semovy

在Java中，類(class)是用來代表對(duì)象的基本單元。對(duì)象(object)可以是現(xiàn)實(shí)世界中的任何一個(gè)實(shí)體，它具有若干區(qū)別于其它對(duì)象的屬性和操作。而類則通過為對(duì)象定義屬性和操作來概括一類實(shí)體。它封裝了一組變量和方法，是生成實(shí)例對(duì)象時(shí)的模板。如一輛汽車可視為一個(gè)對(duì)象，它既具有型號(hào)、顏色、載重等特點(diǎn)，又有完成啟動(dòng)、行駛、剎車等功能。定義汽車類時(shí)需要將這些屬性都包括進(jìn)去，通常用數(shù)據(jù)變量代表型號(hào)、顏色、載重等屬性特點(diǎn)，用成員方法來實(shí)現(xiàn)啟動(dòng)、行駛、剎車等操作功能。可以說類是對(duì)象的抽象，對(duì)象是類的實(shí)例化。
　　接口(interface)可看成一個(gè)空的抽象的類，只聲明了一組類的若干同名變量和方法，而不考慮方法的具體實(shí)現(xiàn)。Java的包(package)中包含一系列相關(guān)的類，同一個(gè)包中的類可直接互相使用，對(duì)包外的類則有一定的使用限制。Java的包近似于其它語(yǔ)言的函數(shù)庫(kù)，可提供重用的方便。
　　在下面各部分的詳細(xì)介紹中，我們將先給出基本概念，然后結(jié)合具體實(shí)例闡明Java的類、接口、包以及封裝、繼承、重載等有關(guān)內(nèi)容。

 

4.1 Java的類

　　4.1.1 類的聲明

　　Java是一種很典型的面向?qū)ο蟮某绦蛟O(shè)計(jì)語(yǔ)言。在面向?qū)ο蟮恼Z(yǔ)言中，世界被看成獨(dú)立的對(duì)象集合，相互間通過消息來通信。因而這種語(yǔ)言以數(shù)據(jù)對(duì)象為中心，而不以處理對(duì)象的代碼為中心。Java中的類將數(shù)據(jù)和有關(guān)的操作封裝在一起，描述一組具有相同類型的對(duì)象，作為構(gòu)筑程序的基本單位。
　　類聲明定義的格式為：
　　[類修飾符] class類名 [extends　父類名][implements　接口名]
其中類修飾符用于指明類的性質(zhì)，可缺省。接下來的關(guān)鍵字class指示定義的類的名稱，類名最好是唯一的。“extends 父類名”通過指出所定義的類的父類名稱來表明類間的繼承關(guān)系，當(dāng)缺省時(shí)意味著所定義類為Object類的子類。“implements 接口名”用來指出定義的類實(shí)現(xiàn)的接口名稱。一個(gè)類可以同時(shí)實(shí)現(xiàn)多個(gè)接口。類體則包括一系列數(shù)據(jù)變量和成員方法的定義聲明。下面是一些略去類體的類定義例子：
　　public class WelcomeApp
　　public class Welcome extends java.applet.Applet
　　public Car extends Automobile implements Runable
其中前兩個(gè)類是我們?cè)谏弦徽碌氖纠卸x的。第三個(gè)類是小汽車類Car，它的父類是交通工具類Automobile，它還實(shí)現(xiàn)了接口Runnable。
　　類修飾符是用以指明類的性質(zhì)的關(guān)鍵字。基本的類修飾符有三個(gè)：
　　public，abstract和final
　　■public
　　如果一個(gè)類被聲明為public，那么與它不在同一個(gè)包中的類也可以通過引用它所在的包來使用這個(gè)類；否則這個(gè)類就只能被同一個(gè)包中的類使用。
　　■abstract
　　如果一個(gè)類被聲明為abstract，那么它是一個(gè)抽象的類，不能被實(shí)例化生成自己的對(duì)象，通常只是定義了它的子類共有的一些變量和方法供繼承使用。被聲明為abstract的抽象類往往包含有被聲明為abstract的抽象方法，這些方法由它的非抽象子類完成實(shí)現(xiàn)細(xì)節(jié)。
　　■final
　　如果一個(gè)類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承。因此一個(gè)類不能既被聲明為abstract的，又被聲明為final的。
　　繼承是面向?qū)ο蟪绦蛟O(shè)計(jì)中一個(gè)強(qiáng)有力的工具，它允許在已存在的類的基礎(chǔ)上創(chuàng)建新的類。新創(chuàng)建的類稱為其基礎(chǔ)類的子類，基礎(chǔ)類稱為其子類的父類。子類的對(duì)象除了具有新定義的屬性和方法外，還自動(dòng)具有其父類定義的部分或全部屬性方法。這樣程序員可以在子類中重用父類中已定義好的變量和方法，只需對(duì)子類中不同于父類或新添加的部分重新定義，這樣就節(jié)省了大量的時(shí)間、空間和精力。Java在類聲明中使用
　　extends 父類名
的方式定義繼承關(guān)系。如果不明顯地寫出繼承的父類名，則缺省地認(rèn)為所聲明的類是Java的Object類的一個(gè)子類。Object類是Java中所有的類的祖先類。我們可以把這種類繼承關(guān)系想象為一棵倒置的類家族樹，Object類就是這棵樹的根。

　　4.1.2 類的組成

　　我們已經(jīng)知道類是代表對(duì)象的，而每一個(gè)對(duì)象總有特定的狀態(tài)和行為，在類中分別用變量數(shù)據(jù)和在數(shù)據(jù)上可進(jìn)行的操作表示這些狀態(tài)和行為。因此類的組成成分是變量和方法。變量和方法的聲明格式如下：
　　[變量修飾符]　數(shù)據(jù)類型　變量名[=初值]　;
　　[方法修飾符]　返回值類型　方法名(參數(shù)表)
其中修飾符用來指明變量和方法的特性。變量可一次定義一個(gè)或多個(gè)，定義時(shí)可以給出初值。例如：
　　public int a,b=12;
　　protected String s="Hot Java";
定義方法時(shí)一定要給出返回值類型和參數(shù)表。當(dāng)沒有返回值時(shí)，返回值類型記為void。參數(shù)表的形式為：
　　參數(shù)類型 參數(shù)值{，參數(shù)類型 參數(shù)值}
各參數(shù)間以逗號(hào)分隔。下面是一些簡(jiǎn)單的例子：
　　public static void main(String args[])
　　public void paint(Graphics g)
　　public int area(int length,int width){return length * width;}
其中前兩個(gè)是我們?cè)诘谌乱呀?jīng)見過的方法聲明，這里略去了具體語(yǔ)句組成的方法體。第三個(gè)則是一個(gè)計(jì)算長(zhǎng)方形面積的簡(jiǎn)單方法，接受整數(shù)類型的長(zhǎng)度和寬度參數(shù)并返回它們的乘積作為結(jié)果。
　　變量和方法修飾符是用來指明特性的關(guān)鍵字，主要有以下幾種：
　　■public
　　一個(gè)類中被聲明為public的變量和方法是“公開”的，意味著只要能使用這個(gè)類，就可以直接存取這個(gè)變量的數(shù)據(jù)，或直接使用這個(gè)方法。
　　■protected
　　一個(gè)類中被聲明為protected的變量和方法是“受限”的，意味著它們僅能被與該類處于同一個(gè)包的類及該類的子類所直接存取和使用。
　　■private
　　被聲明為private的變量和方法是“私有”的，除了聲明它們的類外，不能被任何其它的類直接存取和使用。
　　當(dāng)變量或方法前不加以上三種修飾符時(shí)，被認(rèn)為取friendly狀態(tài)，即它們只能被同一個(gè)包中的類直接存取和使用。但不存在friendly關(guān)鍵字。
　　■static
　　被聲明為static的變量和方法是屬于類而不是屬于對(duì)象的。不管這個(gè)類產(chǎn)生了多少個(gè)對(duì)象，它們都共享這個(gè)類變量或類方法。我們可以在不創(chuàng)建類實(shí)例對(duì)象時(shí)直接使用類變量和類方法。一般來說，在Java中，引用一個(gè)特定的變量或方法的形式是：
　　對(duì)象名.變量名
　　對(duì)象名.方法名
例如：
　　int a=rectangle.length;
　　g.drawString("Welcome to Java World!");
即變量和方法是受限于對(duì)象的，但聲明為static的變量或方法受限于類，使用形式是
　　類名.變量名
　　類名.方法名
例如：
　　System.out.println("Welcome to Java World!");
　　String s=String.valueOf(123);
這里我們并沒有創(chuàng)建System類或String類的對(duì)象，而直接調(diào)用System類的類變量out和String類的類方法valueOf。其中valueOf方法將整形參數(shù)轉(zhuǎn)換為String類對(duì)象。被聲明為static的類方法在使用時(shí)有兩點(diǎn)要特別注意：
　　(1)類方法的方法體中只能使用類中其它同樣是static的變量或方法；
　　(2)類方法不能被子類修改或重新定義。
　　■final
　　將變量或方法聲明為final，可以保證它們?cè)谑褂弥胁槐桓淖儭１宦暶鳛閒inal的變量必須在聲明時(shí)給定初值，而在以后的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重載。
　　■abstract
　　這個(gè)修飾符僅適用于方法。被聲明為abstract的方法不需要實(shí)際的方法體，只要提供方法原型接口，即給出方法的名稱、返回值類型和參數(shù)表，格式如下：
　　abstract　返回值類型　方法名(參數(shù)表)；
定義了abstract抽象方法的類必須被聲明為abstract的抽象類。

