Oracle Certified Java Programmer 经典题目分析（一）

Given:
1. public  class  returnIt {
2. returnType  methodA(byte x, double y){
3. return  (short) x/y * 2;
4.     }
5. }

What is the valid returnType for methodA in line 2?
A.int
B.byte
C.long
D.short
E.float
F.double

这个题目考察数据类型转换；简单类型数据间的转换,有两种方式:自动转换和强制转换,通常发生在表达式中或方法的参数传递时。

1）自动转换

具体地讲,当一个较“小”数据与一个较“大”的数据一起运算时,系统将自动将“小”数据转换成“大”数据,再进行运算。而在方法调用时,实际参数较“小”,而被调用的方法的形式参数数据又较“大”时(若有匹配的,当然会直接调用匹配的方法),系统也将自动将“小”数据转换成“大”数据,再进行方法的调用,自然,对于多个同名的重载方法,会转换成最“接近”的“大”数据并进行调用。这些类型由“小”到“大”分别为 (byte，short，char)--int--long--float—double。这里我们所说的“大”与“小”,并不是指占用字节的多少,而是指表示值的范围的大小。如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值。对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用强制类型转换。

2）强制转换

将“大”数据转换为“小”数据时，你可以使用强制类型转换。如：
   int n=(int)3.14159/2;
   可以想象，这种转换肯定可能会导致溢出或精度的下降。

3）自动提升

   关于类型的自动提升，注意下面的规则。
   ①所有的byte,short,char型的值将被提升为int型；
   ②如果有一个操作数是long型，计算结果是long型；
   ③如果有一个操作数是float型，计算结果是float型；
   ④如果有一个操作数是double型，计算结果是double型；

简单数据类型之间的转换大致就这么多，也可以利用包装器类提供的方法进行不同数据类型的转换，此处不表。

这个题目（short）的强制类型转换实际上只对x进行强制转换为short类型，注意到y是double型，所以运算结果返回的应当是double型，故选F。

---

Given
1) class Super{
2) public float getNum(){return 3.0f;}
3) }
4)
5) public class Sub extends Super{
6)
7) }
which method, placed at line 6, will cause a compiler error?
A. public float getNum(){return 4.0f;}
B. public void getNum(){}
C. public void getNum(double d){}
D. public double getNum(float d){return 4.0d;}

这个题目考察重载和覆盖的相关知识，只需熟练掌握重载（overload）和覆盖（override）的规则即可。

override即是重写（覆盖）了一个方法，通常发生在子类继承父类的过程中，override的规则如下：

   1）override 参数列表必须与被重写方法的参数列表相同，否则不能称为override而是overload；
   2）override 返回值必须与被重写方法的返回值一致；
   3）override 访问修饰符范围一定大于等于被重写方法的访问修饰符的范围；
   4）override 的异常必须小于等于被重写方法抛出的异常的范围；
   5）被重写方法不能为private或者static，否则只是重新定义了一个新的方法，并不是重写。

overload是方法的重载，通常用于一个类中实现若干重载方法，overload的规则如下：

  1）重载是通过相同方法名和不同的参数列表实现，不同的参数列表包括不同参数类型、不同的参数个数、不同的参数顺序；
  2）不能通过访问权限返回类型抛出的异常进行重载；
  3）方法的返回类型可以不同也可以相同；
  4）方法的异常类型和数目不会对重载造成影响。

本题中A选项是标准的方法重写，B选项只从参数列表上看是重写，但是返回值不同违反了方法重写的原则，CD都是方法的重载。

---

Given
1)public class Foo{
2)    public static void main(String args[]){
3)    try{return;}
4)    finally{ System.out.println("Finally");}
5)    }
6)    }
what is the result?
A. The program runs and prints nothing.
B. The program runs and prints “Finally”.
C. The code compiles, but an exception is thrown at runtime.
D. The code will not compile because the catch block is missing.

本题考察当return在finally之前，会怎样执行？可做如下总结
  1）不管有没有出现异常，finally一定会被执行；
  2）当try或者catch中有return时，finally仍然会执行；
  3）finally不会改变return的值，换句话说，return在finally之前就已经执行并确定了return的值，只是没有来得及return只是保存起来等finally执行结束在return；
  4）当finally中有return时，那么这个return一定会被return而不是之前try catch里面的return值，因此强烈建议表在finally里搞个return。

---

Given
1） public class Test{
2） public static String output="";
3） public static void foo(int i){
4）   try {
5）        if(i==1){
6）                    throw new Exception();
7）               }
8）         output +="1";
9）       }
10）     catch(Exception e){
11）                     output+="2";
12）                     return;
13）                      }
14）     finally{
15）                output+="3";
16）           }
17）      output+="4";
18） }
19） public static void main(String args[]){
20）              foo(0);
21）              foo(1);
22）
23）   }
24） }
what is the value of output at line 22?

