不看OCJP考题你永远不知道自己的JAVA基础有多差（七）

上期答案

第二十六题

1.interface A {public void aMethod(); }

2.interface B {public void bMethod(); }

3.interface C extends A,B { public void cMethod(); }

4.class D implements B {

5.     public void bMethod(){}

6. }

7.class E extends D implements C {

8.     public void aMethod(){}

9.     public void bMethod(){}

10.   public void cMethod(){}

11. }

What isthe result?

A. 因为第3行存在问题，因此编译失败.

B. 因为第7行存在问题，因此编译失败.

C. 因为第9行存在问题，因此编译失败.

D. 如果你使用De = new E()创建了一个类D的实例并调用bMethod()方法，则将调用在第5行处定义的bMethod()方法

E. 如果你使用De = (D)(new E())创建了一个类D的实例并调用bMethod()方法，则将调用在第5行处定义的bMethod()方法

F. 如果你使用De = (D)(new E())创建了一个类D的实例并调用bMethod()方法，则将调用在第9行处定义的bMethod()方法

答案：F

知识点：

继承与转型，这部分内容特别的乱，而且绕来绕去的。对于那些指针理解的比较好的同学实际上也没什么，如果再配合反射来解释其实一句话就说清楚了。在newE()的时候类，JVM会在堆内存中生成一个引用，而在栈内存中为类的实例开辟内存空间。在堆内存中的这个引用实际上可以理解为是一个指针数组，分别指向栈内存中用来存放属性的地址和用来存放方法的方法入口地址（方法指针）。此时，无论如何转型，这些指针是不会发生改变的，所以答案F中，尽管向上转型为D类的实例，但是在调用方法的时候还是调用在类E中声明的方法。

这里，对于只学过JAVA的同学，我想说，回去看看C吧，理解尽可能多一些的中、低层机制对编程是有好处的，尤其是在做优化的时候。另外，总听别人说JAVA好，简单，没有指针。我想说，JAVA的开发者并不是为了简化语法而不用指针，而是他们觉得指针不安全，这里说的不安全不是说你用起来不安全，而是说容易给程序留下漏洞。

任何高级语言编译到最后都是编程汇编进而是字节码，JAVA封装的再好，他的基本原理还是那样。其实，从1945年到现在计算机的原理就没变过。

第二十七题

一下哪段代码诠释了“人类有一个最好的朋友—狗”（Manhas a best friend who is a Dog）

A.class Man extendsDog { }

B.class Manimplements Dog { }

C.class Man {private BestFriend dog; }

D.class Man {private Dog bestFriend; }

E.class Man {private Dog<bestFriend>; }

答案：D

BestFriend是属性，Dog是类型，换句话说就是Man这个类有一个bestFriend属性，属性的类型是Dog。

第二十八题

有如下代码

31.class Foo {

32.       public int a = 3;

33.       public void addFive() { a += 5;System.out.print("f "); }

34. }

35.class Bar extends Foo {

36.       public int a = 8;

37.       public void addFive() { this.a += 5;System.out.print("b " ); }

38. }

执行一下三行代码

Foo f =new Bar();

f.addFive();

System.out.println(f.a);

结果是什么?

A. b 3

B. b 8

C. b 13

D. f 3

E. f 8

F. f 13

G. 编译失败.

H. 抛出异常.

答案：A

知识点：

依然是继承和转型方面的问题，很乱很坑爹，如果你认为答案是C，证明你也挺不错的。现在JAVA有一种叫做面向接口的设计理念（不能叫设计模式，面向接口的设计模式有很多，比如工厂模式）。这个题目中出现的问题在一定程度上也解释了为什么借口中的属性都默认是staticfinal的，这也是JAVA的一种安全机制。

第二十九题

11.class Animal {public String noise() { return "peep"; } }

12.class Dog extends Animal {

13.  public String noise() { return "bark"; }

14. }

15.class Cat extends Animal {

16.  public String noise() { return "meow"; }

17. }...

30.Animal animal =new Dog();

31. Catcat =(Cat)animal;

32.System.out.println(cat.noise());