　　4.1.3 構(gòu)造方法和finalizer

　　Java中有兩個(gè)特殊的方法：用于創(chuàng)建對(duì)象的構(gòu)造方法(constructor)和用于撤銷對(duì)象的方法finalizer，相當(dāng)于C++中的構(gòu)造函數(shù)和析構(gòu)函數(shù)。構(gòu)造方法是生成對(duì)象時(shí)編譯器自動(dòng)調(diào)用的方法，用以給出對(duì)象中變量的初值。構(gòu)造方法必須與類同名，而且絕對(duì)不允許有返回值，甚至不允許以void來標(biāo)記無(wú)返回值。一個(gè)類的構(gòu)造方法可以有多個(gè)，以不同的參數(shù)表區(qū)分不同的情形，這是Java多態(tài)性的一個(gè)體現(xiàn)。下面是一個(gè)簡(jiǎn)單的例子。
　　例4.1 Rectangle類的構(gòu)造方法。
　　class Rectangle{
　　　protected int width;/*類Rectangle的兩個(gè)整型變量*/
　　　protected int height;/*分代表長(zhǎng)方形的長(zhǎng)和寬*/
　　　/*下面是類Rectangle的三個(gè)構(gòu)造方法*/
　　　/*第一個(gè)構(gòu)造方法，無(wú)參數(shù)，缺省地給出長(zhǎng)和寬*/
　　　　Rectangle()
　　　/*第二個(gè)構(gòu)造方法，給出長(zhǎng)、寬參數(shù)*/
　　　　Rectangle(int w,int h)
　　　/*第三個(gè)構(gòu)造方法，給出另一個(gè)Rectangle作參數(shù)*/
　　　　Rectangle(Rectangle r)
　　　　{width=r.width();
　　　　　height=r.height();
　　　　}
　　　/*下面是類Rectangle的另外兩個(gè)方法，分別為取長(zhǎng)和寬的值*/
　　　　public int width()
　　　　　{return width;}
　　　　public int height()
　　　　　{return height;}
　　}
　　class Test{
　　　Rectangle r1=new Rectangle();/*調(diào)用第一個(gè)構(gòu)造方法*/
　　　Rectangle r2=new Rectangle(12,20);/*調(diào)用第二個(gè)構(gòu)造方法*/
　　　Rectangle r3=new Rectangle(r1);/*調(diào)用第三個(gè)構(gòu)造方法*/
　　}
　　在這個(gè)例子中Rectangle有三個(gè)構(gòu)造方法，它們的名字相同，參數(shù)不同因而采用的調(diào)用形式也不同。第一個(gè)構(gòu)造方法不需要任何參數(shù)，調(diào)用時(shí)系統(tǒng)自動(dòng)地給出統(tǒng)一的固定的長(zhǎng)方形的寬和高(這里我們?cè)O(shè)定為20和30)。第二個(gè)構(gòu)造方法需要兩個(gè)整形參數(shù)，根據(jù)用戶給出的長(zhǎng)方形的寬和高創(chuàng)建長(zhǎng)方形對(duì)象。第三個(gè)構(gòu)造方法需要一個(gè)長(zhǎng)方形參數(shù)，創(chuàng)建出與這個(gè)長(zhǎng)方形具有同樣的寬和高的長(zhǎng)方形對(duì)象。在Rectangle類中，width和height都是protected的，不宜直接存取。為了使用方便，我們定義出width()和height()方法來獲得一個(gè)特定長(zhǎng)方形的寬和高，再將取得的數(shù)值傳遞給新創(chuàng)建的對(duì)象。像這樣在一類中有兩個(gè)或兩個(gè)以上同名方法的現(xiàn)象叫Overloading，是多態(tài)的一種表現(xiàn)。這樣同名方法應(yīng)該有且必須有不同的參數(shù)表，調(diào)用時(shí)編譯系統(tǒng)就是根據(jù)參數(shù)的匹配情況，包括個(gè)數(shù)和類型，來決定實(shí)際使用哪一個(gè)方法的。如果兩同名方法的參數(shù)表也相同，會(huì)造成混淆，編譯時(shí)將得到出錯(cuò)信息：
　　Duplicate method declaration
　　(重復(fù)的方法聲明)
　　為了實(shí)際創(chuàng)建出對(duì)象，我們要使用new。系統(tǒng)執(zhí)行遇到new，才根據(jù)new后面跟隨的構(gòu)造方法名和參數(shù)表，選擇合適的構(gòu)造方式，分配內(nèi)存，創(chuàng)建對(duì)象并初始化。一個(gè)類若沒有顯示地定義構(gòu)造方法，使用new時(shí)將調(diào)用它的父類的構(gòu)造方法，這種上溯可一直到達(dá)Object類，而Object類的構(gòu)造方法是語(yǔ)言預(yù)先定義好的。
　　相對(duì)于構(gòu)造方法，在對(duì)象被撤銷時(shí)調(diào)用的方法是finalizer。對(duì)所有的類，它的原始定義形式都是一樣的：
　　void finalize();
沒有返回值，而且沒有任何參數(shù)。一般來說，由于Java的內(nèi)存管理是由系統(tǒng)自動(dòng)完成，通常不需要我們重寫這個(gè)方法，而讓它自然而然地從父類(最終也就是從Object類)繼承。只有當(dāng)某些資源需要自動(dòng)歸還時(shí)，才需要將這一方法重寫。

　　4.1.4 重寫(Overriding)和重載(Overloading)

