【課前思考】 
　　1． 什麼是物件？什麼是類？什麼是包？什麼是介面？什麼是內部類？ 
　　2． 面向物件程式設計的特性有哪三個？它們各自又有哪些特性？ 
　　3． 你知道java語言在面向物件程式設計方面有何獨特的特點嗎？ 

難點： 
　　1． 理解方法過載和方法重寫，不要混淆了兩者的使用。 
　　2． 類變數和類方法的使用。 
　　3． 介面的使用。 
3．1 面向物件技術基礎 http://hovertree.com/menu/java/

3．1．1 面向物件的基本概念 
　　面向物件的基本思想 
　　面向物件是一種新興的程式設計方法,或者是一種新的程式設計規範(paradigm),其基本思想是使用物件、類、繼承、封裝、訊息等基本概念來進行程式設計。從現實世界中客觀存在的事物（即物件）出發來構造軟體系統，並且在系統構造中儘可能運用人類的自然思維方式。開發一個軟體是為了解決某些問題，這些問題所涉及的業務範圍稱作該軟體的問題域。其應用領域不僅僅是軟體，還有計算機體系結構和人工智慧等。 

1． 物件的基本概念 
　　物件是系統中用來描述客觀事物的一個實體，它是構成系統的一個基本單位。一個物件由一組屬性和對這組屬性進行操作的一組服務組成。 

主動物件是一組屬性和一組服務的封裝體，其中至少有一個服務不需要接收訊息就能主動執行（稱作主動服務）。 
2． 類的基本概念 
類是具有相同屬性和服務的一組物件的集合，它為屬於該類的所有物件提供了統一的抽象描述，其內部包括屬性和服務兩個主要部分。在面向物件的程式語言中，類是一個獨立的程式單位，它應該有一個類名幷包括屬性說明和服務說明兩個主要部分。 

3． 訊息 

訊息就是向物件發出的服務請求，它應該包含下述資訊：提供服務的物件標識、服務標識、輸入資訊和回答資訊。服務通常被稱為方法或函式。 

3．1．2 面向物件的基本特徵 

1．封裝性 
　　封裝性就是把物件的屬性和服務結合成一個獨立的相同單位，並儘可能隱蔽物件的內部細節，包含兩個含義： 
　　◇ 把物件的全部屬性和全部服務結合在一起，形成一個不可分割的獨立單位（即物件）。 
　　◇ 資訊隱蔽，即儘可能隱蔽物件的內部細節，對外形成一個邊界〔或者說形成一道屏障〕，只保留有限的對外介面使之與外部發生聯絡。 
　　封裝的原則在軟體上的反映是：要求使物件以外的部分不能隨意存取物件的內部資料（屬性），從而有效的避免了外部錯誤對它的"交叉感染"，使軟體錯誤能夠區域性化，大大減少查錯和排錯的難度。 

2．繼承性 
　　特殊類的物件擁有其一般類的全部屬性與服務，稱作特殊類對一般類的繼承。 

一個類可以是多個一般類的特殊類，它從多個一般類中繼承了屬性與服務，這稱為多繼承。 

在java語言中，通常我們稱一般類為父類（superclass,超類），特殊類為子類(subclass)。 

3．多型性 
　　物件的多型性是指在一般類中定義的屬性或服務被特殊類繼承之後，可以具有不同的資料型別或表現出不同的行為。這使得同一個屬性或服務在一般類及其各個特殊類中具有不同的語義。例如："幾何圖形"的"繪圖"方法，"橢圓"和"多邊形"都是"幾何圖"的子類，其"繪圖"方法功能不同。 
3．1．3 面向物件程式設計方法 
　　OOA－Object Oriented Analysis 　　　　面向物件的分析 
　　OOD－Object Oriented Design 　　　　　面向物件的設計 
　　OOI－Object Oriented Implementation 　面向物件的實現 
3．2 Java語言的面向物件特性 

