JavaSE题目记录——易错选择题

墨蓝 2023-09-30 20:38 304阅读 0赞

1.  Test.main() 函数执行后的输出是（）

public class Test {
        public static void main(String [] args){
            System.out.println(new B().getValue());//17
        }
        static class A{
            protected int value;
            public A(int v) {
                setValue(v);//5
            }
            public void setValue(int value){//10, 22
                this.value = value;//10, 22, 16
            }
            public int getValue(){
                try{
                    value++;//11,17
                    return value;//11,17
                } catch(Exception e){
                    System.out.println(e.toString());
                } finally {//22, 34
                    this.setValue(value);
                    System.out.println(value);
                }
                return value;
            }
        }
        static class B extends A{
            public B() {
                super(5);//10
                setValue(getValue() - 3);//11 - 3 = 8
            }
            public void setValue(int value){//5, 11, 8
                super.setValue(2 * value);//10, 22, 16, 34
            }
        }
    }

A.11 17 34

B.22 74 74

C.6 7 7

D.22 34 17

**答案：D**

**考察点：**内部类，继承，处理异常。

1.  以下程序的运行结果是（）

public class Increment
    {
        public static void main(String args[])
        {
            int a;
            a = 6;
            System.out.print(a);//6
            System.out.print(a++);//6, a = 7
            System.out.print(a);//7
        }
    }

A.666

B.667

C.677

D.676

**答案：B**

1.  关于 JAVA 堆,下面说法错误的是()

A.所有类的实例和数组都是在堆上分配内存的

B.对象所占的堆内存是由自动内存管理系统回收

C.堆内存由存活和死亡的对象,空闲碎片区组成

D.数组是分配在栈中的

**答案：D**

**解析：**数组分配在堆上，用new关键字的对象都在堆上。

1.  对文件名为Test.java的java代码描述正确的是()

class Person {
        String name = "No name";
        public Person(String nm) {//有参的构造函数
            name = nm;
        }
    }
    class Employee extends Person {
        String empID = "0000";
        public Employee(String id) {//有参的构造函数
            empID = id;//错误，应该先调用Person的构造函数
        }
    }
    public class Test {
        public static void main(String args[]) {
            Employee e = new Employee("123");
            System.out.println(e.empID);
        }
    }

A.输出：0000

B.输出：123

C.编译报错

D.输出：No name

**答案：C**

**解析：**构造函数语法错误。

1.  有关下述Java代码描述正确的选项是\_\_\_\_。

public class TestClass {
       private static void testMethod(){
            System.out.println("testMethod");
       }
       public static void main(String[] args) {
            ((TestClass)null).testMethod();
       }
    }

A.编译不通过

B.编译通过，运行异常，报NullPointerException

C.编译通过，运行异常，报IllegalArgumentException

D.编译通过，运行异常，报NoSuchMethodException

E.编译通过，运行异常，报Exception

F.运行正常，输出testMethod

**答案：F**

**解析：**static属性，无论new多少个该类的实例，static方法只有一份，属于类本身。

该题testMethod这个方法就是static的。

1.  下列java程序的输出结果为\_\_\_\_。

public class Example{
        String str=new String("hello");
        char[]ch={'a','b'};
        public static void main(String args[]){
            Example ex=new Example();
            ex.change(ex.str,ex.ch);
            System.out.print(ex.str+" and ");
            System.out.print(ex.ch);
        }
        public void change(String str,char ch[]){//str是形参，ch[]传的是地址
            str="test ok";//引用改变
            ch[0]='c';
        }
    }

A.hello and ab

B.hello and cb

C.hello and a

D.test ok and ab

E.test ok and cb

F.test ok and c

**答案：B**

**解析：**

![0b4cffcbc25aefd9a053b8142af9d4db.png][]

1.  在jdk1.5之后，下列 java 程序输出结果为\_\_\_\_\_\_。

int i=0;
    Integer j = new Integer(0);//自动拆箱
    System.out.println(i==j);
    System.out.println(j.equals(i));

A.true,false

B.true,true

C.false,true

D.false,false

E.对于不同的环境结果不同

F.程序无法执行

**答案：B**

**解析：**包装类会自动拆箱。

1.  下面代码运行结果是（）

public class Test{    
        public int add(int a,int b){    
             try {    
                 return a+b;        
             } 
            catch (Exception e) {    
                System.out.println("catch语句块");    
             }    
             finally{    
                 System.out.println("finally语句块");    
             }    
             return 0;    
        } 
         public static void main(String argv[]){ 
             Test test =new Test(); 
             System.out.println("和是："+test.add(9, 34)); 
         }
    }

A.catch语句块 和是：43

B.编译异常

C.finally语句块 和是：43

D.和是：43 finally语句块

**答案：C**

**解析：**返回之前先执行finally块中的语句。

1.  以下声明合法的是

A.default String s

B.public final static native int w( )

C.abstract double d

D.abstract final double hyperbolicCosine( )

**答案：B**