　　方法的重寫Overriding和重載Overloading是Java多態(tài)性的不同表現(xiàn)。前者是父類與子類之間多態(tài)性的一種表現(xiàn)，后者是一個(gè)類中多態(tài)性的一種表現(xiàn)。如果在子類中定義某方法與其父類有相同的名稱和參數(shù)，我們說該方法被重寫(Overriding)。子類的對(duì)象使用這個(gè)方法時(shí)，將調(diào)用子類中的定義，對(duì)它而言，父類中的定義如同被“屏蔽”了。如果在一個(gè)類中定義了多個(gè)同名的方法，它們或有不同的參數(shù)個(gè)數(shù)或有不同的參數(shù)類型，則稱為方法的重載(Overloading)。這在例4.1中已經(jīng)可以看到。下面再給出兩個(gè)簡(jiǎn)單的例子，分別顯示Overriding和Overloading。
　　例4.2 Overriding的例示
　　class Father{
　　　void speak(){
　　　　System.out.println("I am Father!");//父類定義的speak方法
　　　}
　　}
　　class Son extends Father{
　　　void speak(){
　　　　System.out.println("I am Son!");//子類重寫的speak方法
　　　}
　　}
　　public class Check{
　　　public static void main(String args[]){
　　　　Son x=new Son();
　　　　x.speak();//調(diào)用子類的speak方法
　　　}
　　}
　　//output of class Check!
　　I am Son!
　　從這個(gè)例子我們可以看到，類Son中的speak()方法重寫了其父類Father中一模一樣的方法，而它的對(duì)象x調(diào)用speak()方法的結(jié)果是與Son中定義致的。
　　例4.3　Overloading例示。
　　class Father{
　　　void speak(){　　//無(wú)參的speak方法
　　　　System.out.println("I am Father.");
　　　}
　　　void speak (String s){　　//有參的speak方法
　　　　System.out.println("I like"+s+".");
　　　}
　　}
　　public class Check{
　　　public static void main(String args[]){
　　　　Father x=new Father();
　　　　x.speak();//調(diào)用無(wú)參的speak方法
　　　　x.speak("music");//調(diào)用有參的speak方法
　　　}
　　}
　　//out put of class Check
　　I am Father
　　I like music.
　　這個(gè)例子中類的Father定義了兩個(gè)speak方法，在類Check中又兩次調(diào)用，一次無(wú)參，一次有參，打印出兩行不同的字符串。注意Java在打印字符串時(shí)，字符串間的連接用符號(hào)“+”來完成。

　　Overriding是父類與子類之間多態(tài)性的一種表現(xiàn)；Overloading是一個(gè)類中多態(tài)性的一種表現(xiàn)。

　　4.1.5 幾個(gè)特殊的變量：null，this和super

　　Java中有三個(gè)特殊的變量：null,this和super，這三個(gè)變量是所有的類都可以使用的，用來指示一些特定的對(duì)象。
　　null相當(dāng)于“空”，可以用來代指任何對(duì)象，但沒有實(shí)例。如
　　　　Rectangle r=null;
創(chuàng)建了一個(gè)Rectangle的變量r，但并沒有一個(gè)Rectangle的實(shí)例對(duì)象由r來代表。r就如同一個(gè)可放置Rectangle的盒子，只是這個(gè)盒子現(xiàn)在是空的。
　　this用以指代一個(gè)對(duì)象自身。它的作用主要是將自己這個(gè)對(duì)象作為參數(shù)，傳送給別的對(duì)象中的方法。它的使用形式是這樣的：
　　class Painter{
　　　　...
　　　　void drawing(Father y){
　　　　...
　　　　}
　　}
　　class Father{
　　　　...
　　　　void draw(Painter x)
　　　　{...
　　　　　x.drawing(this);/*將自身傳遞給x的drawing方法*/
　　　　　　...
　　　　}
　　}
　　class Test{
　　　...
　　　Father f=new Father();
　　　Painter p=new Painter();
　　　f.draw(p);
　　　...
　　}
例中調(diào)用Father類的draw方法時(shí)，使用語(yǔ)句
　　f.draw(p);
又Father類中定義draw方法時(shí)以this為參數(shù)調(diào)用了類Painter的drawing方法：
　　x.drawing(this);
因而實(shí)際上調(diào)用了Painter類對(duì)象p的drawing方法，而將Father類對(duì)象f作為參數(shù)傳遞給drawing方法.
　　super用來取用父類中的方法和變量數(shù)據(jù)。它的用法如在下面的例子中所示。
　　例4.4在類中使用super的例示。
　　/* Check.java */
　　class Father{
　　　void speak(){
　　　　System.out.println("I am Father.");
　　　}
　　　void speak(String s){
　　　　System.out.println("I like "+s+".");
　　　}
　　}
　　class Son extends Father{
　　　void speak(){
　　　　System.out.println("My father says.");
　　　　super.speak();//相當(dāng)于調(diào)用Father類的speak()方法
　　　　super.speak("hunting");
　　　　　//相當(dāng)于調(diào)用Father類的speak(String s)方法
　　　}
　　}
　　class Check{
　　　public static void main(String args[]){
　　　　Son s=new Son();
　　　　s.speak();
　　　}
　　}
　　//Check.java的執(zhí)行結(jié)果：
　　My father says:
　　I am Fater.
　　I like hunting.
　　在這個(gè)例子中，類Son的speak()方法語(yǔ)句
　　super.speak();
　　super.speak("hunting");
實(shí)際調(diào)用了Son的父類Father中的speak()和speak(String s)方法，以實(shí)現(xiàn)執(zhí)行結(jié)果后兩行的輸出。使用父類的變量形式也很類似。
　　super.變量名
　　super和this的另一個(gè)重要用途是用在構(gòu)造方法中。當(dāng)一個(gè)類中不止一個(gè)構(gòu)造方法時(shí)，可以用this在一個(gè)構(gòu)造方法中調(diào)用中一個(gè)構(gòu)造方法。若想調(diào)用父類的構(gòu)造函數(shù)，則直接使用super。例如我們可心如下定義例4.1中類Rectangle的子類ColorRectangle:
　　public class ColorRectaqngle extends Rectangle{
　　　int color;
　　　ColorRectangle(int w,int h,int c){
　　　　super(w,h);
　　　　color=c;
　　　}
　　　...
　　}
　　與父類Rectangle相比，類ColorRectangle增加了color成員變量代表長(zhǎng)方形的顏色。在它的構(gòu)造方法中，用語(yǔ)句
　　　　super(w,h);
調(diào)用了類Rectangle的構(gòu)造方法
　　　　Rectangle(int w,int h);
設(shè)定長(zhǎng)方形的長(zhǎng)和寬，然后就只需設(shè)定長(zhǎng)方形的顏色：
　　　　color=c;
這樣大大提高了代碼的重用性。

4.2 Java的包

　　在Java中，包的概念和目的都與其它語(yǔ)言的函數(shù)庫(kù)非常類似，所不同的只是其中封裝的是一組類。為了開發(fā)和重用的方便，我們可以將寫好的程序類整理成一個(gè)個(gè)程序包。Java自身提供了21個(gè)預(yù)先設(shè)定好的包，下面列出其中主要的幾個(gè)，其余讀者參看Java的API：
　　java.lang　　　　提供基本數(shù)據(jù)類型及操作
　　java.util　　　　提供高級(jí)數(shù)據(jù)類型及操作
　　java.io　　　　　提供輸入/輸出流控制
　　java.awt　　　　　提供圖形窗口界面控制
　　java.awt.event　　提供窗口事件處理
　　java.net　　　　　提供支持Internet協(xié)議的功能
　　java.applet　　　提供實(shí)現(xiàn)瀏覽器環(huán)境中Applet的有關(guān)類和方法
　　java.sql　　　　　提供與數(shù)據(jù)庫(kù)連接的接口
　　java.rmi　　　　　提供遠(yuǎn)程連接與載入的支持
　　java.security　　提供安全性方面的有關(guān)支持
　　我們可以引用這些包，也可以創(chuàng)建自己的包。

　　4.2.1 包的聲明

　　為了聲明一個(gè)包，首先必須建立一個(gè)相應(yīng)的目錄結(jié)構(gòu)，子目錄名與包名一致。然后在需要放入該包的類文件開頭聲明包，形式為：
　　package 包名；
這樣這個(gè)類文件中定義的所有類都被裝入到你所希望的包中。例如
　　package Family;
　　class Father{
　　　...//類Father裝入包Family
　　}
　　class Son{
　　　...//類Son裝入包Family
　　}
　　class Daughter{
　　　...　　//類Daughter裝入包Family
　　}
不同的程序文件內(nèi)的類也可以同屬于一個(gè)包，只要在這些程序文件前都加上同一個(gè)包的說明即可。譬如：
　　//文件 Cat.java
　　package Animals;
　　class Cat{/*將類Cat放入包Animals中*;
　　...
　　}
　　//文件Dog.java
　　package Animals;
　　class Dog{　　/*將類Dog放入包Animals中*/
　　...
　　}

