java选择题错题集锦（持续更新）

关于以下application,说法正确是什么？
public class Test {

static int x=10;
static {x+=5;}
public static void main(String[] args) //4
    {
    System.out.println("x="+x);
}
static{x/=3;};

}//9
正确答案: B 你的答案: D (错误)
4行与9行不能通过编译，因为缺少方法名和返回类型
编译通过，执行结果是：x=5
编译通过，执行结果是：x=3
9行不能通过编译，因为只能有一个静态初始化器

注：一个静态代码块在整个程序执行的过程中只执行一次，但一个class可以有多个静态代码块，且都会被执行。所以此题static{x/=3;};也会执行。

class A{

static {
    System.out.print("--父类静态代码块--");
}
public A(){
    System.out.print("--父类构造方法--");
}
{
    System.out.print("--父类初始化块--");
}

}
public class demo8 extends A{

static{
    System.out.print("--子类静态代码块--");
}
public demo8(){
    System.out.print("--子类构造方法--");
}
{
    System.out.print("--子类初始化块--");
}
public static void main(String[] args){
    new demo8();
}

}
//–父类静态代码块----子类静态代码块----父类初始化块----父类构造方法----子类初始化块----子类构造方法–
//静态代码块 优先于 main 优先于 构造代码块 优先于 构造方法

---

ResultSet中记录行的第一列索引为？
正确答案: C 你的答案: B (错误)
A.-1
B.0
C.1
D.以上都不是
注：**结果集(ResultSet)**是数据中查询结果返回的一种对象，可以说结果集是一个存储查询结果的对象，但是结果集并不仅仅具有存储的功能，他同时还具有操纵数据的功能，可能完成对数据的更新等。 ResultSet跟普通的数组不同，索引从1开始而不是从0开始。

---

假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（）
public static void main(String[]args)throws Exception {

final Object obj = new Object();
Thread t1 = new Thread() {
    public void run() {
        synchronized (obj) {
            try {
                obj.wait();
                System.out.println("Thread 1 wake up.");
            } catch (InterruptedException e) {
            }
        }
    }
};
t1.start();
Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.
Thread t2 = new Thread() {
    public void run() {
        synchronized (obj) {
            obj.notifyAll();
            System.out.println("Thread 2 sent notify.");
        }
    }
};
t2.start();

}

正确答案: B 你的答案: C (错误)
A.Thread 1 wake up
Thread 2 sent notify.
B.Thread 2 sent notify.
Thread 1 wake up
C.A、B皆有可能
D.程序无输出卡死
注：**notify()**就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。

---

下列说法正确的是（）
正确答案: A B 你的答案: A D (错误)
A.JAVA程序的main方法必须写在类里面
B.JAVA程序中可以有多个名字为main方法
C.JAVA程序中类名必须与文件名一样
D.JAVA程序的main方法中，如果只有一条语句，可以不用{}（大括号）括起来
注：java中可以有多个重载的main方法，只有public static void main(String[] args){}是函数入口。函数都必须用{}括起来，不管是一条语句还是多条语句

---

Java语言中，如果"xyz"没有被创建过，String s =new String(“xyz”);创建了几个string object？
正确答案: B 你的答案: A (错误)
A.1
B.2
C.3
D.4
注：字符串常量的保存位置：常量区。可以认为字符串的常量区是堆区中一块特殊的区域。字符串常量的特点：同一个名字的字符串常量在内存中只允许存在一个。（只占用一块内存）。字符串可以看作是一个“对象”（例如String s1 = “1000phone”;格式），该题"xyz"没有被创建过，所以会新建一个“xyz”对象，所以共创建了两个String对象。

---

以下程序输出结果是什么？

class A
{
    public static int X;
    static { X = B.Y + 1;}
}
public class B
{
    public static int Y = A.X + 1;
    static {}
    public static void main(String[] args) {
        System.out.println("X = "+A.X+", Y = "+B.Y);
    }
}

