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

生菜虾

于 2023-03-23 16:41:31 发布

阅读量206

点赞数 1

分类专栏：刷题记录文章标签： java 开发语言 jvm 学习 Powered by 金山文档

本文链接：https://blog.csdn.net/lil_ghost_/article/details/129654058

版权

刷题记录专栏收录该内容

43 篇文章 0 订阅

订阅专栏

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

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

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

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

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

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

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

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

D.数组是分配在栈中的

答案：D

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

对文件名为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

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

有关下述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的。

下列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

解析：

在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

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

下面代码运行结果是（）

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块中的语句。

以下声明合法的是

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修饰。

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

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中的语句无论如何都会执行，执行完后程序结束。

有代码片段如下：

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

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

下列程序的运行结果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个元素时，才会扩容。

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

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

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

C.HashMap允许将null用作键

D.HashMap允许将null用作值

答案：B

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

下面程序的运行结果是

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。

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

A.private

B.protected

C.final

D.abstract

答案：D

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

下列程序的运行结果

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。

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

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选项抽象方法定义错误，不应该有方法体。

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

生菜虾

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
JavaSE题目记录——易错选择题

start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run()方法来执行任务，而单独的调用run()就跟调用普通方法是一样的，已经失去线程的特性了。这是一个抽象类，所以一定要有抽象方法，所以直接看AD，A选项是正确的抽象方法，D选项抽象方法定义错误，不应该有方法体。发生异常后，异常被catch，try中异常后的语句不执行，finally中的语句无论如何都会执行，执行完后程序结束。static属性，无论new多少个该类的实例，static方法只有一份，属于类本身。
复制链接

扫一扫