　　4.2.2 包的使用

　　在Java中，為了裝載使用已編譯好的包，通常可使用以下三種方法：
　　(1) 在要引用的類名前帶上包名作為修飾符。如：
　　Animals.Cat cat=new Animals.Cat();
其中Animals是包名，Cat是包中的類，cat是類的對(duì)象。
　　(2)在文件開頭使用import引用包中的類。如：
　　import Animals.Cat;
　　class Check{
　　　Cat cat=new Cat();
　　}
同樣Animals是包名，Cat是包中的類，cat是創(chuàng)建的Cat類對(duì)象。
　　(3)在文件前使用import引用整個(gè)包。如：
　　import Animals.*;
　　class Check{
　　　Cat cat=new Cat();
　　　Dog dog=new Dog();
　　　...
　　}
Animals整個(gè)包被引入，Cat和Dog為包中的類，cat和dog為對(duì)應(yīng)類的對(duì)象。
　　在使用包時(shí)，可以用點(diǎn)“.” 表示出包所在的層次結(jié)構(gòu)，如我們經(jīng)常使用的
　　import java.io.*;
　　import java.applet.*;
實(shí)際是引入了/java/io/或/java/applet/這樣的目錄結(jié)構(gòu)下的所有內(nèi)容。需要指出的是，java.lang這個(gè)包無(wú)需顯式地引用，它總是被編譯器自動(dòng)調(diào)入的。使用包時(shí)還要特別注意系統(tǒng)classpath路徑的設(shè)置情況，它需要將包名對(duì)應(yīng)目錄的父目錄包含在classpath路徑中，否則編譯時(shí)會(huì)出錯(cuò)，提示用戶編譯器找不到指定的類。

4.3 一個(gè)郵件類(Mails)的例子

　　下面我們給出一個(gè)較大的例子，讓讀者在實(shí)例中進(jìn)一步熟悉Java的類和包。
　　這里所有的類都放在包c(diǎn)h4package中，先定義出一個(gè)虛基類Mails，然后派生出它的兩個(gè)子類Parcel(包裹)和Remittance(匯款)。Show類用于實(shí)際執(zhí)行，允許用戶創(chuàng)建自己的郵件，然后顯示出所有的郵件信息。為了方便地存取郵件，還定義了類ShowMails。接下來我們逐一介紹這經(jīng)些類。
　　例4.5 類Mails程序文件。
　　1：package ch4package;
　　2: public abstract class Mails{
　　3: 　protected String fromAddress;
　　4: 　protected String toAddress;
　　5: 　public abstract void showMe();
　　6: }
　　類Mails是一個(gè)虛類，不能產(chǎn)生自己的實(shí)例對(duì)象，而只是描述了郵件最基本的特性。類文件的開頭首先用
　　　　package cha4package;
表明Mails類是放于ch4package這個(gè)包里的。然后程序第二行為Mails的類聲明。
　　　　public abstract class Mails
　　用修飾符abstract指出這是個(gè)虛類。第三至第四行Mails類中定義了兩個(gè)變量：
　　　　protected String fromAddress;
　　　　protected String toAddress;
fromAddress和toAddress ,分別代表郵件的寄出地址和送往地址，都是protected類型的，這樣cha4package包外的類不能直接引用，保證了信息的隱藏。第五行Mails類定義了方法
showMe()，用于顯示一個(gè)郵件自身的有在信息：
　　　　public abstract voi showMe();
聲明時(shí)以abstract修飾，意味著這是一個(gè)抽象方法，只給出原型，具體實(shí)現(xiàn)要由Mails類的非虛子類通過Overriding完成。
　　接下來是Mails的兩個(gè)非虛子類。
　　例4.6　類Parcel和類Remittance程序文件。
　　//Parcel.java
　　1: package ch4package;
　　2: 　public class Parcel extends Mails{//郵件類的子類Parcel類
　　3: 　　protected int weight;
　　4: 　　Parcel(String address1,String address2,int w){//構(gòu)造方法
　　5: 　　fromAddress=address1;
　　6: 　　toAddress=address2;
　　7: 　　weight=w;
　　8: 　}
　　9: 　public void showMe(){
　　10:　　System.out.print("Parcel:");
　　11:　　System.out.println("\tFrom:"+fromAddress+"\tTo:"+toAddress);
　　12:　　System.out.println("\tWeigth:"+weight+"g");}
　　13:　}
　　//Remittance.java
　　1: package ch4package;
　　2: 　public class Remittance extends Mails{//郵件類的子類Remittance
　　3: 　　protected int money;
　　4: 　　Remittance(String address1,String address2,int m){//構(gòu)造方法
　　5: 　　fromAddress=address1;
　　6: 　　toAddress=address2;
　　7: 　　money=m;
　　8: 　}
　　9: 　public void showMe(){//顯示郵件信息
　　10:　　System.out.println("Remittance:");
　　11:　　System.out.println("\tFrom:"+fromAddress+"\tTo:"+toAddress);
　　12:　　System.out.println("\tMoney:"+money+" Yuan");
　　13:　}
　　14:}