这个题目没什么好说的，只要注意到当i=1的时候抛出异常跳到catch里面去执行就ok的，而且output这个值是静态的，两次函数调用操作的实际上是同一个变量，只是相当于在原有字符串后面追加的。

---

Given
1）public class IfElse{
2）public static void main(String args[]){
3）if(odd(5))
4）System.out.println("odd");
5）else
6）System.out.println("even");
7）}
8）public static int odd(int x){return x%2;}
9）}
what is output?

这个题目考察点在于对于boolean变量的理解，在Java世界中，boolean就两个值：非true即false，不同与C系列语言中“非零即为真”。注意到odd函数的返回值是int类型，用在if判定条件上作为逻辑表达式肯定是不妥的，因此编译会出错。output即为：compile error！

---

Given
1）class ExceptionTest{
2）public static void main(String args[]){
3）try{
4）methodA();
5）}catch(IOException e){
6）System.out.println("caught IOException");
7）}catch(Exception e){
8）System.out.println("caught Exception");
9） }
10） }
11）}
If methodA() throws a IOException, what is the result?

这题考察异常的捕获与处理。Java中异常以类对象的形式处理，异常之间可以有继承的关系。在一个try匹配多个catch的情况下，一旦出现异常，那么按顺序匹配catch中的异常，一旦匹配成功则处理，不会继续到下一个catch。因此一般在异常处理程序中，catch顺序越往下异常越靠近顶层作为“兜底”来处理，即应当把子类的异常尽量的放在前面。一言以蔽之：根据抛出来的异常是哪个自定义异常类，这里注意，走完一个catch{}后就不再走其他的catch{}了。

---

Given
1)public class X{
2) public Object m(){
3) Object o=new Float(3.14F);
4) Object[] oa=new Object[1];
5)     oa[0]=o;
6)     o=null;
7)     oa[0]=null;
8）    System.out.println(oa[0]);
9)       }
10) }
which line is the earliest point the object a refered is definitely elibile to be garbage collectioned?
A.After line 4
B.After line 5
C.After line 6
D.After line 7
E.After line 9(that is,as the method returns)

Java的垃圾回收是一个及其复杂的机制，其回收时间具有不可预知性，因此永远不要假定Java垃圾回收什么时候会启动，但是作为程序员可以为Java垃圾回收创造启动条件，一般来说有以下几种方式：
  1）空引用 ：当对象没有对他可到达引用时，他就符合垃圾回收的条件。也就是说如果没有对他的引用，删除对象的引用就可以达到目的，因此我们可以把引用变量设置为 null，来符合垃圾回收的条件。
  2）重新为引用变量赋值：可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。
  3）方法内创建的对象：所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回，在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况，就是方法的返回对象。如：

public static void main(String[] args) {
        Date d = getDate();
        System.out.println("d = " + d);
}
private static Date getDate() {
        Date d2 = new Date();
        StringBuffer now = new StringBuffer(d2.toString());
        System.out.println(now);
        return d2;
}

4）隔离引用：这种情况中，被回收的对象仍具有引用，这种情况称作隔离岛。若存在这两个实例，他们互相引用，并且这两个对象的所有其他引用都删除，其他任何线程无法访问这两个对象中的任意一个，也可以符合垃圾回收条件。如：

public class Island {
        Island i;
        public static void main(String[] args) {
                Island i2 = new Island();
                Island i3 = new Island();
                Island i4 = new Island();
                i2.i=i3;
                i3.i=i4;
                i4.i=i2;
                i2=null;
                i3=null;
                i4=null;
        }
}

在本题中第6行使得o指向了空引用，忽略上下文的话o应当被回收，但是上一句oa[0]句柄指向了o此时o仍然在被引用，因此当oa[0]被指向空引用此时o和oa[0]都应当被回收，故应选D.

---

1) interface Foo{
2)          int k=0;
3)    }
4) public class Test implements Foo{
5)             public static void main(String args[]){
6)                        int i;
7)                          Test test =new Test();
8)                           i=test.k;
9)                           i=Test.k;
10)                          i=Foo.k;
11)                           }
12) }
What is the result?
A. Compilation succeeds.
B. An error at line 2 causes compilation to fail.
C. An error at line 9 causes compilation to fail.
D. An error at line 10 causes compilation to fail.
E. An error at line 11 causes compilation to fail.

接口就是提供一种统一的'协议',而接口中的属性也属于'协议'中的成员.它们是公共的,静态的,最终的常量.相当于全局常量.抽象类是不'完全'的类,相当于是接口和具体类的一个中间层.即满足接口的抽象,也满足具体的实现。需要说明的是在Java8中，接口可以实现一种特殊的方法，一般声明为default方法，该方法可以在接口中实现，作为接口的默认方法可以调用。
在这个题目中，k就相当于一个静态常量，因此实现了接口的对象包括接口本身都可以直接调用这个“常量”.

(部分资料参考CSDN其他博友)