3．2．1 類 
　　類是java中的一種重要的複合資料型別，是組成java程式的基本要素。它封裝了一類物件的狀態和方法，是這一類物件的原形。一個類的實現包括兩個部分：類宣告和類體 

1．類宣告： 
　　[public][abstract|final] class className [extends superclassName] [implements interfaceNameList] 
　　{……} 
　　其中，修飾符public,abstract,final 說明了類的屬性，className為類名，superclassName為類的父類的名字，interfaceNameList為類所實現的介面列表。 
　2．類體 
　　類體定義如下： 
　　class className 
　　{[public | protected | private ] [static] 
　　[final] [transient] [volatile] type 
　　variableName;　　　　　　　　　　　　　　　　　//成員變數 
　　[public | protected | private ] [static] 
　　[final | abstract] [native] [synchronized] 
　　returnType methodName([paramList]) [throws exceptionList] 
　　　{statements} 　　　　　　　　　　　　　　　 //成員方法 
　　} 
　3．成員變數 
　　成員變數的宣告方式如下： 
　　[public | protected | private ] [static] 
　　[final] [transient] [volatile] type 
　　variableName; 　　　　　　　　　　　　　　　　//成員變數 
　　其中， 
　　static: 靜態變數（類變數）；相對於例項變數 
　　final: 常量 
　　transient: 暫時性變數，用於物件存檔，用於物件的序列化，見物件的序列化一節 
　　volatile: 貢獻變數，用於併發執行緒的共享 
　4．成員方法 
　　方法的實現包括兩部分內容：方法宣告和方法體。 
　　[public | protected | private ] [static] 
　　[final　| abstract] [native] [synchronized] 
　　returnType methodName([paramList]) 
　　[throws exceptionList] 　　　　　　　　　　　//方法宣告 
　　　{statements} 　　　　　　　　　　　　　　　//方法體 
　　方法宣告中的限定詞的含義： 
　　static: 類方法，可通過類名直接呼叫 
　　abstract: 抽象方法，沒有方法體 
　　final: 方法不能被重寫 
　　native: 整合其它語言的程式碼 
　　synchronized: 控制多個併發執行緒的訪問 
　　◇ 方法宣告 
　　方法宣告包括方法名、返回型別和外部引數。其中引數的型別可以是簡單資料型別，也可以是複合資料型別（又稱引用資料型別）。 
　　對於簡單資料型別來說，java實現的是值傳遞，方法接收引數的值，但不能改變這些引數的值。如果要改變引數的值，則用引用資料型別，因為引用資料型別傳遞給方法的是資料在記憶體中的地址，方法中對資料的操作可以改變資料的值。 
　　例3-1說明了簡單資料型別與引用資料的區別。 
【例3-1】 
　　import java.io.*; 
　　public class PassTest{ 
　　float ptValue; 
　　public static void main(String args[]) { 
　　int val; 
　　PassTest pt=new PassTest(); 
　　val=11; 
　　System.out.println("Original Int Value is:"+val); 
　　pt.changeInt(val); 　　　　　　　　　　　　　　　　　　//值引數 
　　System.out.println("Int Value after Change is:" +val); /*值引數 
　　　　　　　　　　　　　　　　　　　 值的修改，沒有影響值引數的值*/ 
　　pt.ptValue=101f; 
　　System.out.println("Original ptValue is:"+pt.ptValue); 
　　pt.changeObjValue(pt); //引用型別的引數 
　　System.out.println("ptValue after Change is:"+pt.ptValue);/* 引用引數值的修改，改變了引用引數的值*/ 
　　} 
　　public void changeInt(int value){ 
　　value=55; 　　　　　　　　　　　//在方法內部對值引數進行了修改 
　　} 
　　public void changeObjValue(PassTest ref){ 
　　ref.ptValue=99f; 　　　　　　 //在方法內部對引用引數進行了修改 
　　　　} 
　　} 

