幾道Java筆試題

yuan22003發表於2011-08-26
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


相關文章