這里是郵件的兩個(gè)子類：包裹Parcel和匯款Remittance。以類Parcel為例詳細(xì)說明。首先在程序開頭寫出：
　　package ch4package;
　　一方面將類Parcel裝入包c(diǎn)h4package，另一方面方便類Parcel使用包c(diǎn)h4package中的其它類，如已定義的Mails類。接下來類Parcel聲明時(shí)用
　　extends Mails
表明自己是Mails的一個(gè)子類。在第三行Parcel聲明了一個(gè)weight變量，用來代表包裹的重量。加上從父類Mails繼承下來的變量fromAddress和toAddress，類Parcel一共有三個(gè)成員變量：
　　寄出地址　fromAddress，寄達(dá)地址toAddress和重量weight
　　相對(duì)應(yīng)的，它的構(gòu)造方法Parcel也必須有三個(gè)參數(shù)，分別傳遞給三個(gè)成員變量。構(gòu)造方法的定義如第四行至第八行所示。由于Parcel類不是虛類，所以必須在其中重寫完成它的父類Mails中聲明的抽象方法showMe。Parcel的showMe()方法僅僅是將自己的郵件類型和三個(gè)變量的信息在屏幕上顯示出來。
　　類Remittance與Parcel非常相似，只是它定義的變量為money，用來代表匯款的金額。它也必須具體完成方法showMe。
　　下面我們看到的是用于存取郵件的類ShowMails。
　　例4.7 類ShowMails程序文件。
　　1: package ch4package;
　　2: import java.lang.*;
　　3: public class ShowMails{
　　4: 　protected Mails showList[];//郵件數(shù)組序列
　　5: 　protected static final int maxMails=50;//最大郵件個(gè)數(shù)
　　6: 　protected int numMails;//當(dāng)前郵件個(gè)數(shù)
　　7: 　ShowMails(){
　　8: 　　showList=new Mails[maxMails];
　　9: 　　numMails=0;
　　10:　}
　　11:　public void putMails(Mails mail){
　　12:　　if(numMails<maxMails){
　　13:　　　showList[numMails]=mail;//加入郵件
　　14:　　　numMails++;//修改計(jì)數(shù)
　　15:　　}
　　16:　}
　　17:　public Mails getMails(int index){//獲取郵件
　　18:　　if((0<=index)&&(index<numMails)) return showList[index];
　　19:　　else return null;
　　20:　}
　　21:　public void showAll(){//展示郵件
　　22:　　if(numMails>0)
　　23:　　　for (int i=0;i<numMails;i++){
　　24:　　　　System.out.print("Mail NO"+(i+1)+":");//郵件序號(hào)
　　25:　　　　showList[i].showMe();//郵件具體信息
　　26:　　　}
　　27:　　else
　　28:　　　System.out.println("No mails.");
　　29:　}
　　30:　public int mailnum(){
　　31:　　return numMails;
　　32:　}
　　33:}
　　程序第四行至第六行類ShowMails定義了三個(gè)成員變量：
　　　　showList[],maxMails和numMails
　　變量showList[]是類Mails的一個(gè)數(shù)組。但由于Mails本身是個(gè)虛類，因而showList[]的元素不可能是Mails的對(duì)象，它實(shí)際上是用來存放Mails的兩個(gè)子類Parcel和Remittance的對(duì)象的。一般說來，一個(gè)被聲明為類A的的變量，總可以被賦值為任何類A的子類的實(shí)例對(duì)象。這與父子類之間的類型轉(zhuǎn)換的原則是一致的：父類到子類的轉(zhuǎn)換可以隱式地自動(dòng)進(jìn)行，而子類到父類的轉(zhuǎn)換則需要顯式地加以說明。
　　變量maxMails用來指出showList[]中最多可容 納的郵件數(shù)，它對(duì)ShowMails的所有對(duì)象都應(yīng)是固定且一致的。因此它被聲明為tatatic和final的，為所有對(duì)象共享且不可更改。變量numMails則用來作為showList[]中實(shí)際郵件個(gè)數(shù)的計(jì)數(shù)。
　　對(duì)應(yīng)ShowMails的三個(gè)成員變量，我們?cè)赟howMails()構(gòu)造方法中只需做兩件事：實(shí)際創(chuàng)建類mails的數(shù)組showList[]，然后將郵件計(jì)數(shù)numMails置零。
　　第11行開始的方法putMails和第17行開始的方法getMails分別完成對(duì)showList[]中郵件的存取。第30行的mailnum方法則返回當(dāng)時(shí)的郵件計(jì)數(shù)值。putMails方法接受一個(gè)郵件類參數(shù)，并把它加入到當(dāng)前郵件序列的末尾。getMails方法接受一個(gè)整型參數(shù)作為郵件序號(hào)，根據(jù)該序號(hào)找出當(dāng)前郵件序列中對(duì)應(yīng)郵件返回。當(dāng)給定的郵件號(hào)index不在有效范圍時(shí)，以據(jù)該序號(hào)找出當(dāng)前郵件序列中對(duì)應(yīng)郵件返回。當(dāng)給定的郵件號(hào)index不在有效范圍時(shí)，以
　　　　return null;(19行)
返回一個(gè)定值。這一句看上去并沒有完成什么實(shí)質(zhì)性的工作，但如果省略則編譯時(shí)會(huì)出錯(cuò)。因?yàn)間etMails方法的返回值已聲明為Mails類，這就要求在任何情況下都返回一個(gè)符合這一要求的值。而空變量null可與任何類型匹配，恰好能適合這樣的要求。
　　第21行的方法showAll顯示showList[]中所有郵件的信息。每一郵件首先顯示自己的郵件號(hào)。因?yàn)閟howList[]數(shù)組的下標(biāo)從0開始，為了符合人們的日常習(xí)慣，將每一個(gè)下標(biāo)加1后再作為郵件號(hào)輸出。各個(gè)郵件的顯示是調(diào)用郵件的showMe()方法來實(shí)現(xiàn)的。因?yàn)閟howMe()方法已經(jīng)在虛類Mails中定義了，所以不管showList[]中的實(shí)際元素是Parcel還是Remittance，編譯器總能順利地連接調(diào)用相應(yīng)的代碼。Java面向?qū)ο筇匦灾械膭?dòng)態(tài)綁定(Dynamic Binding)，保證了無(wú)需在編譯前確定地知道showList[]每一個(gè)數(shù)組元素的類型，就能成功地實(shí)現(xiàn)這樣的鏈接。
　　最后給出的類是實(shí)際執(zhí)行的Shos類。
　　例4.8 類Show程序文件
　　1: package ch4package;
　　2: import java.io.*;
　　3:
　　4: public class Show{
　　5:　public static ShowMails board=new ShowMails();//郵件庫(kù)變量
　　6:　　public static void main(String args[])throws IOException{
　　7: 　　　boolean finished=false;
　　8:　　　BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
　　9:　　　while(!finished){//添加郵件
　　10:　　　　System.out.print("\nDo you want to add mails(Y/N)?");
　　11:　　　　System.out.flush();
　　12:　　　　char ch=in.readLine().charAt(0);
　　13:　　　　if('Y'==Character.toUpperCase(ch)){//輸入地址
　　14:　　　　System.out.println("Address information:");
　　15:　　　　System.out.print("\tFrom:");
　　16:　　　　System.out.flush();
　　17:　　　　String address1=in.readLine();
　　18:　　　　System.out.print("\tTo:");
　　19:　　　　System.out.flush();
　　20:　　　　String address2=in.readLine();
　　　　　　//選擇郵件各類(包裹或匯款)
　　21:　　　　System.out.print("Choose the mail type:1-Parcel 2-Remittance ");
　　22:　　　　System.out.flush();
　　23:　　　　ch=in.readLine().charAt(0);
　　24:　　　　if('1'==ch){//輸入包裹重量
　　25:　　　　　System.out.print("Parce\tWeight:");
　　26:　　　　　System.out.flush();
　　27:　　　　　int w=getInt();
　　28:　　　　　Parcel pa=new Parcel(address1,address2,w);
　　29:　　　　　board.putMails(pa);
　　30:　　　　}
　　31:　　　　if('2'==ch){//輸入?yún)R款金額
　　32:　　　　　System.out.print("Remittance\tMoney:");
　　33:　　　　　System.out.flush();
　　34:　　　　　int m=getInt();
　　35:　　　　　Remittance re=
　　　　　　　　　　new Remittance(address1,address2,m);
　　36:　　　　　board.putMails(re);
　　37:　　　　}
　　38:　　　}
　　39:　　　else finished=true;
　　40:　　}
　　41:　　System.out.println(" ");
　　42:　　board.showAll();//輸出所有郵件信息
　　43:　}
　　　//鍵盤輸入獲取整數(shù)
　　44:　public static int getInt() throws IOException{
　　45:　　BufferedReader in= new BufferedReader
　　　　　　　(new InputStreamReader(System.in));
　　46:　　String st=in.readLine();
　　47:　　Integer i=new Integer(st);
　　48:　　return i.intValue();
　　49:　}
　　50:}
　　由于涉及交互，類Show中用到了許多輸入輸出語(yǔ)句，我們?cè)诔绦虻?行用
　　　　import java.io.*;
引入Java的IO包。這個(gè)包封裝了大量有關(guān)輸入輸出的方法，具體內(nèi)容將在第七章中詳細(xì)介紹。這里我們只需要弄清楚所用到的輸入/出語(yǔ)句的功能。
　　在輸入/出中，總有可能產(chǎn)生輸入輸出錯(cuò)誤，Java反這引起錯(cuò)誤都?xì)w入IOException(IO異常)因?yàn)槲覀儾淮蛩阍诔绦蛑屑尤雽?duì)這些異常的處理，所以需要在每個(gè)方法的參數(shù)表后用關(guān)鍵字throws“扔出”這些異常，如第6行
　　　　public static void main(String args[])throws IOException
這樣異常發(fā)生時(shí)，將自動(dòng)中止程序運(yùn)行并進(jìn)行標(biāo)準(zhǔn)處理。請(qǐng)參看第五章的內(nèi)容。
　　程序的輸入來源是一個(gè)BufferedReader類的對(duì)象in，它的聲明在第８行：
　　BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
因而具有BufferedReader中定義的所有輸入功能。
　　in.readLine()
是讀入一行輸入，并返回一字符串。而
　　charAt(i)
是String類的一個(gè)方法，取得指定字符串的第i個(gè)元素作為字符型返回。這兩上方法邊用，則可取得想要的輸入。而在輸入前用
　　System.out.flush();
將緩沖清空，以保證輸入的正確性。
　　System.out.print
　　System.out.println
都是輸出語(yǔ)句，不同的只是后者在輸出結(jié)束后自動(dòng)換行。類System和getInt()中用到的類都是Interger(注意不是int!)都在Java的lang名中定義，我們將在第六章詳細(xì)介紹。
　　在了解以上的基本輸入輸出后，這個(gè)程序就變得較等了。為了方便起見，我們不失一般性的將Show類的所有成員都定義為static的，這樣，類Show就不同志需要特別定義的構(gòu)造方法了。在第５行聲明的變量board是ShowMails類的對(duì)象，用來建立郵件庫(kù)：
　　public static ShowMails board=new ShowMails();
第44行開始的getInt方法用來從鍵盤輸入獲得一個(gè)整數(shù)。第6行開始的main方法則是程序的主體。它實(shí)現(xiàn)的功能是不斷詢問是否要加入新郵件，肯定回答時(shí)要求選擇郵件類型并輸入相應(yīng)信息。據(jù)此創(chuàng)建郵件子類對(duì)象并加入board中，直至得到不定回答退出。最后顯示此時(shí)已有的郵件信息。郵件的加入和顯示都通過簡(jiǎn)單的
　　　　board.pubMails()
　　　　board.showAll()
調(diào)用ShowMails的方法來實(shí)現(xiàn)的，簡(jiǎn)潔明了而層次清晰。這就是面向?qū)ο筮M(jìn)行數(shù)據(jù)封裝和重用的優(yōu)點(diǎn)所在。要執(zhí)行類Show，我們需要將例4.5～例4.8的文件依次輸入、編譯。最后用解釋器java執(zhí)行類Show。下面給出的是Show的運(yùn)行結(jié)果，其中加下劃線“_”的是鍵盤輸入。
　　例4.9　類Show運(yùn)行結(jié)果。
　　D:\java01>java ch4package.Show