◇ 方法體 
　　方法體是對方法的實現，它包括區域性變數的宣告以及所有合法的Java指令。方法體中宣告的區域性變數的作用域在該方法內部。若區域性變數與類的成員變數同名，則類的成員變數被隱藏。 
為了區別引數和類的成員變數，我們必須使用this。this-----用在一個方法中引用當前物件，它的值是呼叫該方法的物件。返回值須與返回型別一致，或者完全相同，或是其子類。當返回型別是介面時，返回值必須實現該介面。 
5．方法過載 
　方法過載是指多個方法享有相同的名字，但是這些方法的引數必須不同，或者是引數的個數不同，或者是引數型別不同。返回型別不能用來區分過載的方法。 
　　引數型別的區分度一定要足夠，例如不能是同一簡單型別的引數，如int與long。編譯器會根據引數的個數和型別來決定當前所使用的方法。 

6． 構造方法 
　　◇ 構造方法是一個特殊的方法。Java 中的每個類都有構造方法，用來初始化該類的一個物件。 
　　◇ 構造方法具有和類名相同的名稱，而且不返回任何資料型別。 
　　◇ 過載經常用於構造方法。 
　　◇ 構造方法只能由new運算子呼叫 

3．2．2 物件 
　　類例項化可生成物件，物件通過訊息傳遞來進行互動。訊息傳遞即啟用指定的某個物件的方法以改變其狀態或讓它產生一定的行為。一個物件的生命週期包括三個階段：生成、使用和消除。 

物件的清除 
　　當不存在對一個物件的引用時，該物件成為一個無用物件。Java的垃圾收集器自動掃描物件的動態記憶體區，把沒有引用的物件作為垃圾收集起來並釋放。 
　　System.gc( );　　System.exit();//terminate the current JVM 
　　當系統記憶體用盡或呼叫System.gc( )要求垃圾回收時，垃圾回收執行緒與系統同步執行。 
3．2．3 面向物件特性 
　　java語言中有三個典型的面向物件的特性：封裝性、繼承性和多型性。 

1． 封裝性 
　　java語言中，物件就是對一組變數和相關方法的封裝，其中變量表明瞭物件的狀態，方法表明了物件具有的行為。通過物件的封裝，實現了模組化和資訊隱藏。通過對類的成員施以一定的訪問許可權，實現了類中成員的資訊隱藏。 
◇ java類中的限定詞 
　　java語言中有四種不同的限定詞，提供了四種不同的訪問許可權。 
　　1） private 
　　類中限定為private的成員，只能被這個類本身訪問。 
　　如果一個類的構造方法宣告為private,則其它類不能生成該類的一個例項。 
　　2） default 
　　類中不加任何訪問許可權限定的成員屬於預設的（default）訪問狀態：friend，可以被這個類本身和同一個包中的類所訪問。 
3） protected 
　　類中限定為protected的成員，可以被這個類本身、它的子類（包括同一個包中以及不同包中的子類）和同一個包中的所有其他的類訪問。 
4） public 
　　類中限定為public的成員，可以被所有的類訪問。 
【表3-1】　java中類的限定詞的作用範圍比較 


同一個類 
同一個包 
不同包的子類 
不同包非子類 

private 
* 




default 
* 
* 



protected 
* 
* 
* 


public 
* 
* 
* 
* 




