几道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