几道Java笔试题

考点一：
try finally中return的执行顺序

1、

public class Test {  public static boolean decide() {   try {    System.out.println("First");   return true;  } finally {   System.out.println("Second");  return false;  } }     public static void main(String args[ ]){ if (Test.decide()) {   System.out.println("True");   }else {     System.out.println("False");    }   }}

输出结果：
First
Second
False
解析：
try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。

2、

public class Test { public static void main(String[] args) {   // TODO Auto-generated method stub    System.out.println(new Test().test());}      static int test()     {      int x = 1;      try {         return x; }  finally  {         ++x;  System.out.println(x); System.out.println("aaa");        }   }  } 

输出结果：
2
aaa
1

       3、

public  class Test {    public static void main(String[] args) {       System.out.println(new Test().test());;    }    int test()    {       try       {           return func1();       }       finally       {           return func2();       }    }    int func1()    {       System.out.println("func1");       return 1;    }    int func2()    {       System.out.println("func2");       return 2;    }   }

输出结果：
func1
func2
2

考点二：多态。。。

4、

public class Test {      /**      * @param args      */      public static void main(String[] args) {          Animal a = new Dog();          a.syaHi();          Animal b = new Bulldog();          b.syaHi();          Dog dog = (Dog)b;          dog.syaHi();          check(dog);          Bulldog bulldog = (Bulldog)b;          check(bulldog);       }      public static void check(Dog dog)      {          System.out.println("check dog"+dog.getName()+".");      }      public static void check(Bulldog bulldog)      {          System.out.println("check bulldog"+bulldog.getName()+".");      }  }  interface Animal  {      void syaHi();      String getName();  }  class Dog implements Animal  {      public String getName()      {          return "Bob";      }      private String bark()      {          return "wang-wang";      }      public void syaHi()      {          System.out.println("I am "+getName()+"."+bark());      }  }  class Bulldog extends Dog  {      @Override      public String getName(){return "Mike";}      private String bark(){return "WOO-WOO";}  }  

输出结果：

I am Bob.wang-wang
I am Mike.wang-wang
I am Mike.wang-wang
check dogMike.
check bulldogMike.

考点三：构造函数

5、

public class Test {        public static void main(String[] args) {            BB bb = new BB();            bb = new BB();        }    }    class AA    {        static       {            System.out.println("static_aa");        }        public AA()        {            System.out.println("aa");        }    }    class BB extends AA    {        static       {            System.out.println("static_bb");        }        public BB()        {            System.out.println("bb");        }    }    

结果：

static_aa
static_bb
aa
bb
aa
bb

6、

class A {         public String show(D obj){                return ("A and D");         }          public String show(A obj){                return ("A and A");         }          public String show(C obj){               return ("A and C");         }} class B extends A{         public String show(B obj){                return ("B and B");         }         public String show(A obj){                return ("B and A");         }          public String show(C obj){                return ("B and C");  }}class C extends B{} class D extends B{} class Test{        public static void main(String[] args){      A a1 = new A();      A a2 = new B();      B b = new B();      C c = new C();       D d = new D();       System.out.println(a1.show(b));     // 1      System.out.println(a1.show(c));     // 2      System.out.println(a1.show(d));    // 3      System.out.println(a2.show(b));    // 4      System.out.println(a2.show(c));     // 5      System.out.println(a2.show(d));    // 6      System.out.println(b.show(b));      // 7      System.out.println(b.show(c));      // 8      System.out.println(b.show(d));      // 9    } } 

输出结果：

1   A and  A
2   A and  C
3   A and  D
4   B and  A
5   B and  C
6   A and  D
7   B and  B
8   B and  C
9   A and  D
背景知识：运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 （但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

分析：主要知识点：方法调用的优先问题 ，优先级由高到低依次为：this.show(obj)、super.show(obj)、this.show((super)obj)、super.show((super)obj)，如果弄懂了这个优先级调用问题，那么上面的结果都很好解释了。
比如对于第一个结果，由于A类中没有 show(B obj)方法，且它没有父类，故它会调用第三个优先级，即调用方法show(A obj)，很容易得出上面的结果。
又如第四个，a2.show(b)，a2是一个引用变量，引用变量类型为B，this指的是B的实例，但是show(B obj)方法没有在父类中定义，则不满足由类B的实例决定调用函数，因此转到第三优先级this.show((super)obj)，(super)obj即(super)B即A，因此最终锁定到类B的show(A obj)，输出为"B and A”。（个人观点，欢迎轻拍）
7、

public class Test {public static void main(String[] args) {Parent p = new Child();System.out.println(p.name);System.out.println(p.get());}}class Parent {String name = "Parent";public String get() {return name;}}class Child extends Parent {String name = "Child";public String get() {return name;}}

Parent
Child