1. 閱讀下列程式碼回答問題（第一個Java程式，理解PATH和CLASSPATH，學會使用javac和java命令）

package cn.edu.uibe; public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } }

問：

（1)上面程式碼所在的原始檔的檔名是_______________？
（2）在DOS提示符下，當前目錄為該原始檔所在的目錄，PATH環境變數已包含編譯程式所在的路徑，編譯目標路徑為“D:/classes”，編譯命令列是_____________？
（3）為了讓Java直譯器能夠找到編譯後的類檔案，需要如何設定環境變數___________？
（4）在正確設定了相關的環境變數之後，執行HelloWorld類的命令列是____________?

答案：

（1）HelloWorld.java，公共類必須定義在和類名同名的檔案中，檔名區分大小寫。

（2）javac -d D:/classes HelloWorld.java ，-d給出輸出目錄，javac會在D:/classes建立包的目錄層次結構cn/edu/uibe/HelloWorld.class

（3）set CLASSPATH=.;D:/classses，CLASSSPATH給出Java尋找.class檔案的多個路徑，路徑之間用分號分隔，“.”表示當前路徑。

（4）java cn.edu.uibe.HelloWorld，注意需要給出包名，類名後面不要加“.class”。

2. 閱讀下列程式碼回答問題（關於private的理解）

public class Light { private int brightness = 5; public void brighten(Light another){ another.brightness++; } public static void main(String[] args) { Light light1 = new Light(); Light light2 = new Light(); light1.brighten(light2); } }

問：上面程式碼Java編譯器是否會給出錯誤提示？為什麼？

答案：不會出現錯誤提示，private限制了私有變數只能被同一個類訪問，但是沒有限制同一個類的不同物件之間互相訪問私有變數。實際上，private是在編譯時進行檢查，如果想限制同類物件之間互相訪問，需要在動態執行時實現，開銷較大，而且沒有必要。

3. 閱讀下列程式碼回答問題（關於多型性的理解）

class Base { int i=1; void f(){ System.out.println("Base.f()"); } void g(){ f(); //會呼叫上面的f()方法嗎？ } } public class Derived extends Base { //繼承了Base類 int i=2; //Derived類的物件有1個i還是2個i呢？ 答：2個 void f(){ //覆蓋override了f()方法 System.out.println("Derived.f()"); } public static void main(String[] args) { Derived d = new Derived(); //建立子類物件 Base b = d; //沒有建立物件，僅僅是父類引用指向了子類物件 d.f(); //將會輸出Derived.f() b.f(); //也會輸出Derived.f()，方法具有多型性 System.out.println(d.i); //輸出的是2，d.i訪問子類中定義的變數i System.out.println(b.i); //輸出的是1，b.i訪問的是父類中定義的變數i，成員變數是不會動態繫結而表現出多型性的。 d.g(); //輸出Derived.f() b.g(); //也輸出Derived.f()，從父類中呼叫被覆蓋的方法f()，也將呼叫到子類中更具體的方法。 } }

問： 寫出上面程式碼的輸出？

答案：參見程式碼註釋，子類和父類中定義同名的變數時，僅僅是隱藏了，變數沒有多型性；而對於覆蓋的方法，Java表現出多型性，

會呼叫更具體的子類裡面的方法，無論從哪裡呼叫，無論使用什麼引用型別呼叫。

4.閱讀下列程式碼回答問題（關於匿名內部類的理解）

interface A { void f(); } public class B { public void f(A a) { } public static void main(String[] args) { B b= new B(); b.f(new A() { public void f() { } }); } }

問：請解釋語句
b.f(new A() {
    public void f() {
    }
});
的含義與作用。

答案：

   這個語句在引數表中定義了一個匿名內部類，這個匿名內部類實現了介面A，例項化了一個匿名內部類的物件，並將這個物件傳遞給了接收介面A作為引數的方法f(A a)。需要注意的是介面A中的方法f()和類B中的方法f(A a)沒有任何關係，是不同的方法。

5. 閱讀下列程式碼回答問題（關於static的理解）

public class Static { static int i = 0; int j=0; public static void main(String[] args) { Static s1 = new Static(); Static s2 = new Static(); s1.i++; s2.i++; s1.j++; s2.j++; System.out.println(s1.i); System.out.println(s1.j); System.out.println(s2.i); System.out.println(s2.j); } }

問：寫出上面程式碼的輸出。

答案： 2 1 2 1，i是靜態變數，類的所有例項共享同一個i，通常我們不通過引用變數訪問靜態變數，而是通過類名訪問Static.i，注意Static是我們自己定義的類名，而小寫的static是關鍵字，表示靜態的，為類的所有例項共享的變數或方法。j是例項變數，每個物件具有不同的，屬於其自身的一個變數j。

6. 閱讀下列程式碼回答問題（關於引用變數的理解）

class Counter{ int i=0; } public class Reference { public void plus(int i){ i++; //不會改變傳遞進來的引數的值,Java傳遞基本型別時進行了值的拷貝 } public void plus(Counter c){ c.i++; //會改變，因為c是一個引用變數，相當於指標 } public void create(Counter c){ c = new Counter(); c.i++; //不會改變，因為c執行了另外一個新建的物件 } public static void main(String[] args) { int i = 0; Reference r = new Reference(); Counter c1 = new Counter(); Counter c2 = new Counter(); r.plus(i); r.plus(c1); r.create(c2); System.out.println(i); System.out.println(c1.i); System.out.println(c2.i); } }

問：上面程式碼輸出是？

答案：參考程式碼註釋，輸出應該是：0 1 0

7. 閱讀下列程式碼回答問題（關於異常的理解）

class MyException extends Exception{ public MyException(String message){ super(message); } } public class ExceptionDemo{ public void f(int num) throws MyException { if(num<0){ throw new MyException("引數不能為負數！"); } System.out.println(num); } public void g(){ try{ f(1); f(3); f(0); f(-1); f(2); f(-5); }catch(MyException e){ System.err.println(e.getMessage()); return;//會立即返回嗎？答：不會！ }finally{ System.out.println("無論什麼時候！"); } } public static void main(String[] args) { ExceptionDemo demo = new ExceptionDemo(); demo.g(); } }

問：上面程式碼輸出是？

答案：輸出是：1 3 0 引數不能為負數! 無論什麼時候!

try語句塊裡面的一行程式碼丟擲了異常，後續程式碼就不再執行了，而是轉到catch開始匹配異常型別。finally語句塊裡面的程式碼始終會被執行，即使在catch語句塊裡面有行return語句也不會立即返回，Java確保finally語句塊執行完函式才會返回。