前言
部分练习题摘录自：Sun-Java程序员认证考试题库
部分练习题加入了自己的解析
若对JavaSE某些知识点不熟悉，可以看下我有关JavaSE知识点总结的文章
还未整理完，待更
若有错误或补充，欢迎私信
一、Java入门
-
下列哪项不是JDK所包含的内容？（选一项）C
A. Java编程语言 B. 工具及工具的API C. Java EE扩展API D. Java平台虚拟机 -
下列关于JDK、JRE和JVM的描述。哪项正确？D
A. JDK中包含了JRE，JVM中包含了JRE B. JRE中包含了JDK，JDK中包含了JVM C. JRE中包含了JDK，JVM中包含了JRE D. JDK中包含了JRE，JRE中包含了JVM -
下列哪个工具可以编译java源文件？A
A. javac B. jdb C. javadoc D. junit -
JDK工具javadoc的作用是哪项？A
A. 生成Java文档 B. 编译Java源文件 C. 执行Java类文件 D. 测试Java代码 -
以下哪些包是Java标准库中常用的包？（选三项）ACD
A. java.lang B. javax.servlet.http C. java.io D. java.sql -
使用JDK工具生成的Java文档的文件格式是？D
A. XML格式 B. 自定义格式 C. 二进制格式 D. HTML格式 -
以下关于JVM的叙述，哪项正确？（选两项）AC
A. JVM运行于操作系统之上，它依赖于操作系统 B. JVM运行于操作系统之上，它与操作系统无关 C. JVM支持Java程序运行，它能够直接运行Java字节码文件 D. JVM支持Java程序运行，它能够直接运行Java源代码文件 注：Java跨平台，但每一种操作系统都有自己对应的JVM -
以下关于支持Java运行平台的叙述，哪项错误？C
A. Java可在Solaris平台上运行 B. Java可在Windows平台上运行 C. Java语言与平台无关。Java程序的运行结果依赖于操作系统 D. Java语言与平台无关。Java程序的运行结果与操作系统无关 -
以下关于Applet和Java程序之间关系的叙述，哪项错误？B
A. 一个Applet就是一段Java程序 B. Applet是一种特殊的Java程序，它需要运行在Web服务器上 C. Applet是一种特殊的Java程序，它需要运行在Web浏览器上 D. Applet是一种Java SE平台的应用程序 -
以下关于Java HotSpot的描述，哪两项错误？（选两项）AD
A. JavaHotSpot是一种热编译技术，在编译Java源程序时会被使用 B. Java HotSpot是一种热编译技术，在运行Java代码时会被使用 C. Java HotSpot是一种热编译技术，它只对程序的部分字节码进行优化 D. Java HotSpot是一种热编译技术，它会对程序的全部字节码进行优化 -
环境变量PATH中含有多个路径时，路径和路径之间可以用哪项来隔开？A
A. ; B. , C. * D. | -
CLASSPATH中的"."的含义是哪项？B
A. 省略号 B. 当前目录 C. 所有目录 D. 上级目录 -
JVM在执行一个Java类时，大致采用以下过程？D
A. 执行类中的代码->装载类->校验类 B. 校验类->装载类->执行类中的代码 C. 装载类->执行类中的代码->校验类 D. 装载类->校验类->执行类中的代码 注：考察类加载 -
当运行个Java程序时，传递参数的格式是哪项？C
A. java 类名 参数1, 参数2 B. javac 类名 参数1 参数2 C. java 类名 参数1 参数2 D. java 类名 参数1 + 参数2 -
以下关于Java文件名的叙述，正确的有？（选两项）AB
A. Java源文件的扩展名应为.java B. Java源文件的文件名应与文件中的类名一致 C. Java字节码文件的扩展名应为.java D. 一个Java源文件中只能包含一个Java类
二、数据类型和运算符
-
下列哪项不属于Java语言的基本数据类型？B
A. int B. String C. double D. boolean -
下列哪项不是int类型的字面量？A
A. \u03A6 B. 077 C. 0xABBC D. 20 -
下列哪项不是有效的标识符？B
A. userName B. 2test C. $change D. _password -
下列哪项是Java语言中所规定的注释样式？（选三项）ACD
A. // 单行注释 B. --单行注释 C. /* * 单行或多行注释 */ D. /** * 文档注释 */ -
下列哪项不是Java语言的关键字？B
A. goto B. sizeof C. instanceof D. volatile -
现有如下五个声明：哪行无法通过编译？D
Line1: int a_really_really_really_long_variable_name = 5; Line2: int _hi = 6; Line3: int big = Integer.getInteger("7"); Line4: int $dollars = 8; Line5: int %opercent = 9; A. Line1 B. Line3 C. Line4 D. Line5 -
下面程序结果为：D
class Top { static int x = 1; public Top(int y) { x *= 3; } } class Middle extends Top { // 由于父类有了有参构造就不会默认提供无参构造 // 因此子类所有构造中需要显示调用父类有参构造 public Middle() { x += 1; } public static void main(String[] args) { Middle m = new Middle(); System.out.println(x); } } A. 1 B. 2 C. 3 D. 编译失败 -
下面程序结果为：A
class Passer f { static final int x = 5; public static void main(String[] args) { new Passer().go(x); // 打印的是成员变量x System.out.print(x); } void go(int x) { // 打印的是值传递过来的x System.out.print(x++); } } A. 55 B. 56 C. 65 D. 66 -
下面程序结果为：B
class Wrench { public static void main(String[] args) { Wrench w = new Wrench(); Wrench w2 = new Wrench(); // 返回w赋给w2 w2 = go(w, w2); System.out.print(w2 == w); } static Wrench go(Wrench wrl, Wrench wr2) { Wrench wr3 = wrl; wrl = wr2; wr2 = wr3; // w3只赋值一次，值为wrl return wr3; } } A. false B. true C. 编译失败 D. 运行的时候有异常抛出 -
下面程序结果为：A
class Wrench2 { int size; public static void main(String[] args) { Wrench2 w = new Wrench2(); w.size = 11; Wrench2 w2 = go(w, w.size); System.out.print(w2.size); } // s为值传递 static Wrench2 go(Wrench2 wr, int s) { s = 12; return wr; } } A. 11 B. 12 C. 编译失败 D. 运行的时候有异常抛出 -
下面程序哪一句是错误的？B
class Test2 { public static void main(String[] args) { short a, b, c; a = 1; b = 2; // short + short在运算时会提升为int c = a + b; a += 2; } } A. a = 1; B. c = a + b; C. a += 2; D. short a, b, c; -
表达式：1 - 2 / 5 + 2 * 5的结果是哪项？D
A. 10.6 B. 9.8 C. 9 D. 11 -
sl的结果是哪项：A
String s = "123"; String sl = s + 456; A. 123456 B. 579 C. 编译错误 D. 运行时抛出异常 -
基本数据类型float的包装类是哪项？C
A. Integer B. Double C. Float D. Character -
下面程序结果为：D
class Test4 { public static void main(String[] args) { boolean x = true; boolean y = false; short z = 42; // true && true; y被赋值为true; 执行完方法体后z的值为44 if ((z++ == 42) && (y = true)) z++; // false || true; z的值为46 if ((x = false) || (++z == 45)) z++; System.out.println("z=" + z); } } A. z=42 B. z=44 C. z=45 D. z=46
三、流程控制与数组
-
下面程序结果为：D
class TestApp { public static void main(String[] args) { for (int i = 0; i < 10; i++) { if (i == 3) break; System.out.print(i); } } } A. 0123 B. 012456789 C. 0123456789 D. 012 -
下面程序结果为：B
class TestApp { public static void main(String[] args) { int x = 6; if (x > 1) System.out.println("x>l"); else if (x > 5) System.out.println("x>5"); else if (x < 10) System.out.println("x<lO"); else if (x < 29) System.out.println("x<29"); else System.out.println("以上都不是"); } } A. x>5 B. x>1 C. x<10 D. x<29 -
下面程序结果为：C
class TestApp { public static void main(String[] args) { int[] myarray = {10, 11, 12, 13, 14}; int sum = 0; for (int x : myarray) sum += x; System.out.println("sum=" + sum); } } A. sum=10 B. sum=70 C. sum=60 D. 运行时抛出异常 -
下列有关数组的声明中，正确的是哪项？（选两项）CD
A. int s[ 10]; B. int[10]s; C. int[] s = {1, 2, 3, 4, 5}; D. int s[]; -
已知数组array，其最后一个元素的下标是？B
A. array.size B. array.length - 1 C. array.size - 1 D. array.length -
下面程序结果为：B
class TestApp { public static void main(String[] args) { int x = 5; switch (x) { case 1: case 2: case 3: System.out.println("一季度"); break; case 4: case 5: case 6: System.out.println("二季度"); break; default: System.out.println("三季度以上"); break; } } } A. 一季度 B. 二季度 C. 三季度以上 D. 无输出 -
为将数组myArray的长度由3改为6，现采取以下编码：D
int[] myArray = new int[3]; // 改变了myArray的引用而已 myArray = new int[6]; A. 数组myArray的长度已由3改为6，其中前3个元素的值不变，后3个元素的值为空 B. 数组myArray的长度已由3改为6，其中前3个元素的值不变，后3个元素需再经过初始化后才能使用 C. 数组myArray的长度没有变化 D. 数组myArray的长度已由3改为6，原来3个元素的值全部丢失 -
下面程序结果为：A
class Ifs { public static void main(String[] args) { boolean state = false; int i = 2; // true && true; i = 4, state = true if ((++i > 2) && (state = true)) i++; // true || false; i = 6 if ((++i > 4) || (state = false)) i++; System.out.println(i); } } A. 6 B. 5 C. 4 D. 编译失败 -
下面程序结果为：C
public class Tester { public static void main(String[] args) { int x = 5; Integer x1 = x; // 5在byte区间内，因此x2会使用x1的缓存，不会new，因此x2和x1为同一个对象 Integer x2 = x; // Integer会自动拆箱成int int x3 = new Integer(5); // x, x1, x2, x3值均为5 // Integer重写了equals System.out.print(x1.equals(x)); // true // Integer与int进行==比较时，Integer会拆箱成一个int System.out.print(x1 == x); // true System.out.print(x2.equals(x1)); // true System.out.print(x2 == x1); // true System.out.print(x2 == x3); // true System.out.print(x2.equals(x3)); // true } } A. 编译失败 B. falsefalsetruetruetruetrue C. truetruetruetruetruetrue D. falsefalsetruetruetruefalse E. truefalsetruefalsefalsetrue F. 运行时异常被抛出 -
下面程序结果为：A
class Rectangle { public static void main(String[] args) { int[] x = {1, 2, 3}; // 2 > 1因此x[1]值为x[2]=3 x[1] = (x[1] > 1) ? x[2] : 0; System.out.println(x[1]); } } A. 3 B. 2 C. 1 D. 0 -
下面程序结果为：C
class Output { public static void main(String[] args) { int i = 5; System.out.print("4" + i + ""); System.out.print(i + 5 + "7"); System.out.println(i + "8"); } } A. 9 9722 B. 9 55758 C. 45 10758 D. 45 9722 -
以下哪种初始化数组的方式是错误的？C
A. String[] names = {"zhang", "wang", "li"}; B. String names[] = new String[3]; names[0] = "zhang"; names[1] = "wang"; names[2] = "li"; C. String[3] names = {"zhang", "wang", "li"}; D. 以上皆正确 -
下面程序结果为：A
class WhileTests { public static void main(String[] args) { int x = 5; // 先++x为6，>4不会进入循环体，会直接输出 while (++x < 4) { --x; } System.out.println("x=" + x); } } A. x=6 B. x=5 C. x=2 D. 编译失败 -
下面程序结果为：B
class Test2 { public static void main(String[] args) { boolean x = true; boolean y = false; short z = 20; // true && true; y=true, z=21 if ((x == true) && (y = true)) z++; // true然后短路; z=22 if ((y == true) || (++z == 22)) z++; System.out.println("z=" + z); } } A. z=21 B. z=22 C. z=23 D. z=24 -
下面程序结果为：B
class Foo { public static void main(String[] args) { int x = 0; int y = 4; for (int z = 0; z < 3; z++, x++) { /* z x y 0 0 4 1 1 5 2 2 6 3 3 8 */ // &不会短路 if (x > 1 & ++y < 10) y++; } System.out.println(y); } } A. 7 B. 8 C. 10 D. 12
四、封装
-
下列有关类、对象和实例的叙述，正确的是哪一项？D
A. 类就是对象，对象就是类，实例是对象的另一个名称，三者没有差别 B. 对象是类的抽象，类是对象的具体化，实例是对象的另一个名称 C. 类是对象的抽象，对象是类的具体化，实例是类的另一个名称 D. 类是对象的抽象，对象是类的具体化，实例是对象的另一个名称 -
下列类Account的构造方法中，声明正确的是？A
A. Account(String name) {} B. Account(String name) C. Account(name) () D. NewAccount(String name) {} -
类Account中字段声明正确的是哪项？C
A. class Account { name; amount; } B. class Account { String name = 1.0; double amount = "Mike"; } C. class Account { String name; double amount; } D. class Account { String name = "Mike", double amount = 1000.0; } -
类Account中方法声明正确的是哪一项？C
A. class Account { deposit(); } B. class Account { void deposit(); } C. class Account { void deposit() {} } D. class Account { void deposit{} } -
下列有关类声明的代码片段，哪一项是正确的？A
A. package school; import java.sql.*; class Student { } B. import java.sql.*; package school; class Student { } C. package school; class Student { } import java.sql.*; D. package school; import java.sql.*; private String name; class Student { } -
有关new关键字的描述正确的是哪项？C
A. 创建对象实例的时候可以不使用new关键字 B. new所创建的对象不占用内存空间 C. new会调用类的构造器来创建对象 D. new所创建的对象一定存在引用变量 -
下列哪些是方法public int add(int a)的重载方法？（选三项）ACD
A. public int add(long a); B. public void add(int a); C. public void add(long a); D. public int add(float a); -
我们定义一个Account类来描述银行账户，银行账户有账户名、金额等属性特征，同时有存款、取款等行为特征，下述代码适合描述的是哪项？C
A. class Account { String name; // 账户 String amount; // 金额 Account(String name) { } void deposit(double mount) { // 存款 } void withdraw(double mount) { // 取款 } } B. class Account { String name; // 账户 double amount; // 金额 Account(double amount) { } void deposit(double mount) { //存款 } void withdraw(double mount) { //取款 } } C. class Account { String name; // 账户 double amount; // 金额 Account(String name) { } void deposit(double mount) { // 存款 } void withdraw(double mount) { // 取款 } } D. class Account { String name; // 账户 double amount; // 金额 Account(String name) { } void deposit() { // 存款 } void withdraw() { // 取款 } } -
下面程序结果为：C
class Banana2 { static int x = 2; public static void main(String[] args) { int x = 2; Banana2 b = new Banana2(); // 传递的是局部的x b.go(x); } static { x += x; } void go(int x) { ++x; System.out.println(x); } } A. 7 B. 5 C. 3 D. 2 -
可以添加多少个修饰符来封装下面的类？D
/** * 权限 final * 权限 abstract * 若是内部类还可以加static */ class TestFoo { int x; String y; int getX() { return x; } String getY() { return y; } void setX(int x) { int Z = 7; this.x = x; } } A. 5 B. 4 C. 3 D. 2 -
正确使用下列枚举类型的语句是哪项？B
public enum Direction { EAST, SOUTH, WEST, NORTH } // EAST需要通过Direction来调用，且变量名不能和类型一样 Direction Direction = EAST; // 正确 Direction direction = Direction.WEST; // 枚举的成员也是该枚举类型 int a = Direction.NORTH; // 不能把int型赋值给枚举 Direction direction = 2; A. 第一句 B. 第二句 C. 第三句 D. 第四句 -
在注释处插入哪项代码，可以使程序正常编译和执行？C
定义类： package utils; public class Rep { public static String twice(String s) { return s + s; } } 再定义另一个类Demo： // insert code here public class Demo { public static void main(String[] args) { System.out.println(twice("Hello")); } } A. import utils.*; B. import utils.Rep.*; C. import static utils.Rep.twice; D. static import utils.Rep.twice; -
在Here处可以访问的变量是哪些？（选三项）ABD
public class TestDemo { private int x = 2; static int y = 3; public void method() { final int i = 100; // 局部内部类只能访问final的局部变量，在JDK1.8之后，若没有加final则会默认加上 int j = 10; class Cinner { public void mymethod() { // Here } } } } A. x B. y C. j D. i -
哪三个必须加入到类Test中，以使其通过编译？（选三项）BCD
包结构： com |---X | |---Alpha.class | | | |---y | |---Beta.class | |---Gamma.class 类： class Test { Alpha a; Beta b; Gamma c; } A. package y; B. package com; C. import com.x.y.*; D. import com.x.*; -
哪两项分别插入到类Find的注释处将编译并产生输出“doX”？（选两项）CD
2个文件： package x; public class X { public static void doX() { System.out.print("doX"); } } 和 class Find { public static void main(String[] args) { // insert code here } } A. doX(); B. X.doX(); C. x.X.doX(); D. x.X myX = new x.X();myX.doX();
五、继承
-
下列关于继承优点的叙述正确的是哪几项？（选三项）ABD
A. 可以创建更为特殊的类型 B. 消除重复代码 C. 执行效率高 D. 便于维护 -
在子类中调用父类中被覆盖的方法时需要使用哪项关键字？B
A. this B. super C. new D. 以上都不是 -
下列哪个声明是正确的覆盖了父类的change方法？C
public class Parent { public void change(int x) { } } public class Child extends Parent { // 覆盖父类change方法 } A. protected void change(int x) {} B. public void change(int x, int y) {} C. public void change(int x) {} D. public void change(String s) {} 注：子类重写时访问权限不能比父类的低 -
如果想要一个类不能被任何类继承的话，需要使用哪个关键字来修饰该类？D
A. abstract B. new C. static D. final -
为了使得System.out.println()输出对象引用的时候得到有意义的信息，我们应该覆盖Object的哪个方法？B
A. equals B. toString C. hashCode D. notify -
下列哪项是正确的？C
public class Pet {} public class Cat extends Pet {} 执行代码： Cat c = new Cat(); // 子类可以转为父类 Pet p = (Pet) c; A. Pet p = (Pet) c运行错误 B. Pet p = (Pet) c编译错误 C. Pet p = (Pet) c正常执行 D. 以上都不对 -
程序输出的内容是哪项？D
public class Pet { public void speak() { System.out.print("pet"); } } public class Cat extends Pet { public void speak() { System.out.print("Cat"); } } public class Dog extends Pet { public void speak() { System.out.print("Dog"); } } 执行代码： Pet[] p = {new Cat(), new Dog(), new Pet()}; for (int i = 0; i < p.length; i++) p[i].speak(); B. Cat Cat Cat C. Cat Dog Dog D. Cat Dog Pet -
下面哪一项是正确的？D
class Dog {} class Harrier extends Dog {} class DogTest { public static void main(String[] args) { Dog dl = new Dog(); Harrier hl = new Harrier(); Dog d2 = hl; Harrier h2 = (Harrier) d2; // d2为Dog类型，不能把父类赋值给子类 Harrier h3 = d2; } } A. 2个Dog对象被创建 B. 2个Harrier对象被创建 C. 3个Harrier对象被创建 D. 编译失败 -
下面程序结果为：C
class Cat { Cat(int c) { System.out.print("cat" + c + " "); } } class SubCat extends Cat { SubCat(int c) { super(5); System.out.print("cable"); } SubCat() { this(4); } public static void main(String[] args) { /** * 调用子类无参构造 * 子类无参构造中调用了子类有参构造 * 子类有参构造先调用了父类有参构造，先输出：cat5 * 然后输出cable */ SubCat s = new SubCat(); } } A. cat5 B. cable C. cat5 cable D. cable cat5 -
下面程序结果为：A
class Guy { String greet() { return "hi"; } } class Cowboy extends Guy { String greet() { return "howdy"; } } class Surfer extends Guy { String greet() { return "dude! "; } } class Greetings { public static void main(String[] args) { Guy[] guys = {new Guy(), new Cowboy(), new Surfer()}; for (Guy g : guys) System.out.print(g.greet()); } } A. hi howdy dude! B. 运行时异常被抛出 C. 第7行出现一个错误，编译失败 D. 第8行出现一个错误，编译失败 -
将下面四个方法分别插入到注释处，有几个可以通过编译？D
class Over { int dolt(long x) { return 3; } } class Under extends Over { // insert code here } 四个方法： // 子类方法，没有重写 short dolt(int y) {return 4;} // 子类方法，没有重写 int dolt(long x, long y) {return 4;} // 子类方法，没有重写 private int dolt(short y) {return 4;} // 子类重写父类方法 protected int dolt(long x) {return 4;} A. 1 B. 2 C. 3 D. 4 -
下面程序结果为：D
class Beverage { Beverage() { System.out.print("beverage "); } } class Beer extends Beverage { public static void main(String[] args) { Beer b = new Beer(); } public int Beer(int x) { // 对构造的调用：只能出现在其他构造的第一句 this(); System.out.print("beerl"); return 0; } public Beer() { System.out.print("beer2 "); } } A. beerl beverage B. beer2 beverage C. beverage beer2 beerl D. 编译失败 -
下面程序结果为：C
class Bird { void talk() { System.out.print("chirp "); } } class Parrot2 extends Bird { protected void talk() { System.out.print("hello "); } public static void main(String[] args) { Bird[] birds = {new Bird(), new Parrot2()}; for (Bird b : birds) b.talk(); } } A. chirp chirp B. hello hello C. chirp hello D. 编译错误 -
下面四个声明分别插入到注释处，有几个可以通过通过？C
class SuperFoo { SuperFoo doStuff(int x) { return new SuperFoo(); } } class Foo extends SuperFoo { // insert code here } 四个声明： Foo doStuff(int x) { return new Foo(); } // 父类不能被赋值给子类 Foo doStuff(int x) { return new SuperFoo(); } // 子类可以赋值给父类 SuperFoo doStuff(int x) { return new Foo(); } SuperFoo doStuff(int y) { return new SuperFoo(); } A. 1 B. 2 C. 3 D. 4 -
下列选项分别插入到注释处，哪两项允许代码编译并产生“bok choy”输出结果？（选两项）AD
class HorseRadish { // insert code here protected HorseRadish(int x) { System.out.println("bok choy"); } } class Wasabi extends HorseRadish { public static void main(String[] args) { Wasabi w = new Wasabi(); } } A. protected HorseRadish() {this(42);} B. protected HorseRadish() {} C. // just a comment D. protected HorseRadish() {new HorseRadish(42);} 注：要编译通过必须插入一个无参构造；要产生“bok choy”，则无参构造中需调用有参构造
六、抽象类与接口
-
下列有关抽象类的叙述正确的是哪项？B
A. 抽象类中一定含有抽象方法 B. 抽象类的声明必须包含abstract关键字 C. 抽象类既能被实例化也能被继承 D. 抽象类中不能有构造方法 -
下列有关抽象方法叙述正确的是哪项？（选两项）BD
A. 抽象方法和普通方法一样，只是前面多加一个修饰符asbtract B. 抽象方法没有方法体 C. 抽象方法可以包含存任何类中 D. 包含抽象方法的类的具体子类必须提供具体的覆盖方法 -
下列有关接口的叙述错误的是哪项？D
A. 接口中只能包含抽象方法和常量 B. 一个类可以实现多个接口 C. 类实现接口时必须实现其中的方法 D. 接口不能被继承 -
下列关于接口的定义哪项是正确的？C
A. interface C {int a;} // 常量需要被初始化 B. public interface A implements B {} // 类实现接口，接口继承接口 C. public interface A {int a();} D. abstract interface D {} // 定义接口不能使用abstract -
以下三个接口声明分别插入到注释处，有多少个可以编译？C
interface Animal { void eat(); } // insert code here public class HouseCat implements Feline { public void eat() { } } 三个接口声明： interface Feline extends Animal {} interface Feline extends Animal {void eat();} // 接口中只能是抽象方法 interface Feline extends Animal {void eat() {}} A. 0 B. 1 C. 2 D. 3 -
以下六个声明分别插入到注释处，有多少行可以编译？B
interface Color {} interface Weight {} //insert code here 六个声明： class Boat extends Color, extends Weight {} class Boat extends Color and Weight {} class Boat extends Color, Weight {} class Boat implements Color, implements Weight {} class Boat implements Color and Weight {} class Boat implements Color, Weight {} A. 0 B. 1 C. 2 D. 3 注：类是实现接口，实现多个接口时以","分割 -
以下四个声明分别插入到注释处，有几个可以通过编译？C
abstract class Color { protected abstract String getRGB(); } public class Blue extends Color { // insert code here } 四个声明： public String getRGB() { return "blue"; } String getRGB() { return "blue"; } private String getRGB() { return "blue"; } protected String getRGB() { return "blue"; } A. 0 B. 1 C. 2 D. 3 注：子类重写时访问权限不能比父类的低 -
以下四个声明分别插入到注释处，有几个可以通过编译？D
abstract class Color2 { //insert code here } public class Blue2 extends Color2 { public String getRGB() { return "blue"; } } 四个声明： public abstract String getRGB(); abstract String getRGB(); private abstract String getRGB(); protected abstract String getRGB(); A. 0 B. 1 C. 2 D. 3 private和abstract不能一起用，因为矛盾 -
下面程序结果为：C
class Top { static int x = 1; public Top() { x *= 3; } } class Middle extends Top { public Middle() { // super();x=3 x += 1; // x=4 } public static void main(String[] args) { Middle m = new Middle(); System.out.println(x); } } A. 2 B. 3 C. 4 D. 编译失败 -
下面程序结果为：D
两个文件： package x; public class X { public static void doX() { System.out.print("doX "); } } 和 import x.X; class Find { public static void main(String[] args) { X myX = new X(); // 对象调用方法，输出doX myX.doX(); // 类调用静态方法，输出doX X.doX(); // 类调用静态方法，输出doX x.X.doX(); x.X myX2 = new x.X(); // 对象调用方法，输出doX myx2.doX(); } } A. X myX = new X();行出现一个错误，编译失败 B. X.doX();行出现一个错误，编译失败 C. x.X.doX();行出现一个错误，编译失败 D. doX doX doX doX -
下面程序结果为：C
class Tree { private static String tree = "tree "; String getTree() { return tree; } } class Elm extends Tree { private static String tree = "elm "; public static void main(String[] args) { new Elm().go(new Tree()); } void go(Tree t) { // Tree的getTree()返回tree // Elm.tree为elm // tree先在本类成员找，为elm // new Elm().getTree()调用父类方法，返回tree String s = t.getTree() + Elm.tree + tree + (new Elm().getTree()); System.out.println(s); } } A. elm elm elm elm B. tree elm elm elm C. tree elm elm tree D. tree elm tree elm -
以下五个声明分别插入到注释处，有几个可以通过编译？C
interface Animal { void eat(); } //insert code here public class HouseCat extends Feline { public void eat() { } } 五个声明： // 通过 abstract class Feline implements Animal {} // 不通过，类中抽象方法要用abstract声明 abstract class Feline implements Animal {void eat();} // 不通过，类中抽象方法要用abstract声明 abstract class Feline implements Animal {public void eat();} // 通过 abstract class Feline implements Animal {public void eat() {}} // 通过 abstract class Feline implements Animal {abstract public void eat();} A. 1 B. 2 C. 3 D. 4 -
下面程序结果为：D
interface I {void go();} abstract class A implements I {} class C extends A { // 接口中方法为public，实现类重写后也要是public void go() {} } A. 代码通过编译 B. 由于x interface I {void go();}行的错误导致编译失败 C. 由于abstract class A implements I {}行的错误导致编译失败 D. 由于void go() {}行的错误导致编译失败 -
下列类定义中正确使用Data和Info的是哪项？B
interface Data {public void load();} abstract class Info {public abstract void load();} // 类实现接口不是继承 A. public class Employee implements Info extends Data { public void load() {/*do something*/} } // 正确 B. public class Employee extends Inf implements Data { public void load() {/*do something*/} } // 在Data中load不是静态方法 C. public class Employee implements Inf extends Data { public void Data.load() {/*do something*/} public void load() {/*do something*/} } // 在Data和Info中load不是静态方法 D. public class Employee extends Inf implements Data { public void Data.load() {/*do something*/} public void Info.load() {/*do something*/} } -
下列代码正确的是哪项？C
A. public class Session implements Runnable, Clonable { // 没有方法体 public void run(); public Object clone(); } // 类实现接口，不是继承接口 B. public class Session extends Runnable, Cloneable { public void run() {/*do something*/} public Object clone() {/*make a copy*/} } // 正确 C. public abstract class Session implements Runnable, Clonable { public void run() {/*do something*/} public Object clone() {/*make a copy*/} } // 语法错误，只能用一个implements D. public class Session implements Runnable, implements Clonable { public void run() {/*do something*/} public Object clone() {/*make a copy*/} }
七、多态
-
下列关于多态的叙述正确的是哪项？（选两项）AC
A. 父类的引用指向子类的实例是一种多态 B. 子类的引用指向子类的实例是一种多态 // 接口的实例即接口实现类的实例 C. 接口的引用指向实现该接口类的实例是一种多态 D. 抽象类的引用指向抽象类的实例是一种多态 -
Java中方法绑定有哪些形式？（选两项）AB
A. 编译时刻绑定 B. 运行时刻绑定 C. 静态绑定 D. 私有绑定 -
表达式"hello" instanceof String返回的值是哪项？A
A. true B. false C. 1 D. 0 -
求平方根方法public static double sqrt(double a)可以传递的参数类型有哪些？（选三项）ABD
A. byte B. float C. String D. long -
涉及类MyClass的方法签名是public void find(MyClass a)，那么该方法可接收的实际参数的类型可以是哪些？（选两项）AB
A. MyClass类的类型 B. MyClass子类的类型 C. Object类型 D. 所有接口 -
使用下列哪些关键字可以判定实参的具体类型？C
A. as B. is C. instanceof D. extends -
下面程序结果为：C
现有： class Pencil { public void write(String content) { System.out.println("Write" + content); } } class RubberPencil extends Pencil { public void erase(String content) { System.out.println("Erase" + content); } } 执行下列代码： Pencil pen = new RubberPencil(); pen.write("Hello"); // 编译时pen是Pencil类型，没有erase方法 pen.erase("Hello"); A. Write Hello Erase Hello B. Erase Hello Write Hello C. 编译错误 D. 运行时抛出异常 -
下面程序结果为：B
现有： class Pencil { public void write(String content) { System.out.println("Write" + content); } } class RubberPencil extends Pencil { public void write(String content) { System.out.println("Rubber Write" + content); } public void erase(String content) { System.out.println("Erase " + content); } } 执行下列代码： Pencil pen = new RubberPencil(); // 非静态成员方法执行时看右边 pen.write("Hello"); A. Write Hello B. Rubber Write Hello C. 编译错误 D. 运行时抛出异常 -
下列哪些方法是在编译时刻绑定的？（选三项）ABC
A. 静态方法 B. private方法 C. final方法 D. 非private方法 -
下面程序结果为：D
现有： class Pencil { public void write(String content) { System.out.println("Write" + content); } } class RubberPencil extends Pencil { public void write(String content) { System.out.println("Rubber Write" + content); } public void erase(String content) { System.out.println("Erase " + content); } } 执行下列代码： Pencil pen = new Pencil(); // 本体为父类，强转为子类会在运行时抛出类转换异常 ((RubberPencil) pen).write("Hello"); A. Write Hello B. Rubber Write Hello C. 编译失败 D. 运行时抛出异常 -
下面程序结果为：B
class TestA { public void start() { System.out.println("TestA"); } } public class TestB extends TestA { public void start() { System.out.println("TestB"); } public static void main(String[] args) { /* 相当于： TestA testA = new TestB(); testA.start(); */ ((TestA) new TestB()).start(); } } A. TestA B. TestB C. 编译失败 D. 运行时抛出异常 -
下面程序结果为：A
class A {public String name = "a";} class B extends A {public String name = "b";} 执行下列代码： A a = new B(); // 成员变量看左边 System.out.println(a.name); A. a B. b C. 编译失败 D. 运行时抛出异常 -
下列哪行代码插入到注释处，将抛出java.lang.ClassCaseException异常？B
interface F {} class A implements F {} class B extends A {} class C extends B { public static void main(String[] args) { B b = new B(); // insert code here } } A. A a = b; // b本体是B，转为子类C会抛出类转换异常 B. F f = (C) b; C. F f = (A) b; D. B bb = (B) (A) b; 注：父类不能赋值给子类，子类可以赋值给父类 -
下面程序结果为：B
class Guy { String greet() { return "hi"; } } class Cowboy extends Guy { String greet() { return "howdy"; } } class Wrangler extends Cowboy { String greet() { return "orch!"; } } class Greetings2 { public static void main(String[] args) { Guy g = new Wrangler(); Guy g2 = new Cowboy(); Wrangler w2 = new Wrangler(); // 非静态成员方法看右边 System.out.print(g.greet() + g2.greet() + w2.greet()); } } A. hi hi ouch! B. ouch! howdy ouch! C. hi howdy ouch! D. 编译失败 E. 运行的咐候有异常抛出 -
下列哪些是正确的？（选三项）AEF
现有： class ClassA {} class ClassB extends ClassA {} class ClassC extends ClassA {} 以及： ClassA p0 = new ClassA(); ClassB p1 = new ClassB(); ClassC p2 = new ClassC(); ClassA p3 = new ClassB(); ClassA p4 = new ClassC(); // 子类B赋值给父类A A. p0 = p1; // C赋值给B，C和B没关系，错误 B. p1 = p2; // 父类A赋值给子类C，错误 C. p2 = p4; // 本体B强转为C，C和B没关系，错误 D. p2 = (ClassC) p1; // 本体B强转为B E. p1 = (ClassB) p3; // 本体C强转为C F. p2 = (ClassC) p4;
八、异常
-
Java语言中异常的分类是哪项？B
A. 运行时异常和异常 B. 受检异常和非受检异常 C. 错误和异常 D. 错误和运行时异常 -
所有异常的父类是哪项？A
A. Throwable B. Error C. RuntimeException D. Exception 注：Error错误和Exception异常都继承了Throwable -
关于try...catch...finally结构，描述正确的是哪项？（选两项）AC
A. 可以有多个catch B. 只能有一个catch C. 可以没有catch D. finally必须有 注：try必须有，catch和finally只能省略一个 -
下列属于非受检异常的是哪项？CD
A. SQLException B. IOException C. NullPointerException D. OutOfMemoryError -
假设有自定义异常类ServiceException，那么抛出该异常的语句正确的是哪项？B
A. raise ServiceException B. throw new ServiceException() C. throw ServiceException D. throws ServiceException -
在方法的声明中，要求该方法必须抛出异常时使用哪个关键字？D
A. throw B. catch C. finally D. throws -
下面程序结果为：D
class Number { public static void main(String[] aras) { try { System.out.print(Integer.parseInt("forty")); } catch (RuntimeException r) { System.out.print("runtime"); } catch (NumberFormatException e) { // 由于多态，父类异常可以抓住子类异常，因此这里执行不到 System.out.print("number"); } } } A. number B. runtime C. forty number D. 编译失败 -
如果调用topGo()，则结果为：B
void topGo() { try { middleGo(); } catch (Exception e) { System.out.print("catch"); } } void middleGo() throws Exception { // 抛出Exception，后面不执行 go(); System.out.print("late middle"); } void go() throws Exception { throw new Exception(); } A. late middle B. catch C. late middle catch D. catch Iate middle -
下面哪两行分别插入到注释处会导致输“oops”？（选两项）AC
class Calc { public static void main(String[] args) { try { int x = Integer.parseInt("42a"); //insert code here System.out.print("oops"); } } } A. }catch(IllegalArgumentException e){ B. }catch(IllegalStateException c){ C. }catch(NumbelFormatException n){ D. }catch(ClassCastException c){ 注：NumberFormatException继承了IllegalArgumentException -
下面程序可能会产生哪两项结果？（选两项）BC
class Flow { public static void main(String[] args) { try { System.out.print("before"); doRiskyThing(); System.out.print("after "); } catch (Exception fe) { System.out.print("catch"); } System.out.println(" done"); } public static void doRiskyThing() throws Exception { // this code returns unless it throws an Exception } } A. before catch // 没发生异常 B. before after done // 发生异常 C. before catch done D. before after catch -
下面程序结果为：C
class Birds { public static void main(String[] args) { try { throw new Exception(); } catch (Exception e) { try { throw new Exception(); } catch (Exception e2) { System.out.print("inner "); } System.out.print("middle "); } System.out.print("outer"); } } A. inner outer B. middle outer C. inner middle outer D. 编译失败 -
下面程序结果为：B
class Parser extends Utils { public static void main(String[] args) { try { // 使用子类的getlnt，但没发生异常 System.out.print(new Parser().getlnt("42")); } catch (NumberFormatException n) { System.out.println("NFExc"); } } // 父类虽没抛出异常，但子类可以抛出运行时异常 int getlnt(String arg) throws NumberFormatException { return Integer.parseInt(arg); } } class Utils { int getlnt(String arg) { return 42; } } A. NFExc B. 42 C. 42NFExc D. 编译失败 -
下面程序结果为：D
class Parser extends Utils { public static void main(String[] args) { try { System.out.print(new Parser().getlnt("42")); } catch (Exception e) { System.out.println("Exc"); } } // 重写时父类没抛出异常，则子类不能抛出编译时异常 int getlnt(String arg) throws Exception { return Integer.parseInt(arg); } } class Utils { int getlnt(String arg) { return 42; } } A. 42 B. Exc C. 42Exc D. 编译失败 -
为使下列代码通过编译，需要在哪个方法上加入声明throws Exception？D
class Propeller2 { public static void main(String[] args) { new Propeller2().topGo(); } void topGo() { middleGo(); } void middleGo() { go(); System.out.println("late middle"); } void go() { throw new Exception(); } } A. go B. middleGo、go C. topGo、middleGo、go D. main、topGo、middleGo、go 注：不断上抛，直到被catch抓住，或交给JVM -
下面程序结果为：C
class Parser extends Utils { public static void main(String[] args) { try { System.out.print(new Parser().getlnt("42")); } catch (Exception e) { System.out.println("Exc"); } } int getlnt(String arg) throws Exception { return Integer.parseInt(arg); } } class Utils { int getlnt() { return 42; } } A. 42Exc B. Exc C. 42 D. 编译失败
九、多线程机制
-
线程由以下哪些部分组成？（选三项）ABD
A. 虚拟的CPU B. CPU执行的代码 C. 支持代码工作的数据 D. 进程 -
创建线程的时候必须实现哪项接口？A
A. Runnable B. Thread C. Run D. Start -
启动一个线程的方法是哪项？C
A. join() B. run() C. start() D. sleep() -
当一个处于阻塞状态的线程解除阻塞后，它将回到哪个状态？D
A. 运行中状态 B. 结束状态 C. 新建状态 D. 可运行状态 -
可以通过继承哪个类来创建线程？A
A. Thread B. Runnable C. Start D. Run -
为了保证方法的线程安全，声明方法的时候必须用哪个修饰符？D
A. new B. transient C. void D. synchronized -
线程的默认优先级是哪项？C
A. 0 B. 1 C. 5 D. 10 -
下面程序结果为：D
class Thread2 implements Runnable { // 子类实现方法时访问权限不能比父类的低 void run() { System.out.print("go"); } public static void main(String[] args) { Thread2 t2 = new Thread2(); Thread t = new Thread(t2); t.start(); } } A. go B. 运行时异常被抛出 C. 代码运行，无输出结果 D. 编译失败 -
程序员想要创建一个名为MyThread的类以便在main方法中用Thread实例化。对于下面三行有几行是正确的？A
// 实现Runnable或Callable也可以 MyThread必须继承Thread MyThread必须实现Thread // 也可以覆盖Callable的V call() throws Exception; MyThread必须覆盖public void run() A. 0 B. 1 C. 2 D. 3 -
下面程序结果为：A
class ThreadBoth extends Thread implements Runnable { public void run() { System.out.print("hi "); } public static void main(String[] args) { Thread tl = new ThreadBoth(); Thread t2 = new Thread(tl); tl.run(); t2.run(); } } A. hi hi B. hi C. 编译失败 D. 运行时异常被抛出 -
t是一个合法的Thread对象的引用，并且t的合法run()方法如下，则哪一个是结果？C
t的合法run()方法： public void run() { System.out.print("go"); } 及： t.start(); // 一个线程只能启动一次 t.start(); // 一个普通的函数调用 t.run(); A. go go B. go go go C. go之后跟着一个异常 D. go go之后跟着一个异常 -
下面程序结果为：C
class ThreadExcept implements Runnable { public void run() { throw new RuntimeException("exception "); } public static void main(String[] args) { // 抛出异常，没有处理就交给jvm // 不会影响主线程 new Thread(new ThreadExcept()).start(); try { int x = Integer.parseInt(args[0]); // 先睡眠x毫秒，然后输出main Thread.sleep(x); System.out.print("main"); } catch (Exception e) { } } } 和命令行： java ThreadExcept 1000 A. main B. 编译失败 C. java.lang.RuntimeException: exception main D. 代码运行，但没有输出 -
哪一个插入到注释处，最有可能产生输出rmrmrmrm？E
class Order2 implements Runnable { public void run() { for (int x = 0; x < 4; x++) { try { Thread.sleep(100); } catch (Exception e) { } System.out.print("r"); } } public static void main(String[] args) { Thread t = new Thread(new Order2()); t.start(); for (int x = 0; x < 4; x++) { // insert code here System.out.print("m"); } } } A. Thread.sleep(1); B. Thread.sleep(100); C. Thread.sleep(1000); // sleep方法会抛出异常 D. try {Thread.sleep(1);} catch (Exception e) {} // 当两个线程睡眠时间相同时，最有可能按顺序执行，输出rmrmrmrm E. try {Thread.sleep(100);} catch (Exception e) {} F. try {Thread.sleep(1000);} catch (Exception e) {} -
以下哪两项是正确的？（选两项）BF
class Waiting implements Runnable { boolean flag = false; public synchronized void run() { if (flag) { flag = false; System.out.print("1 "); try { this.wait(); } catch (Exception e) { } System.out.print("2 "); } else { flag = true; System.out.print("3 "); try { Thread.sleep(2000); } catch (Exception e) { } System.out.print("4 "); notify(); } } public static void main(String[] args) { Waiting w = new Waiting(); /* 此线程先执行，由于同步，其他线程在此期间进不来 先判断flag为false，将flag置为true 先输出3，然后睡眠2秒，sleep不会释放锁对象 睡眠后输出4，然后执行notify() */ new Thread(w).start(); /* 上面线程先执行，将flag置为了true， 此线程判断为true，然后将flag置为false 然后输出1，等待 因为上面线程已经执行完了，因此此线程不会被唤醒 程序陷入死锁 */ new Thread(w).start(); } } A. 代码输出1 3 4 B. 代码输出3 4 1 C. 代码输出1 2 3 4 D. 代码输出1 3 4 2 E. 代码运行完毕 F. 代码不会完成 -
下面程序可产生哪两项结果？（选两项）AD
class Order implements Runnable { public void run() { try { Thread.sleep(2000); } catch (Exception e) { System.out.print("in"); } } public static void main(String[] args) { Thread t = new Thread(new Order()); // 开启线程，会先睡眠2秒 /* 若睡眠时，main还没拿到CPU 且t线程再次执行时出现异常，则先输出in */ t.start(); // 先输出pre System.out.print("pre "); try { // t执行完main才能执行，过程可能抛出异常，输出in t.join(); } catch (Exception e) { } // 最后执行post System.out.print("post"); } } A. pre in post B. pre in C. in post pre D. in pre post E. pre post in
十、输入输出流
-
下列哪项是Java语言中所定义的字节流？D
A. Output B. Reader C. Writer D. InputStream -
在输入流的read方法返回哪个值的时候表示读取结束？C
A. 0 B. 1 C. -1 D. null -
为了从文本文件中逐行读取内容，应该使用哪个处理流对象？A
A. BufferedReader B. BufferedWriter C. BufferedInputStream D. BufferedOutputStream 注：BufferedReader有readLine()方法 -
为了实现自定义对象的序列化，该自定义对象必须实现哪个接口？B
A. Volatile B. Serializable C. Runnable D. Transient -
以下关于File类的叙述，哪两项正确？（选两项）AD
A. File类位于java.io包中 B. 创建一个File类的实例将导致打开指定文件进行读写 C. File实例不能用于封装目录 D. File实例封装了指定文件的信息 -
删除File实例所对应文件的方法是？C
A. mkdir B. exists C. delete D. isHidden -
下面程序结果为：B
import java.util.*; class ScanStuff { public static void main(String[] args) { String s = "x,yy,123"; // 构造一个新的Scanner，它生成的值是从指定字符串扫描的 // Scanner(String source) Scanner sc = new Scanner(s); // 将字符串中的字符逐个输出 while (sc.hasNext()) System.out.print(sc.next() + " "); } } A. x yy B. x,yy,123 C. x yy 123 D. x,yy E. 编译失败 F. 运行的时候有异常抛出 -
哪一行代码插入到注释处将循环通过一个文本文件并从文本域中每次输出一行？D
现有： 一f对一个java.io.File型实例的合法引用 一fr对一个java.io.FileReader型实例的合法引用 一br对一个java.io.BufferedReader型实例的合法引用 和： String line = null; //insert code here System.out.println(line); } A. while ((line = f.read()) != null) { B. while ((line = fr.read()) != null) { C. while ((line = br.read()) != null) { D. while ((line = br.readLine()) != null) { E. while ((line = fr.readLine()) != null) { F. while ((line = f.readLine()) != null) { 注：readLine()是BufferedReader的方法 -
下面哪一项正确？B
int x = reader.read(); A. 阅读器不是FileReader或者BufferedReader类型 B. 阅读器可以是FileReader或者BufferedReader类型 C. 阅读器可以是FileReader类型，但不能是BufferedReader类型 D. 阅读器可以是BufferedReader类型，但不能是FileReader类型 -
下面哪一项正确？D
String s = "write a line to a file"; w.print(s + "\n"); A. w即可以是PrintWriter类型，也可以是BufferedWriter类型 B. w即不可以是PrintWriter类型，也不可以是BufferedWriter类型 C. w可以是BufferedWriter类型，但不可以是PrintWriter类型 D. w可以是PrintWriter类型，但不可以是BufferedWriter类型 -
下面哪两个是合法的？（选两项）CF
现有： f是一个合法的java.io.File实例的引用 fr是一个合法的java.io.FileReader实例的引用 br是一个合法的java.io.BufferedReader实例的引用 // File(File parent, String child) A. File f2 = new File(f); // FileReader构造不可以传FileReader B. FileReader fr2 = new FileReader(fr); // FileReader构造可以传File C. FileReader fr2 = new FileReader(f); // FileReader构造不可以传BufferedReader D. FileReader fr2 = new FileReader(br); // BufferedReader只能传递Reader及其子类 E. BufferedReader br2 = new BufferedReader(f); F. BufferedReader br2 = new BufferedReader(fr); -
以下哪一项无效？D
现有： f是一个对java.io.File实例的合法引用 fw是一个对java.io.FileWriter实例的合法引用 bw足一个对java.io.BufferedWriter实例的合法引用 // PrintWriter(File file) A. PrintWriter prtWtr = new PrintWriter(f); // PrintWriter(Writer out) B. PrintWriter prtWtr = new PrintWriter(fw); // PrintWriter(Writer out) C. PrintWriter prtWtr = new PrintWriter(bw); // BufferedReader只能传递Reader及其子类 D. BufferWriter bufWtr = new BufferedWritr(f); E. BufferWriter bufWtr = new BufferedWriter(fw); F. BufferWriter bufWtr = new BufferedWriter(bw); -
下面程序结果为：E
import java.io.PrintWriter; class DoFormat { public static void main(String[] args) { int x = 42; int y = 12345; float z = 7; System.out.format("-%4d- ", x); System.out.format("-%4d- ", y); // 应该是%4.1f System.out.format("-%4.1d-", z); } } A. 编译失败 B. -42--1234-- 7.0- C. - 42--1234-- 7.0- D. - 42--12345-- 7.0- E. 运行时异常被抛出 -
如果试图序列化一个Ford实例，结果为：C
class Car implements Serializable {} class Ford extends Car {} A. 编译失败 B. 两个对象被序列化 C. 一个对象被序列化 D. 运行时异常被抛出 一个Ford 如果子类实现Serializable接口而父类未实现时，父类不会被序列化； 如果父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。 -
如果Pet实例被序列化，则多少对象将被序列化？E
class Pet implements Serializable { Collar c = new Collar(); } class Collar implements Serializable { CollarPart cpl = new CollarPart(); CollarPart cp2 = new CollarPart(); } class CollarPart implements Serializable {} A. 0 B. 1 C. 2 D. 3 E. 4 F. 5 一个pet，一个Collar，两个CollarPart 当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化
十一、使用泛型和集合框架
-
集合API中Set接口的特点是哪项？D
A. 不允许重复元素，元素有顺序 B. 允许重复元素，元素无顺序 C. 允许重复元素，元素有顺序 D. 不允许重复元素，元素无顺序 -
实现了Set接口的类是哪项？C
A. ArrayList B. HashTable C. HashSet D. Collection -
表示键值对概念的接口是哪项？D
A. Set B. List C. Collection D. Map -
List接口的特点是哪项？C
A. 不允许重复元素，元素无顺序 B. 不允许重复元素，元素无顺序 C. 允许重复元素，元素有顺序 D. 允许重复元素，元素无顺序 -
下列哪些项是泛型的优点？（选两项）AC
A. 不用向下强制类型转换 B. 代码容易编写 C. 类型安全 D. 运行速度快 -
创建一个只能存放String的泛型ArrayList的语句是哪项？B
A. ArrayList<int> al = new ArrayList<int>(); B. ArrayList<String> al = new ArrayList<String>(); // 创建集合时不写泛型，则可以存储任意引用类型数据 C. ArrayList al = new ArrayList<String>(); // List是接口 D. ArrayList<String> al = new List<String>(); -
下面程序结果为：C
public class Demo { public static void main(String[] args) { List a1 = new ArrayList(); a1.add("l"); a1.add("2"); a1.add("2"); a1.add("3"); System.out.println(a1); } } A. [1, 2, 3] B. [1, 2, 3, 3] C. [1, 2, 2, 3] D. [2, 1, 3, 2] -
哪一行插入到注释处将导致输出“abc"？D
import java.util.*; class ForInTest { static List list = new ArrayList(); public static void main(String[] args) { list.add("a"); list.add("b"); list.add("c"); //insert code here System.out.print(o); } } A. for (Iterator o : list.iterator(); o.hasNext(); ) B. for (Iterator o : list) C. for (Object o : list.iterator()) D. for (Object o : list) 增强for格式：for (元素类型 变量名 : 数组名或集合对象) {} -
下面程序结果为：E
import java.util.*; class AddStuff2 { public static void main(String[] args) { // TreeSet内的元素有一定的顺序 TreeSet<String> t = new TreeSet<String>(); if (t.add("one ")) if (t.add("two ")) if (t.add("three ")) t.add("four "); for (String s : t) System.out.print(s); } } A. one B. one three two C. one two three D. one two three four E. four one three two F. 编译失败 -
哪两个是同步的？（选两项）BC
A. java.util.TreeSet B. java.util.Hashtable C. java.util.Vector D. java.util.LinkedList -
哪两个是合法的？（选两项）BE
list是一个合法的集合引用 getCollection()返回一个合法集合的引用 A. for (Object o ; list) B. for (Object o : getCollection()) C. for (Object o : list.iterator()) D. for (Iterator i; list.iterator(); i.hasNext()) E. for (Iterator i = list.iterator(); i.hasNext(); ) -
哪一组匹配是对的？B
现有如下类型： a - java.util.Hashtable b - java.util.List c - java.util.ArrayList d - java.util.SortedSet 和定义： 1 - 使用本接口，允许用户控制集合中每个元素的插入位置。b 2 - 使用本集合，确保用户可以按照递增或元素的自然顺序遍历集合。d 3 - 本具体类型允许空元素及基于索引的访问。c 4 - 本集合是同步的。a A. 2描述d；3描述b。 B. 1描述b；3描述C。 C. 3描述a；4描述b。 D. 4描述a；2描述C。 -
四个代码片段分别插入到注释处，哪项可以编译？A
现有： import java.util.*; class AddStuff { public static void main(String[] args) { TreeSet<String> s = new TreeSet<String>(); s.add("one"); s.add("two"); //insert code here for (String s2 : sorted) System.out.print(s2 + " "); } } 四个代码片段： // 创建集合时不写泛型，则可以存储任意引用类型数据，而下面要求String s1: SortedSet sorted = s.tailSet(s.first()); s2: SortedSet<String> sorted = s.tailSet(s.first()); s3: SortedSet sorted = (SortedSet) s.tailSet(s.first()); // 泛型不存在继承关系 // 相当于把SortSet<String>赋值给了SortSet<Object>，错误 s4: SortedSet sorted = (SortSet<String>) s.tailSet(s.first()); A. s2 B. s1 C. s2和s3 D. s2和s4 E. s2, s3和s4 F. sl, s2, s3和s4 -
注释处插入哪一项将输出abc？D
class ForInTest { static List list = new ArrayList(); static List getList() { return list; } public static void main(String[] args) { list.add("a"); list.add("b"); list.add("c"); // insert code here System.out.print(o); } } // 题中list中存储的是String A. for (char o : list) B. for (Object o : o.getList()) C. for (Object o : getList() ; ) D. for (Object o : getList()) E. for (Object o : o.getList() ; ) -
下列选项分别插入到注释处，哪三行允许代码编译？（选三项）BDF
import java.util.*; class FindStuff { public static void main(String[] args) { //insert code here c.put("X", 123); } } // SortedMap是抽象类，不能实例化 A. Map c = new SortedMap(); B. HashMap c = new HashMap(); // Hashtable和HashMap没关系 C. HashMap c = new Hashtable(); D. SortedMap c = new TreeMap(); // ArrayList没有put方法 E. ArrayList c = new ArrayList(); F. Map c = new LinkedHashMap();