**解析：**A：defalut不是访问控制权限修饰符，一般在switch中使用。

B：正确。

C：变量不能声明为抽象的。

D：抽象方法不能被final修饰。

1.  下面代码的输出结果是什么？

public class ZeroTest {
        public static void main(String[] args) {
            try{
                int i = 100 / 0;
                System.out.print(i);//不执行
            }catch(Exception e){
                System.out.print(1);//执行1
                throw new RuntimeException();
            }finally{
                System.out.print(2);//执行2
            }
            System.out.print(3);//未执行
        }
    }

A.3

B.123

C.1

D.12

**答案：D**

**解析：**发生异常后，异常被catch，try中异常后的语句不执行，finally中的语句无论如何都会执行，执行完后程序结束。

1.  有代码片段如下：

byte b1=1,b2=2,b3,b6;  
    final byte b4=4,b5=6;  //类型不会变化
    b6=b4+b5;  //类型不会变化
    b3=(b1+b2);  //int类型->byte类型，类型不匹配，编译出错
    System.out.println(b3+b6);

关于上面代码片段叙述正确的是（）

A.输出结果：13

B.语句：b6=b4+b5编译出错

C.语句：b3=b1+b2编译出错

D.运行期抛出异常

**答案：C**

**解析：**大类型转小类型要进行强制类型转换，否则编译出错。

1.  下列程序的运行结果5

public static void main(String args[]) {
        Thread t = new Thread() {
            public void run() {
                pong();
            }
        };
        t.run();
        System.out.print("ping");
    }
    static void pong() {
        System.out.print("pong");
    }

A.pingpong

B.pongping

C.pingpong和pongping都有可能

D.都不输出

**答案：B**

解析：这里考察Thread类中start()和run()方法的区别。start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run()方法来执行任务，而单独的调用run()就跟调用普通方法是一样的，已经失去线程的特性了。因此在启动一个线程的时候一定要使用start()而不是run()。所以本题先输出pong再输出ping。

ArrayList list = new ArrayList(20);

中的list扩充几次

A.0

B.1

C.2

D.3

**答案：A**

**解析：**看原码，直接调用有参构造函数时，并没有进行扩容，只有调用无参构造函数时，才默认容量是10，如果加入第11个元素时，才会扩容。

![fa5143452815c189efad9ccf36d6ba55.png][]

![f88e0f5402f2606a1b9a51db8f54388f.png][]

1.  在Java中，关于HashMap类的描述，以下错误的是

A.HashMap使用键/值得形式保存数据

B.HashMap 能够保证其中元素的顺序

C.HashMap允许将null用作键

D.HashMap允许将null用作值

**答案：B**

**解析：**HashMap不能保证元素顺序。

1.  下面程序的运行结果是

String str1 = "hello";
    String str2 = "he" + new String("llo");
    System.err.println(str1 == str2);

A.true

B.false

C.exception

D.无输出

**答案：B**

**解析：**str1存储在栈中，因为str2是通过new关键字产生的，所以str2存储在堆中，所以不相等，输出false。

1.  java接口的方法修饰符可以为？(忽略内部接口)

A.private

B.protected

C.final

D.abstract

**答案：D**

**解析：**接口的修饰符只能是public或者abstract，因为其中的方法必须被实现。

1.  下列程序的运行结果

public void getCustomerInfo() {
            try {
                // do something that may cause an Exception
            } catch (java.io.FileNotFoundException ex) {
                System.out.print("FileNotFoundException!");
            } catch (java.io.IOException ex) {
                System.out.print("IOException!");
            } catch (java.lang.Exception ex) {
                System.out.print("Exception!");
            }
        }

A.IOException!

B.IOException!Exception

C.FileNotFoundException!IOException!

D.FileNotFoundException!IOException!Exception!

**答案：A**

**解析：**只会catch一个异常，也就是只会输出一次，所以只能选A。

1.  选项中哪一行代码可以添加 到题目中而不产生编译错误？

public abstract class MyClass {
         public int constInt = 5;
         //add code here
         public void method() {
         }
    }

A.public abstract void method(int a);

B.constInt = constInt + 5;

C.public int method();

D.public abstract void anotherMethod() \{\}

**答案：A**

**解析：**这是一个抽象类，所以一定要有抽象方法，所以直接看AD，A选项是正确的抽象方法，D选项抽象方法定义错误，不应该有方法体。

如有建议或想法，欢迎一起讨论学习~

[0b4cffcbc25aefd9a053b8142af9d4db.png]: https://img-blog.csdnimg.cn/img_convert/0b4cffcbc25aefd9a053b8142af9d4db.png
[fa5143452815c189efad9ccf36d6ba55.png]: https://img-blog.csdnimg.cn/img_convert/fa5143452815c189efad9ccf36d6ba55.png
[f88e0f5402f2606a1b9a51db8f54388f.png]: https://img-blog.csdnimg.cn/img_convert/f88e0f5402f2606a1b9a51db8f54388f.png