　　Do you want to add mails(Y/N)?n　//詢問有是否添加郵件

　　No mails.　　　　　　　　　　　　　//顯示沒有郵件

　　D:\java01>java ch4package.Show

　　Do you want to add mails(Y/N)?y//詢問有是否添加郵件
　　Address information:　　　　　　//要求輸入地址信息
　　From:NanJing
　　To:BeiJing
　　Choose the mail type:1-Parcel 2-Remittance 1//要求選擇郵件類型
　　Parce Weight:100//要求輸入包裹重量

　　Do you want to add mails(Y/N)?y
　　Address information:
　　From:ShangHai
　　To:TianJing
　　Choose the mail type:1-Parcel 2-Remittance 2
　　Remittance Money:400//要求輸入?yún)R款金額

　　Do you want to add mails(Y/N)?n

　　Mail NO1:Parcel://輸出所有郵件信息
　　　　 From:NanJing To:BeiJing
　　Weigth:2g
　　Mail NO2:Remittance:
　　From:ShangHai To:TianJing
　　Money:400 Yuan

　　D:\java01

4.4 Java的接口

　　4.4.1 引進(jìn)接口的目的

　　Java的接口也是面向?qū)ο蟮囊粋€(gè)重要機(jī)制。它的引進(jìn)是為了實(shí)現(xiàn)多繼承，同時(shí)免除C++中的多繼承那樣的復(fù)雜性。前面講過，抽象類中包含一個(gè)或多個(gè)抽象方法，該抽象類的子類必須實(shí)現(xiàn)這些抽象方法。接口類似于抽象類，只是接口中的所有方法都是抽象的。這些方法由實(shí)現(xiàn)這一接口的不同類具體完成。在使用中，接口類的變量可用來代表任何實(shí)現(xiàn)了該接口的類的對(duì)象。這就相當(dāng)于把類根據(jù)其實(shí)現(xiàn)的功能來分別代表，而不必顧慮它所在的類繼承層次。這樣可以最大限度地利用動(dòng)態(tài)綁定，隱藏實(shí)現(xiàn)細(xì)節(jié)。接口還可以用來實(shí)現(xiàn)不同類之間的常量共享。
　　為了說明接口的作用，我們不妨假設(shè)有一系列的圖形類，其中一部分在圖形中加入了文字，成為可編輯的，它們應(yīng)當(dāng)支持最普遍的編輯功能：
　　cut，copy，paste和changeFont
將這些方法的原型統(tǒng)一組合在一個(gè)EditShape接口中，就可以保證方法名的規(guī)范統(tǒng)一和使用的方便。我們畫出這個(gè)假想的類和接口的繼承關(guān)系圖，可以更直觀地了解。

　　　　　　　　　　　　　　　　　　　　Object
　　　　　　　　　　　　　　　　　　　　　↓
　　　　　　　　　　　　　　　　　　　　Shape
　　　　　　　　┌────────────┼─────────────┐
　　　　　　　　↓　　　　　　　　　　　　↓　　　　　　　　　　　　　↓
　　　　　　　Circle 　　　　　　　　　Rectangle 　　　　　　　　　Triangle
　　　　　　　↙　↘　　　　　　　　　　↙　↘　　　　　　　　　　　　↙　↘
　　PaintCircle TextCircle PaintRectangle TextRectangle PaintTriangle TextTrangle
　　　　　　　　　　　↑　　　　　　　　　　　↑　　　　　　　　　　　　　　　↑
　　　　　　　　　　　└───────────┼───────────────┘
　　　　　　　　　　　　　　　　　　　　　　EditShape
　　　　　　　　圖4.1　Shape 和 EditShape

　　以圖中類Circle的兩個(gè)子類為例。類PaintCircle未實(shí)現(xiàn)EditShape接口，不支持上述編輯功能。而類TextCircle既是Cricle的子類，又實(shí)現(xiàn)了EditShape接口，因而不但具有Circle類的圖形牲，又支持EditShape定義的編輯功能。而在TextCircle，TextRectangle和TextTriangle中，支持這些編輯功能的方法是同名同參的(與EditShape的定義一致)，這又提供了使用上的方便。

　　4.4.2 接口的聲明和使用

　　Java的接口類似于抽象類，因而它的聲明也和抽象類類似，只定義了類中方法的原型，而沒有直接定義方法的內(nèi)容。它的聲明格式為：
　　[接口修飾符] interface　接口名 [extends 父類名]
　　　　
　　接口修飾符可以是public或abstract，其中abstract缺省時(shí)也有效。public的含義與類修飾符是一致的。要注意的是一個(gè)編譯單元，即一個(gè).java文件中最多只能有一個(gè)public的類或接口，當(dāng)存在public的類或接口時(shí)，編譯單必須與這個(gè)類或接口同名。
　　被聲明的變量總是被視為static和final的，因而必須在聲明時(shí)給定初值。被聲明的方法總是abstract的，abstarct缺省也有效。與抽象類一樣，接口不需要構(gòu)造方法。接口的繼承與為是一樣的，當(dāng)然一個(gè)接口的父類也必須是接口。下面是一個(gè)接口的例子：
　　interface EditShape{
　　　void cut();
　　　void copy();
　　　void paste();
　　　void changeFont();
　　}
在使用時(shí)，為了將某個(gè)接口實(shí)現(xiàn)，必須使用關(guān)鍵字implements。格式是這樣的：
　　[類修飾符] class 類名 [extends 父類名] [implements 接口名表]
其中，接口名表可包括多個(gè)接口名稱，各接口間用逗號(hào)分隔。“實(shí)現(xiàn)(implements)“了一個(gè)接口的非抽象類必須寫出實(shí)現(xiàn)接口中定義的方法的具體代碼，同時(shí)可以讀取使用接口中定義的任何變量。
　　例4.10　接口的實(shí)現(xiàn)
　　class TextCircle extends Circle implements EditShape
　　{...
　　　void cut()　　　　　
　　　void copy()　　　　
　　　void paste()　　　　
　　　void changeFont　　　
　　　...
　　}

　　4.4.3 多繼承