2． 繼承性 
　　通過繼承實現程式碼複用。Java中所有的類都是通過直接或間接地繼承java.lang.Object類得到的。繼承而得到的類稱為子類，被繼承的類稱為父類。子類不能繼承父類中訪問許可權為private的成員變數和方法。子類可以重寫父類的方法，及命名與父類同名的成員變數。但Java不支援多重繼承，即一個類從多個超類派生的能力。 
◇ 成員變數的隱藏和方法的重寫 
　　子類通過隱藏父類的成員變數和重寫父類的方法，可以把父類的狀態和行為改變為自身的狀態和行為。 
例如： 
　　class SuperClass{ 
　　　　int x; … 
　　　　void setX( ){ x=0; } … 
　　} 
　　class SubClass extends SuperClass{ 
　　　　int x; 　　//隱藏了父類的變數x 
　　　　… 
　　　　void setX( ) { //重寫了父類的方法 setX() 
　　　　x=5; } …. 
　　} 
　　注意：子類中重寫的方法和父類中被重寫的方法要具有相同的名字，相同的引數表和相同的返回型別，只是函式體不同。 
　　◇ super 
　　java中通過super來實現對父類成員的訪問，super用來引用當前物件的父類。Super 的使用有三種情況： 
　　1）訪問父類被隱藏的成員變數，如： 
　　　　super.variable; 
　　2）呼叫父類中被重寫的方法，如： 
　　　　super.Method([paramlist]); 
　　3）呼叫父類的建構函式，如： 
　　　　super([paramlist]); 

【例3-5】 
　　import java.io.*; 
　　class SuperClass{ 
　　　　int x; 
　　　　SuperClass( ) { 
　　　　　x=3; 
　　　　　System.out.println("in SuperClass : x=" +x); 
　　　　} 
　　　　　void doSomething( ) { 
　　　　　System.out.println("in SuperClass.doSomething()"); 
　　　　} 
　　} 
　　class SubClass extends SuperClass { 
　　　　int x; 
　　　　SubClass( ) { 
　　　　　super( ); 　　　//呼叫父類的構造方法 
　　　　　x=5;　　　　　　//super( ) 要放在方法中的第一句 
　　　　　System.out.println("in SubClass :x="+x); 
　　　　} 
　　　　　void doSomething( ) { 
　　　　　super.doSomething( ); //呼叫父類的方法 
　　　　　System.out.println("in SubClass.doSomething()"); 
　　　　　System.out.println("super.x="+super.x+" sub.x="+x); 
　　　　} 
　　} 
　　public class Inheritance { 
　　　　　public static void main(String args[]) { 
　　　　　SubClass subC=new SubClass(); 
　　　　　subC.doSomething(); 
　　　　} 
　　} 

3． 多型性 
　　在java語言中，多型性體現在兩個方面：由方法過載實現的靜態多型性（編譯時多型）和方法重寫實現的動態多型性（執行時多型）。 
　　1） 編譯時多型 
　　在編譯階段，具體呼叫哪個被過載的方法，編譯器會根據引數的不同來靜態確定呼叫相應的方法。 
　　2） 執行時多型 
　　由於子類繼承了父類所有的屬性（私有的除外），所以子類物件可以作為父類物件使用。程式中凡是使用父類物件的地方，都可以用子類物件來代替。一個物件可以通過引用子類的例項來呼叫子類的方法。 
　　◇ 重寫方法的呼叫原則：java執行時系統根據呼叫該方法的例項，來決定呼叫哪個方法。對子類的一個例項，如果子類重寫了父類的方法，則執行時系統呼叫子類的方法；如果子類繼承了父類的方法（未重寫），則執行時系統呼叫父類的方法。 
在例3-6中，父類物件a引用的是子類的例項，所以，java執行時呼叫子類B的callme方法。 

【例3-6】 
　　import java.io.*; 
　　class A{ 
　　　　　void callme( ) { 
　　　　　　System.out.println("Inside A''s callme()method"); 
　　　　　} 
　　} 
　　class B extends A{ 
　　　　　void callme( ) { 
　　　　　　System.out.println("Inside B''s callme() Method"); 
　　　　　} 
　　} 
　　public class Dispatch{ 
　　　　　public static void main(String args[]) { 
　　　　　　A a=new B(); 
　　　　　　a.callme( ); 
　　　　　} 
　　} 
◇ 方法重寫時應遵循的原則： 
　　1）改寫後的方法不能比被重寫的方法有更嚴格的訪問許可權（可以相同）。 
　　2）改寫後的方法不能比重寫的方法產生更多的例外。 
4． 其它 
　　◇ final 關鍵字 
　　final 關鍵字可以修飾類、類的成員變數和成員方法，但final 的作用不同。 
　　1） final 修飾成員變數： 
　　final修飾變數,則成為常量，例如 
　　final type variableName; 
　　修飾成員變數時，定義時同時給出初始值，且以後不能被修改，而修飾區域性變數時不做要求。 
　　2） final 修飾成員方法： 
　　final修飾方法，則該方法不能被子類重寫 
　　final returnType methodName(paramList){ 
　　… 
　　} 