注：这个程序能正确运行，类的运行过程如下：首先加载主类B，初始化静态成员Y，发现需要类A的信息，于是加载类A，初始化静态成员X，也用到B类信息，由于此时B类的Y还未成功加载因此这里是默认值0，从而得到A类的X为1，然后返回到B类，得到Y为2。

---

多行注释中可以嵌套//单行注释，也能嵌套/**/多行注释。
正确答案: B 你的答案: A (错误)
A.正确
B.错误
注：多行注释中只能包含单行注释。

---

Java 的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。
正确答案: B 你的答案: A (错误)
A.正确
B.错误
注：容器的左上角被确定为坐标的起点。

---

如下的Java程序

public class Test { 
     public static void main(String[] args) { 
     System.out.println(args[0]); 
     } 
} 

若采用命令行“java Test one two three”调用，则程序输出的结果为：
正确答案: B 你的答案: D (错误)
A.Test
B.one
C.two
D.java
注：采用命令行“ java Test one two three ”调用，其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；System.out.println(args[0]);表示输出第一个元素，故为one。

---

下列哪个说法是正确的（）
正确答案: D 你的答案: C (错误)
A.ConcurrentHashMap使用synchronized关键字保证线程安全
B.HashMap实现了Collction接口
C.Array.asList方法返回java.util.ArrayList对象
D.SimpleDateFormat是线程不安全的
注：选D。

A选项中，ConcurrentHashMap 使用segment来分段和管理锁，segment继承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock来保证线程安全。

B中，HashMap定义规则如下：
public class HashMap
extends AbstractMap
implements Map, Cloneable, Serializable

C中，应该是Arrays.asList()，其将一个数组转化为一个List对象，这个方法会返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的私有内部类（java.util.Arrays.ArrayList ）：

---

下面哪个语句是创建数组的正确语句？( )
正确答案: A B D E 你的答案: D E (错误)
float f[][] = new float[6][6];
float []f[] = new float[6][6];
float f[][] = new float[][6];
float [][]f = new float[6][6];
float [][]f = new float[6][];
注：数组命名时名称与[]可以随意排列，但声明的二维数组中第一个中括号中必须要有值，它代表的是在该二维数组中有多少个一维数组。

---

下列代码的执行结果是：（ ）

public class Test3{
 public static void main(String args[]){
    System.out.println(100%3);
    System.out.println(100%3.0);
 }
}

正确答案: B 你的答案: B (正确)
A.1和1
B.1和1.0
C.1.0和1
D.1.0和1.0
注：多种混合计算时，自动将所有数据类型转换为容量最大的一种数据类型。

---

我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，out是类名，println是方法名。（）
正确答案: B 你的答案: A (错误)
A.正确
B.错误
注：System是java.lang包下的一个类，out为System的final静态成员（PrintStream类型），println()是PrintStream类的实例方法。java规范中包名一般是小写的，类名一般是大写的。

---

以下代码执行后输出结果为（ ）

public class Test
{
    public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB");
    }
    public static void main(String[] args)
    {
        Test t2 = new Test();
    }
 }

正确答案: A 你的答案: C (错误)
A. blockAblockBblockA
B. blockAblockAblockB
C. blockBblockBblockA
D. blockBblockAblockB
注：1.首先，需要明白类的加载顺序。
(1) 父类静态对象和静态代码块
(2) 子类静态对象和静态代码块
(3) 父类非静态对象和非静态代码块
(4) 父类构造函数
(5) 子类 非静态对象和非静态代码块
(6) 子类构造函数
其中：类中静态块按照声明顺序执行，并且(1)和(2)不需要调用new类实例的时候就执行了(意思就是在类加载到方法区的时候执行的)
2.因而，整体的执行顺序为
public static Test t1 = new Test(); //(1)
static
{
System.out.println(“blockB”); //(2)
}
Test t2 =new Test(); //(3)
在执行(1)时创建了一个Test对象，在这个过程中会执行非静态代码块和缺省的无参构造函数，在执行非静态代码块时就输出了blockA；然后执行(2)输出blockB；执行(3)的过程同样会执行非静态代码块和缺省的无参构造函数，在执行非静态代码块时输出blockA。因此，最终的结果为ABA。