以上代码执行的结果是

A. peep

B. bark

C. meow

D. 编译失败.

E. 抛出异常.

答案：E

程序第32行会抛出一个ClassCastException，这是向上，向下转型的基本概念，做错的去把向上，向下转型的规则背下来就行了，没什么需要解释的。

第三十题

1.class Super {

2.     private int a;

3.     protected Super(int a) { this.a = a; }

4. }...

11.class Sub extends Super {

12.  public Sub(int a) { super(a); }

13.  public Sub() { this.a = 5; }

14. }

一下哪两种修改可以使得以上代码编译通过(Choose two.)

A.Change line 2 to:public int a;

B.Change line 2 to:protected int a;

C.Change line 13 to: public Sub() { this(5); }

D. Changeline 13 to: public Sub() { super(5); }

E.Change line 13 to: public Sub() { super(a); }

答案 CD

知识点：

父类只有一个有参的构造方法，子类的无参构造方法必须给父类的构造方法传递一个参数，因此C,D都可以，C是说在子类的无参构造方法中调用自己的有参构造方法并给父类的构造方法传递一个参数，D更直接，直接给父类传个参数。

----------------------------------------------------------分割线---------------------------------------------------------

本期问题

第三十一题：

1. public class Base {

2.    public static final String FOO = "foo";

3.    public static void main(String[] args) {

4.              Base b = new Base();

5.              Sub s = new Sub();

6.              System.out.print(Base.FOO);

7.              System.out.print(Sub.FOO);

8.              System.out.print(b.FOO);

9.              System.out.print(s.FOO);

10.           System.out.print(((Base)s).FOO);

11. } }

12. class Sub extends Base{public static final String FOO="bar";}

上面这段代码的运行结果是：

A. foofoofoofoofoo

B. foobarfoobarbar

C. foobarfoofoofoo

D. foobarfoobarfoo

E. barbarbarbarbar

F. foofoofoobarbar

G.foofoofoobarfoo

 

第三十二题：

1. package geometry;

2. public class Hypotenuse{

3.    public InnerTriangle it = new InnerTriangle();

4.    class InnerTriangle {

5.             public int base;

6.             public int height;

7.      }

8. }

下面描述的内容那个是正确的?

A. 任何类都可以访问属性base.

B. 任何类都不可以访问属性base .

C. 只有属于geometry 包的类可以访问属性base.

D. 只有Hypotenuse的子类可以访问base的属性.

 

第三十三题：

2. public class Hi {

3.    void m1() { }

4.      protected void m2() { }

5. }

6. class Lois extends Hi {

7.    // 此处插入代码

8. }

在第七行处插入哪几个选项中的代码都可以使得程序编译通过? (选择4个.)

A. public void m1() { }

B. protected void m1() { }

C.private void m1() { }

D.void m2() { }

E. public void m2() { }

F. protected void m2() { }

G. private voidm2() { }

 

第三十四题：

以下哪两个选项中的代码可能会引发StackOverflowError？

A. int []x = {12345};

for(int y = 0; y< 6; y++)

System.out.println(x[y]);

B. static int[] x ={7654};

static { x[1] = 8;

x[4] = 3; }

C.for(int y = 10; y < 10; y++)

doStuff(y);

D.void doOne(int x) { doTwo(x);}

void doTwo(int y) { doThree(y); }

void doThree(int z) { doTwo(z); }

E. for(int x = 0; x <1000000000; x++)

doStuff(x);

F. voidcounter(int i) { counter(++i); }

 

第三十五题：

11. class A {

12.           public void process() {System.out.print("A"); }

13.class B extends A {

14.           public void process() throwsIOException {

15.                     super.process();

16.                      System.out.print("B");

17.                     throw new IOException();

18.           }

19.      public static void main(String[] args) {

20.                      try { new B().process(); }

21.                      catch (IOException e) {System.out.println("Exception"); }

22.    }

以上代码运行的结果是?

A. Exception

B. ABException

C. 因为在第20行有错误，因此编译失败.

D. 因为在第14行有错误，因此编译失败.

E. 程序运行时，抛出NullPointerException.