　　在Java中，類之間只允許單繼承，但我們可以把一個(gè)類實(shí)現(xiàn)的接口類也看作這個(gè)類的父類。類從它實(shí)現(xiàn)的接口那里“繼承”了變量和方法，盡管這些變量是靜態(tài)常量，這些方法是未實(shí)現(xiàn)的原型。如果一個(gè)類實(shí)現(xiàn)的接口類不止一個(gè)，那么所有這些接口類都被視為它的“父類”。這樣，實(shí)現(xiàn)了一個(gè)或多個(gè)接口的類就相當(dāng)于是從兩個(gè)(加上該類原有意義上的父類)或兩個(gè)以上的類派生出來的。Java的多繼承正是建立在這種意義之上。通過接口的繼承，相當(dāng)于只選擇了一部分需要的特征匯集在接口中由不同的類共享并繼承下去，而不必通過父子類間的繼承關(guān)系將所有的方法和變量全部傳遞給子類。所以我們又可以把Java的這種多繼承稱為“有選擇的多繼承”。這種多繼承與一般的多繼承相比，更為精簡(jiǎn)，復(fù)雜度也隨之大大降低。
　　在多繼承時(shí)，一個(gè)子類可能會(huì)從它的不同父類那里繼承到同名的不同變量或方法，這往往會(huì)引起兩義性問題，即不知道子類中這樣的變量或方法究竟是繼承了哪一個(gè)父類的版本，在Java中，為了防止出現(xiàn)這樣的兩義性問題，規(guī)定不允許一個(gè)子類繼承的父類和實(shí)現(xiàn)的接口類中定義同名的不同變量，否則編譯該子類時(shí)將出錯(cuò)，無(wú)法通過。而對(duì)于方法，由于接口類中定義的總是abstract的方法原型，而沒有實(shí)際代碼，所以不會(huì)出現(xiàn)類似的兩義性問題。相反，常會(huì)存在這樣的情況：當(dāng)接口類中要求實(shí)現(xiàn)的方法子類沒有實(shí)現(xiàn)，而子類的父類中定義有同名方法時(shí)，編譯器將子類從父繼承的該方法視為對(duì)接口的的實(shí)現(xiàn)。這樣的繼承和實(shí)現(xiàn)都被認(rèn)為是合法的。

4.5 實(shí)現(xiàn)了接口的郵件類例子

　　這一節(jié)我們將4.3節(jié)郵件類的例子加以改進(jìn)和擴(kuò)展，加入有關(guān)接口的內(nèi)容，以說明接口和多繼承的概念。
　　首先定義一個(gè)名為MailPost的接口，其中沒有定義變量，而是給出兩個(gè)有關(guān)郵寄方法原型。
　　calPrice()計(jì)算郵費(fèi)并以浮點(diǎn)數(shù)形式返回；
　　post()完成郵寄。
　　例4.11 接口MailPost。
　　//MailPost.java
　　package ch4package;
　　public interface MailPost{
　　　public float claPrice();
　　　public void post();
　　}
　　接下來在包裹Parcel和匯款Remittance的基礎(chǔ)上分別派生出可郵寄的包裹和匯款：PostParcel和PostRemit兩個(gè)子類。
　　例4.12　子類PostParcel和PostRemit。
　　---------------------------------
　　//PostParcel.java
package ch4package;
import java.lang.*;

public class PostParcel extends Parcel implements MailPost{
protected int postage;
protected boolean postable;
protected boolean posted;
PostParcel(Ttring address1,String address2,int w,intp){
//構(gòu)造方法
super(address1,address2,w);
postage=p;
postable=false;
posted=false;
}
public float calPrice(){//計(jì)算郵資
return((float)0.05*weight);
}
public void post(){//郵寄包裹
float price=calPrice();
postable=(price<=postage);
posted=true;
}
public void showMe(){//顯示郵件信息
float price=calPrice();
System.out.println("Postable Parcel:");
System.out.println("\tFrom:")+fromAddress+\tTo"
+toAddress);
System.out.println("\tWeigth:)+weigth+"g\tPostage:"
+postage+"Yuan");
if(posted){
if(postable)System.out.println("\tIt has been
posted !");
else{
System.out.println("\tIt needs more postage:");
System.out.println("\tThe current postage
is:"+postage+"Yuan");
System.out.println("\t\tThe price is:"+price+"Yuan");
}
}
}
}
//PostRemit.java
package ch4package;
import java.lang.*;

public class PostRemit exteds Remittance implements MailPost{
protected int postage;
portected boolean postable;
protected boolean posted;
PostRemit(String address1,String address2,int m,int p){
//構(gòu)造方法
super(address1,address2,m);
postage=p;
postable=false;
posted=false;
}
public float calPrice(){//計(jì)算郵資
float price=cealPrice();
postable=(price<=postage);
posted=true;
}
public void showMe(){//顯示郵件信息
float price=calPrice();
System.out.println("Postable Remit:");
System.out.println("\tFrom:"+fromAddress+"\tTo:"
+toAddress);
System.out.println("\tMoney:"+money+"Yuan"+"\tPostage:"
+postage+"Yuan");
if(posted){
if(postable)System.out.println("\tIt has been
posted!");
else{
System.out.println("\tIt needs more postage:");
System.out.println("\t\tThe current postage is:"
+postage+"Yuan");
System.out.println("\t\tThe price is:"
+price+"Yuan");
}
}
}
}

　　---------------------------------
　　這兩個(gè)類都實(shí)現(xiàn)了接口MailPost。由于兩個(gè)類非常相似，我們?nèi)匀恢攸c(diǎn)講解其中一個(gè)：類PostParce。
　　PostParcel仍是包c(diǎn)h4package中的一員，它是類Parcel的子類(extends Parcel)，又實(shí)現(xiàn)了接口MailPost(implements MailPost)：
　　　　public class PostParcel extends Parcel implements MailPost
　　在Parcel的基礎(chǔ)上，它新增加了三個(gè)變量：
　　　　postage，posted，postable
其中整型的postage用來記錄郵寄人提供的郵資，布爾型的posted和postable分別用來記錄是否被嘗試郵寄過以及郵寄是束成功。在PostParcel的構(gòu)造方法中，第9行語(yǔ)句
　　　　super(address1,address2,w);
調(diào)用了它的父類Parcel的構(gòu)造方法，設(shè)定它從Parcel中繼承的變量寄出地址、寄達(dá)地址和重量的初值。這就是我們?cè)谇懊嫣岬竭^的super變量在構(gòu)造方法中的用途：調(diào)用父類的相應(yīng)構(gòu)造方法。這樣做的一個(gè)好處是可以重用父類的代碼，然后PostParcel就只需設(shè)定郵資，并將posted和postable初值都置為false。
　　PostParcel和PostRemit都實(shí)現(xiàn)了接口MailPost，國(guó)而在它們的定義中，都必須給出方法calPrice()和post()的具體實(shí)現(xiàn)。在PostParcel中，為了簡(jiǎn)單起見，郵費(fèi)只是根據(jù)重量每克收到0.05元，而不考慮寄達(dá)的距離，如語(yǔ)句第15行：
　　　　return ((float)0.05*weight);
在post()方法中，將計(jì)算所得郵資與瑞有郵費(fèi)加以比較，若郵費(fèi)已夠?qū)ostable設(shè)為true，包裹可郵寄；否則postable為false，包裹不可郵寄。無(wú)論postable取值如何，都已試圖郵寄，所以將posted置為true。處理過程見第18行至20行。
　　最后一個(gè)方法是showMe()。在這里，PostParcel重寫(Overriding)了它的父類Parcel中的同名方法。當(dāng)包裹尚未被試圖郵寄過，則在基本信息后附加有關(guān)的郵寄信息，若未郵寄成功，給出所需最費(fèi)提示。
　　PostRemit類的基本構(gòu)成與PostParcel是一致的，讀者可以自己試著讀懂它的源文件。
　　在包c(diǎn)h4package中，類Mails，Parcel，Remittance以及ShowMails都無(wú)需改動(dòng)，只有最后的可執(zhí)行類Show需要相應(yīng)的修改。它的源程序如下。
　　例4.13 可執(zhí)行類Show程序文件。
　　-------------------------
//Show.java

