Java刷题总结

选择题

• 只有实现了()接口的类，其对象才能序列化。(A)
  A.Serializable
  B.Cloneable
  C.Comparable
  D.Writeable
  解析：
  Serializable要实现序列化对象必须要实现的接口
• Java 源程序文件的扩展名为（A）
  A…java
  B…class
  C…exe
  D…jar
• This调用语句必须是构造函数中的第一个可执行语句。(B)
  A.正确
  B.错误
  解析：
  this()才必须是构造函数中的第一个可执行语句，用this调用语句并不需要。
• protected访问权限要小于包访问权限。（B ）
  A.正确
  B.错误
  解析：
  public > protected > 同包（default） > private
• 有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常， catch 下述哪个类的实例才能达到目的：（B）
  A.Error
  B.Exception
  C.RuntimeException
  D.Throwable
  解析：
  
• 以下 _____ 不是 Object 类的方法（D）
  A.clone（）
  B.finalize()
  C.toString()
  D.hasNext()
  解析：object类的方法
  
• 关于以下程序代码的说明正确的是(A)

public class HasStatic {// 1
    private static int x = 100;// 2
    public static void main(String args[]) {// 3
        HasStatic hsl = new HasStatic();// 4
        hsl.x++;// 5
        HasStatic hs2 = new HasStatic();// 6
        hs2.x++;// 7
        hsl = new HasStatic();// 8
        hsl.x++;// 9
        HasStatic.x--;// 10
        System.out.println(" x=" + x);// 11
    }
}

A.程序通过编译，输出结果为:x=102
B.程序通过编译，输出结果为:x=103
C.10行不能通过编译.因为x星私有静态变量
D.5行不能通过编译.因为引用了私有静态变量
解析：
同一个类内，private变量可以访问，所以CD错。由于x是static的，存贮在类内，而不是对象内，所以++、–操作的是同一个变量。

• /…/中可以嵌套//注释，也能嵌套/…/注释。（B）
  A.正确
  B.错误
• Test.main() 函数执行后的输出是（D）

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

A.11 17 34
B.22 74 74
C.6 7 7
D.22 34 17
解析：
首先，super()函数指的是调用父类的构造方法
①
new B()
执行B的构造函数，第一行是super(5);
此时执行的是A的构造函数，A的构造函数调用的是setValue()方法，由于B重写了A的这个方法，
所以！！！执行的是B的 setValue()方法。
即传入的参数是25=10
此时，因为super，所以调用的是父类的 setValue()方法，即value=10
第一行执行完毕。
第二行是 setValue(getValue()-3);
B没有getValue()方法，故执行父类的此方法，
try返回的是value=10+1=11，保存在临时栈中
finally中调用this的方法，这个this指的是B的对象，又重写，故就是B的 setValue()方法
value=211=22，第一个打印到屏幕上的数字
接下来参数 getValue()-3=11-3=8
传入B的 setValue()方法
此时value=28=16
至此，new B()执行结束
②
new B(). getValue()
B没有 getValue()，故执行A的 getValue()
try返回16+1=17，保存到临时栈中
finally调用B的 setValue()方法
value=172=34，第二个打印到屏幕上面的数字
最后主函数打印返回值，也就是try保存到临时栈的17

答案就是：22,34,17

• 下列描述错误的是?（BD）
  A.类只能继承一个父类，但是可以实现多个接口
  B.抽象类自身可以定义成员而接口不可以
  C.抽象类和接口都不能被实例化(忽略匿名内部类)
  D.一个类可以有多个父类和多个基接口
  解析：
  A、java为单继承，多实现。可以实现多个接口。
  B、接口允许定义成员，但必须是常量。
  C、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
  D、同A，单继承，多实现。