　　3） final 類： 
　　final修飾類，則類不能被繼承 
　　final class finalClassName{ 
　　… 
　　} 
　　◇ 例項成員和類成員 
　　用static 關鍵字可以宣告類變數和類方法，其格式如下： 
　　static type classVar; 
　　static returnType classMethod({paramlist}) { 
　　… 
　　} 
　如果在宣告時不用static 關鍵字修飾，則宣告為例項變數和例項方法。 
　　1） 例項變數和類變數 
　　每個物件的例項變數都分配記憶體，通過該物件來訪問這些例項變數，不同的例項變數是不同的。 
　　類變數僅在生成第一個物件時分配記憶體，所有例項物件共享同一個類變數，每個例項物件對類變數的改變都會影響到其它的例項物件。類變數可通過類名直接訪問，無需先生成一個例項物件，也可以通過例項物件訪問類變數。 
　　2） 例項方法和類方法 
　　例項方法可以對當前物件的例項變數進行操作，也可以對類變數進行操作，例項方法由例項物件呼叫。 
　　但類方法不能訪問例項變數，只能訪問類變數。類方法可以由類名直接呼叫，也可由例項物件進行呼叫。類方法中不能使用this或super關鍵字。 
　　例3-7 是關於例項成員和類成員的例子。 
【例3-7】 
　　class Member { 
　　　　static int classVar; 
　　　　int instanceVar; 
　　　　static void setClassVar(int i) { 
　　　　　classVar=i; 
　　　　　// instanceVar=i; // 類方法不能訪問例項變數 
　　　　} 
　　　　static int getClassVar() 
　　　　　{ return classVar; } 
　　　　void setInstanceVar(int i) 
　　　　　{ classVar=i; //例項方法不但可以訪問類變數，也可以例項變數 
　　　　　instanceVar=i; } 
　　　　　int getInstanceVar( ) 
　　　　　{ return instanceVar; } 
　　　　} 
　　　　public class MemberTest{ 
　　　　　public static void main(String args[]) { 
　　　　　　　　 Member m1=new member(); 
　　　　　　　　 Member m2=new member(); 
　　　　　　　　 m1.setClassVar(1); 
　　　　　　　　 m2.setClassVar(2); 
　　　　　　　　 System.out.println("m1.classVar="+m1.getClassVar()+" 
　　　　　　　　 　　　　　　　　　　m2.ClassVar="+m2.getClassVar()); 
　　　　　　　　 m1.setInstanceVar(11); 
　　　　　　　　 m2.setInstanceVar(22); 
　　　　　　　　 System.out.println("m1.InstanceVar="+m1.getInstanceVar 
　　　　　　　　　　　　　　()+" m2.InstanceVar="+m2.getInstanceVar()); 
　　　　　} 
　　　　} 
◇ 類java.lang.Object 
　　類java.lang.Object處於java開發環境的類層次的根部，其它所有的類都是直接或間接地繼承了此類。該類定義了一些最基本的狀態和行為。下面，我們介紹一些常用的方法。 
　　equals() ：比較兩個物件(引用)是否相同。 
　　getClass()：返回物件執行時所對應的類的表示，從而可得到相應的資訊。 
　　toString()：用來返回物件的字串表示。 
　　finalize()：用於在垃圾收集前清除物件。 
　　notify(),notifyAll(),wait()：用於多執行緒處理中的同步。 

3．2．4抽象類和介面 

　1． 抽象類 
　　java語言中，用abstract 關鍵字來修飾一個類時，這個類叫做抽象類，用abstract 關鍵字來修飾一個方法時，這個方法叫做抽象方法。格式如下： 
　　abstract class abstractClass{ …} //抽象類 
　　abstract returnType abstractMethod([paramlist]) //抽象方法 
　　抽象類必須被繼承，抽象方法必須被重寫。抽象方法只需宣告，無需實現；抽象類不能被例項化，抽象類不一定要包含抽象方法。若類中包含了抽象方法，則該類必須被定義為抽象類。 

若一個類繼承了一個抽象類，則抽象類的抽象方法必須被實現，否則子類必須宣告為abstract. 
　2． 介面 
　　介面是抽象類的一種，只包含常量和方法的定義，而沒有變數和方法的實現，且其方法都是抽象方法。它的用處體現在下面幾個方面： 
　　◇ 通過介面實現不相關類的相同行為,而無需考慮這些類之間的關係。 
　　◇ 通過介面指明多個類需要實現的方法。 
　　◇ 通過介面瞭解物件的互動介面,而無需瞭解物件所對應的類。 
1）介面的定義 
　　介面的定義包括介面宣告和介面體。 
　　介面宣告的格式如下： 
　　[public] interface interfaceName[extends listOfSuperInterface] { … } 
　 extends 子句與類宣告的extends子句基本相同，不同的是一個介面可有多個父介面，用逗號隔開，而一個類只能有一個父類。 
　　介面體包括常量定義和方法定義 
　　常量定義格式為：type NAME=value; 該常量被實現該介面的多個類共享; 具有public ,final, static的屬性。在介面中只能宣告常量，不可以宣告變數。 
　　方法體定義格式為：(具有 public和abstract屬性，不能宣告為protected) 
　　returnType methodName([paramlist])； 

注意：在介面的實現類中，實現的介面方法必須宣告為public ，因為介面中定義的方法為public（預設）。所以其實現必須宣告為public.否則編譯不會通過。 
2）介面的實現 
　　在類的宣告中用implements子句來表示一個類使用某個介面，在類體中可以使用介面中定義的常量，而且必須實現介面中定義的所有方法。一個類可以實現多個介面,在implements子句中用逗號分開。 
3） 介面型別的使用 
　　介面作為一種引用型別來使用。任何實現該介面的類的例項都可以儲存在該介面型別的變數中，通過這些變數可以訪問類所實現的介面中的方法。 
3．2．5 內部類 

　1． 內部類的定義和使用： 
　　內部類是在一個類的內部巢狀定義的類，它可以是其它類的成員，也可以在一個語句塊的內部定義，還可以在表示式內部匿名定義。 
　　內部類有如下特性： 
　　◇ 一般用在定義它的類或語句塊之內,在外部引用它時必須給出完整的名稱.名字不能與包含它的類名相同。 
　　◇ 可以使用包含它的類的靜態和例項成員變數,也可以使用它所在方法的區域性變數。 
　　◇ 可以定義為abstract。 
　　◇ 可以宣告為private或protected。 
　　◇ 若被宣告為static,就變成了頂層類,不能再使用區域性變數。 
　　◇ 若想在Inner Class中宣告任何static成員,則該Inner Class必須宣告為static。 
例3-8】 
　　import java.awt.*; 
　　import java.awt.event.*; 
　　public class TwoListenInner { 
　　　　private Frame f; 
　　　　private TextField tf; 
　　　　　　public static void main(String args[]) { 
　　　　　　　TwoListenInner that=new TwoListenInner(); 
　　　　　　　that.go(); 
　　　　} 
　　　　public void go() { 
　　　　　　　f=new Frame("Two listeners example"); 
　　　　　　　f.add("North",new Label("Click and drag the mouse")); 
　　　　　　　tf=new TextField(30); 
　　　　　　　f.add("South",tf); 
　　　　　　　f.addMouseMotionListener(new MouseMotionHandler());//http://hovertree.com/menu/java/  
　　　　　　　f.addMouseListener(new MouseEventHandler()); 
　　　　　　　f.setSize(300,300); 
　　　　　　　f.setVisible(true); 
　　　　} // 何問起
　　　　public class MouseMotionHandler extends MouseMotionAdapter { 
　　　　　　public void mouseDragged(MouseEvent e){ 
　　　　　　　String s="Mouse dragging:X="+e.getX()+"Y="+e.getY(); 
　　　　　　　tf.setText(s); 
　　　　　　} 
　　　　} 
　　　　public class MouseEventHandler extends MouseAdapter { 
　　　　　　public void mouseEntered(MouseEvent e){ 
　　　　　　　String s="The mouse entered"; 
　　　　　　　tf.setText(s); 
　　　　　　} 
　　　　　　public void mouseExited(MouseEvent e){ 
　　　　　　　String s="The mouse left the building"; 
　　　　　　　tf.setText(s); 
　　　　　　} 
　　　　} 
　　} 

說明：Frame類的add方法來自於其祖先類Container類，addMouseMotionListener和addMouseListener方法來自於其祖先類Component, addMouseListener方法的引數為MouseListener介面，MouseAdapter類是實現了MouseListener介面的類。可見圖形介面對於外部事件的響應是通過新增listener實現的 
2． 匿名類的定義和使用： 
　　匿名類是一種特殊的內部類，它是在一個表示式內部包含一個完整的類定義。通過對例6-7中go()部分語句的修改，我們可以看到匿名類的使用情況。 
　　public void go() { 
　　　　　　　　　f=new Frame("Two listeners example"); 
　　　　　　　　　f.add("North",new Label("Click and drag the mouse")); 
　　　　　　　　　tf=new TextField(30); 
　　　　　　　　　f.add("South",tf); 
　　　　　　　　　f.addMouseMotionListener(new MouseMotionHandler(){ 
　　　　　　　　　/*定義了一個匿名類，類名沒有顯式地給出，只是該類是 
　　　　　　　　　　MouseMotionHandler類的子類*/ 
　　　　　　　　　　　public void mouseDragged(MouseEvent e){ 
　　　　　　　　　　　　　String s="Mouse dragging:X="+e.getX()+"Y 
　　　　　　　　　　　　　="+e.getY(); 
　　　　　　　　　　　　　tf.setText(s); 
　　　　　　　　　　　} 
　　　　　　　　　}); 
　　　　　　　　　f.addMouseListener(new MouseEventHandler()); 
　　　　　　　　　f.setSize(300,300); 
　　　　　　　　　f.setVisible(true); 
　　　　　　　　　} 
　3． 內部類的優缺點： 
　　◇ 優點:節省編譯後產生的位元組碼檔案的大小 
　　◇ 缺點:使程式結構不清楚 

習題： 

1 ：造型不可以從父類向子類造型，只能從子類向父類造型。否則編譯 時可以通過，執行時會報錯 

如：SubClass sc = new SubClass(); BaseClass bc = (BaseClass)sc ;---是正確的 

而 BaseClass bc = new BaseClass(); SubClass sc = (SubClass)bc ;---是錯誤的 

BaseClass bc = new SubClass()也是正確的，並且在呼叫bc中的方法時執行的方法體是子類的方法體，但該方法必須同時在子類，父類中同時存在，若子類中有，而父類中沒有，則不可以這樣呼叫bc.subMethod(); 

若兩個類都繼承於同一個類(必須是直接繼承，否則不對)，則這兩個類可以互相賦值，如：Panel和Frame 同繼承於Container，所以Panel p = new Frame() ；和Frame f = new Panel()都是正確的