　　1: package ch4package;
import java.lang.*;
　　2: import java.io.*;
　　3:
　　4: public class Show{
　　5:　public static ShowMails board=new ShowMails();
　　6:　　public static void main(String args[])throws IOException{
　　7: 　　　boolean finished=false;
　　8:　　　BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
　　9:　　　while(!finished){//添加郵件
　　10:　　　　System.out.print("\nDo you want to add mails(Y/N)?");
　　11:　　　　System.out.flush();
　　12:　　　　char ch=in.readLine().charAt(0);
　　13:　　　　if('Y'==Character.toUpperCase(ch)){
　　14:　　　　System.out.println("Address information:");
　　15:　　　　System.out.print("\tFrom:");//輸入地址信息
　　16:　　　　System.out.flush();
　　17:　　　　String address1=in.readLine();
　　18:　　　　System.out.print("\tTo:");
　　19:　　　　System.out.flush();
　　20:　　　　String address2=in.readLine();
　　　　　　//選擇郵件種類
　　21:　　　　System.out.print("Choose the mail type:1-Parcel
2-Remittance ");
　　22:　　　　System.out.flush();
　　23:　　　　ch=in.readLine().charAt(0);
　　24:　　　　if('1'==ch){//輸入包裹重量
　　25:　　　　　System.out.print("Parcel\tWeight:");
　　26:　　　　　System.out.flush();
　　27:　　　　　int w=getInt();
//是否寄出郵件
System.out.print("Do you want to post it(Y/N?");
System.out.flush();
ch=in.readLine().charAt(0);
if('Y'==Character.toUpperCase(ch)){//輸入郵資
System.out.println("You want to post in,then
input your postage:");
System.out.flush();
int p=getInt();
//可郵寄包裹
PostParcel pa=new
PostParcel(address1,address2,w,p);
board.putMails(pa);
}
//不可郵寄包裹
else{Parcel pa=new Parcel(address1,address2,w);
board.putMails(pa);}
}
if('2'==ch){
System.out.print("Remittance\tMoney:");
System.out.flush();
int m=getInt();
System.out.print("Do you want to post it(Y/N)?");
System.out.flush():
ch=in.readLine().charAt(0);
if('Y'==Character.toUpperCase(ch)){
System.out.println("You want to post it,then input
postage:");
System.out.flush();
int p=getInt();
//可郵寄匯款
PostRemit re=new PostRemit(address1,address2,m,p);
board.putMails(re);
}
//不可郵寄匯款
else{Remittance re=new Remittance(address1,address2,m);
board.putMails(re);}
}
}
else finished=true;
}
System.out.println("");
board.showAll();//顯示郵件信息
post();
}
public static int getInt() throws IEOxception{
BufferedReader in=new BufferedReader
(new InputStreamReader(System.in));
String st=in.readLine();
Integer i=new Integer(st);
return i.intValue();
}
private static void post()throws ClassCastException,IOException{
int n\board.mailnum();
if(n!=0){
System.out.println("You have "+n+" mails");
boolean end=false;
//檢查郵寄情況
while(!end){
System.out.print("\nInput the mail NO you want to check the
result(輸0退出):");
System.out.flush();
int i=getInt();
if(i!=0){
try{
Mails obj=board.getMails(i-1);
post((MailPost)obj);
obj.showMe();
}catch(ClassCastException ex){
System.out.println("Mail is not postable!");}
}
else end=true;
}
}
}
private static void post(MailPost obj){
obj.calPrice();
obj.post();
}
}
　　-------------------------
　　與第三節(jié)例4.8中類的Show相比，改動(dòng)后的Show的main方法增加了詢問是否要將郵件設(shè)為可郵寄類型的功能以及相應(yīng)的處理段，并調(diào)用Post()方法郵寄郵件并給出郵寄情況說明。類Show定義了兩個(gè)post方法來實(shí)惠郵寄。這兩個(gè)方法雖同名，但參數(shù)不同，完成的功能也大相徑庭。
　　第72行至92行的第一個(gè)post方法沒有參數(shù)。它首先給出現(xiàn)有郵件數(shù)量，然后根據(jù)輸入的郵件號(hào)通過ShowMails的getMails方法取得郵件，再調(diào)用第二個(gè)post方法實(shí)際將郵件寄出；當(dāng)輸入的郵件號(hào)為零時(shí)結(jié)束。在調(diào)用第二個(gè)post方法時(shí)，需要將郵件顯式轉(zhuǎn)換為接口類MailPost:
　　83:Mails obj=bord.getMails(i-1);
　　84:post((MailPost)obj);
因?yàn)镻ostParcel和PostRemit都實(shí)現(xiàn)了接口MailPost，都支持這樣的轉(zhuǎn)換，就可以通過種形式從功能上將它們統(tǒng)一起來。如果該郵件所屬的類沒有實(shí)現(xiàn)接口MailPost ,如類Parcel或類Remittance，這樣的類型轉(zhuǎn)換就不能實(shí)現(xiàn)，將引發(fā)類型轉(zhuǎn)換異常(ClassCastException)，不再轉(zhuǎn)去調(diào)用post方法，而由catch結(jié)構(gòu)給出“郵件無(wú)法被郵寄”的報(bào)錯(cuò)信息：
　　86:}catch(ClassCastException ex){
　　87:　System.out.println("Mail is not postable!");}
其中的try-catch結(jié)構(gòu)是Java中異常處理的典型結(jié)構(gòu)。
　　第二個(gè)post方法帶一個(gè)MailPost接口類的參數(shù)，它實(shí)際調(diào)用接口定義的方法calPrice和post將郵件寄出。
　　下面我們來看一個(gè)Show的執(zhí)行實(shí)例，其中帶下劃線“_”的部分為執(zhí)行的鍵盤輸入。
　　例4.14　Show的執(zhí)行結(jié)果。
　　--------------------
　　--------------------
　　當(dāng)啟動(dòng)Show的運(yùn)行后，首先依照提示創(chuàng)建三個(gè)郵件對(duì)象，其中第一個(gè)是不可郵寄包裹后兩個(gè)分別是可郵寄的包裹和匯款。停止添加郵件后順序顯示現(xiàn)有郵件信息，包括郵件號(hào)、郵件類別、地址信息、重量／金額以及已付郵資，并提示現(xiàn)有郵件總數(shù)。此時(shí)我們可依次檢查郵件是否可寄出：
　　輸入郵件號(hào)“１”，由于此包裹不是可郵寄包裹類，給出報(bào)告：郵件不可寄出；
　　輸入郵件號(hào)“２”，該郵件是可郵寄包裹，且通過郵資計(jì)算已付足，給出報(bào)告：郵件可寄出；
　　輸入郵件號(hào)“３”，該郵件是可郵寄匯款，但欠缺郵資，給出報(bào)告：郵件需補(bǔ)足郵資，然后列出應(yīng)交郵費(fèi)與實(shí)交郵費(fèi)比較。
　　最后輸入數(shù)字“０”，結(jié)束本次執(zhí)行。
　　這樣我們就完成了對(duì)第三節(jié)中郵件類的擴(kuò)充和改進(jìn)，最終得到的包c(diǎn)h4package中所有類和接口的層次繼承關(guān)系，如圖4.2所示。讀者可以對(duì)照這個(gè)圖理清它們的繼承和實(shí)現(xiàn)關(guān)系。
　　　　　　　　　　　　　Object
　　　　　　　　┌─────┼─────┐
　　　　　　　　↓　　　　　↓　　　　　↓
　　　　　　　Mails　　ShowMails　　show
　　　　┌───┴───┐
　　　　↓　　　　　　　↓
　　　Parcel　　　　Remittance
　　　　↓　　　　　　　↓
　　PostParcel　　PostRemit
　　　　　　↖　　↗
　　　　　　MailPost
　　　　圖4.2 包c(diǎn)h4package的類和接口層次