---

下面有关java object默认的基本方法，说法错误的是？
正确答案: B 你的答案: D (错误)
A.equals(Object obj) 指示某个其他对象是否与此对象“相等”
B.copy() 创建并返回此对象的一个副本
C.wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
D.toString() 返回该对象的字符串表示
注：java object默认的基本方法中没有copy()，含有如下方法：
getClass(), hashCode(), equals(), clone(), toString(), notify(), notifyAll(), wait(), finalize()。
toString虽然默认返回的是对象的包名+类名+@+哈希码值的十六进制，但也是该对象的一种字符串形式，源码解释Returns a string representation of the object.

---

以下代码结果是什么？

public class foo {
	public static void main(String sgf[]) {
    
    StringBuffer a=new StringBuffer(“A”);
    
    StringBuffer b=new StringBuffer(“B”);
    
    operate(a,b);
    
    System.out.println(a+”.”+b);
    }

	static void operate(StringBuffer x, StringBuffer y) {
		x.append(y);
		y = x;
	}
}

正确答案: C 你的答案: A (错误)
A.代码可以编译运行，输出“AB.AB”。
B.代码可以编译运行，输出“A.A”。
C.代码可以编译运行，输出“AB.B”。
D.代码可以编译运行，输出“A.B”。
注：
对于append函数而言，修改的是x引用所指向的对象本身，所以无论是a还是x，其引用没有变化，但指向的值都变成了AB。然而对于y而言，其修改的是引用的值，也就是y这个形参（局部变量）的引用指向了AB，但对于实参b而言，其指向和指向对象的值都没有变动，所以仍然是B。

---

3.Java程序的最小程序单元是( )。
A.类
B.变量
C.对象
D.函数
注：A.类。因为java是面向对象的，所以java的程序必须在类中才能运行，不像C 只有方法就可以。

---

5.关于异常，下列说法正确的是（C，D）
A.Java中处理异常的方式有捕获和抛出两种
B.一个数除以0，会出现NumberFormatException的异常
C.catch语句的排列，子类在前，父类在后
D.在Java类库中所有异常都是Throwable的子类。
注：
A错。可以选择三种方法来进行异常处理
1对代码块用try…catch进行异常捕获处理；
2在 该代码的方法体外用throws进行抛出声明，告知此方法的调用者这段代码可能会出现这些异常，你需要谨慎处理。此时有两种情况：
　　　　如果声明抛出的异常是非运行时异常，此方法的调用者必须显示地用try…catch块进行捕获或者继续向上层抛出异常。
　　　　如果声明抛出的异常是运行时异常，此方法的调用者可以选择地进行异常捕获处理。
3在代码块用throw手动抛出一个异常对象，此时也有两种情况，跟2）中的类似。
B错， java.lang.ArithmeticException: / by zero
D正确，

---

2.(F)能作为类的访问权限修饰符的只有public和default。
注：内部类可以用protected, private。

---

如果一个接口Cup有个方法use()，有个类SmallCup实现接口Cup，则在类SmallCup中正确的是？ ( )
正确答案: C 你的答案: D (错误)
A.void use() { …}
B.protected void use() { …}
C.public void use() { …}
D.以上语句都可以用在类SmallCup中
注：然是实现接口，就要实现接口的所以方法，相当于重写方法，方法的重写需要满足：三同一大一小（方法名、返回值类型、形参相同；访问权限>=重写前；抛出异常<=重写前）。接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract。所以重写接口中的方法，访问权限一定是public。

---

What is the result of compiling and executing the following fragment of code:

Boolean flag = false;
if (flag = true)
{
    System.out.println(“true”);
}
else
{
    System.out.println(“false”);
}

正确答案: C 你的答案: D (错误)
A.The code fails to compile at the “if” statement.
B.An exception is thrown at run-time at the “if” statement.
C.The text“true” is displayed.
D.The text“false”is displayed.
E.Nothing is displayed.
注：赋值语句会有返回值，返回值为你所赋的值，flag = true运算后的返回值为true，所以此题中 if (flag = true)相当于if(true)。

---