semovy

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

 

4.1 Java的類

　　4.1.1 類的聲明

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

　　4.1.2 類的組成

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

　　4.1.3 構造方法和finalizer

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

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

　　方法的重寫Overriding和重載Overloading是Java多態性的不同表現。前者是父類與子類之間多態性的一種表現，后者是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫(Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被“屏蔽”了。如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型，則稱為方法的重載(Overloading)。這在例4.1中已經可以看到。下面再給出兩個簡單的例子，分別顯示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();//調用子類的speak方法
　　　}
　　}
　　//output of class Check!
　　I am Son!
　　從這個例子我們可以看到，類Son中的speak()方法重寫了其父類Father中一模一樣的方法，而它的對象x調用speak()方法的結果是與Son中定義致的。
　　例4.3　Overloading例示。
　　class Father{
　　　void speak(){　　//無參的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();//調用無參的speak方法
　　　　x.speak("music");//調用有參的speak方法
　　　}
　　}
　　//out put of class Check
　　I am Father
　　I like music.
　　這個例子中類的Father定義了兩個speak方法，在類Check中又兩次調用，一次無參，一次有參，打印出兩行不同的字符串。注意Java在打印字符串時，字符串間的連接用符號“+”來完成。

　　Overriding是父類與子類之間多態性的一種表現；Overloading是一個類中多態性的一種表現。

　　4.1.5 幾個特殊的變量：null，this和super

　　Java中有三個特殊的變量：null,this和super，這三個變量是所有的類都可以使用的，用來指示一些特定的對象。
　　null相當于“空”，可以用來代指任何對象，但沒有實例。如
　　　　Rectangle r=null;
創建了一個Rectangle的變量r，但并沒有一個Rectangle的實例對象由r來代表。r就如同一個可放置Rectangle的盒子，只是這個盒子現在是空的。
　　this用以指代一個對象自身。它的作用主要是將自己這個對象作為參數，傳送給別的對象中的方法。它的使用形式是這樣的：
　　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);
　　　...
　　}
例中調用Father類的draw方法時，使用語句
　　f.draw(p);
又Father類中定義draw方法時以this為參數調用了類Painter的drawing方法：
　　x.drawing(this);
因而實際上調用了Painter類對象p的drawing方法，而將Father類對象f作為參數傳遞給drawing方法.
　　super用來取用父類中的方法和變量數據。它的用法如在下面的例子中所示。
　　例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();//相當于調用Father類的speak()方法
　　　　super.speak("hunting");
　　　　　//相當于調用Father類的speak(String s)方法
　　　}
　　}
　　class Check{
　　　public static void main(String args[]){
　　　　Son s=new Son();
　　　　s.speak();
　　　}
　　}
　　//Check.java的執行結果：
　　My father says:
　　I am Fater.
　　I like hunting.
　　在這個例子中，類Son的speak()方法語句
　　super.speak();
　　super.speak("hunting");
實際調用了Son的父類Father中的speak()和speak(String s)方法，以實現執行結果后兩行的輸出。使用父類的變量形式也很類似。
　　super.變量名
　　super和this的另一個重要用途是用在構造方法中。當一個類中不止一個構造方法時，可以用this在一個構造方法中調用中一個構造方法。若想調用父類的構造函數，則直接使用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成員變量代表長方形的顏色。在它的構造方法中，用語句
　　　　super(w,h);
調用了類Rectangle的構造方法
　　　　Rectangle(int w,int h);
設定長方形的長和寬，然后就只需設定長方形的顏色：
　　　　color=c;
這樣大大提高了代碼的重用性。

4.2 Java的包

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

　　4.2.1 包的聲明

　　為了聲明一個包，首先必須建立一個相應的目錄結構，子目錄名與包名一致。然后在需要放入該包的類文件開頭聲明包，形式為：
　　package 包名；
這樣這個類文件中定義的所有類都被裝入到你所希望的包中。例如
　　package Family;
　　class Father{
　　　...//類Father裝入包Family
　　}
　　class Son{
　　　...//類Son裝入包Family
　　}
　　class Daughter{
　　　...　　//類Daughter裝入包Family
　　}
不同的程序文件內的類也可以同屬于一個包，只要在這些程序文件前都加上同一個包的說明即可。譬如：
　　//文件 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是類的對象。
　　(2)在文件開頭使用import引用包中的類。如：
　　import Animals.Cat;
　　class Check{
　　　Cat cat=new Cat();
　　}
同樣Animals是包名，Cat是包中的類，cat是創建的Cat類對象。
　　(3)在文件前使用import引用整個包。如：
　　import Animals.*;
　　class Check{
　　　Cat cat=new Cat();
　　　Dog dog=new Dog();
　　　...
　　}
Animals整個包被引入，Cat和Dog為包中的類，cat和dog為對應類的對象。
　　在使用包時，可以用點“.” 表示出包所在的層次結構，如我們經常使用的
　　import java.io.*;
　　import java.applet.*;
實際是引入了/java/io/或/java/applet/這樣的目錄結構下的所有內容。需要指出的是，java.lang這個包無需顯式地引用，它總是被編譯器自動調入的。使用包時還要特別注意系統classpath路徑的設置情況，它需要將包名對應目錄的父目錄包含在classpath路徑中，否則編譯時會出錯，提示用戶編譯器找不到指定的類。

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

　　下面我們給出一個較大的例子，讓讀者在實例中進一步熟悉Java的類和包。
　　這里所有的類都放在包ch4package中，先定義出一個虛基類Mails，然后派生出它的兩個子類Parcel(包裹)和Remittance(匯款)。Show類用于實際執行，允許用戶創建自己的郵件，然后顯示出所有的郵件信息。為了方便地存取郵件，還定義了類ShowMails。接下來我們逐一介紹這經些類。
　　例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是一個虛類，不能產生自己的實例對象，而只是描述了郵件最基本的特性。類文件的開頭首先用
　　　　package cha4package;
表明Mails類是放于ch4package這個包里的。然后程序第二行為Mails的類聲明。
　　　　public abstract class Mails
　　用修飾符abstract指出這是個虛類。第三至第四行Mails類中定義了兩個變量：
　　　　protected String fromAddress;
　　　　protected String toAddress;
fromAddress和toAddress ,分別代表郵件的寄出地址和送往地址，都是protected類型的，這樣cha4package包外的類不能直接引用，保證了信息的隱藏。第五行Mails類定義了方法
showMe()，用于顯示一個郵件自身的有在信息：
　　　　public abstract voi showMe();
聲明時以abstract修飾，意味著這是一個抽象方法，只給出原型，具體實現要由Mails類的非虛子類通過Overriding完成。
　　接下來是Mails的兩個非虛子類。
　　例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){//構造方法
　　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){//構造方法
　　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:}

這里是郵件的兩個子類：包裹Parcel和匯款Remittance。以類Parcel為例詳細說明。首先在程序開頭寫出：
　　package ch4package;
　　一方面將類Parcel裝入包ch4package，另一方面方便類Parcel使用包ch4package中的其它類，如已定義的Mails類。接下來類Parcel聲明時用
　　extends Mails
表明自己是Mails的一個子類。在第三行Parcel聲明了一個weight變量，用來代表包裹的重量。加上從父類Mails繼承下來的變量fromAddress和toAddress，類Parcel一共有三個成員變量：
　　寄出地址　fromAddress，寄達地址toAddress和重量weight
　　相對應的，它的構造方法Parcel也必須有三個參數，分別傳遞給三個成員變量。構造方法的定義如第四行至第八行所示。由于Parcel類不是虛類，所以必須在其中重寫完成它的父類Mails中聲明的抽象方法showMe。Parcel的showMe()方法僅僅是將自己的郵件類型和三個變量的信息在屏幕上顯示出來。
　　類Remittance與Parcel非常相似，只是它定義的變量為money，用來代表匯款的金額。它也必須具體完成方法showMe。
　　下面我們看到的是用于存取郵件的類ShowMails。
　　例4.7 類ShowMails程序文件。
　　1: package ch4package;
　　2: import java.lang.*;
　　3: public class ShowMails{
　　4: 　protected Mails showList[];//郵件數組序列
　　5: 　protected static final int maxMails=50;//最大郵件個數
　　6: 　protected int numMails;//當前郵件個數
　　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++;//修改計數
　　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)+":");//郵件序號
　　25:　　　　showList[i].showMe();//郵件具體信息
　　26:　　　}
　　27:　　else
　　28:　　　System.out.println("No mails.");
　　29:　}
　　30:　public int mailnum(){
　　31:　　return numMails;
　　32:　}
　　33:}
　　程序第四行至第六行類ShowMails定義了三個成員變量：
　　　　showList[],maxMails和numMails
　　變量showList[]是類Mails的一個數組。但由于Mails本身是個虛類，因而showList[]的元素不可能是Mails的對象，它實際上是用來存放Mails的兩個子類Parcel和Remittance的對象的。一般說來，一個被聲明為類A的的變量，總可以被賦值為任何類A的子類的實例對象。這與父子類之間的類型轉換的原則是一致的：父類到子類的轉換可以隱式地自動進行，而子類到父類的轉換則需要顯式地加以說明。
　　變量maxMails用來指出showList[]中最多可容 納的郵件數，它對ShowMails的所有對象都應是固定且一致的。因此它被聲明為tatatic和final的，為所有對象共享且不可更改。變量numMails則用來作為showList[]中實際郵件個數的計數。
　　對應ShowMails的三個成員變量，我們在ShowMails()構造方法中只需做兩件事：實際創建類mails的數組showList[]，然后將郵件計數numMails置零。
　　第11行開始的方法putMails和第17行開始的方法getMails分別完成對showList[]中郵件的存取。第30行的mailnum方法則返回當時的郵件計數值。putMails方法接受一個郵件類參數，并把它加入到當前郵件序列的末尾。getMails方法接受一個整型參數作為郵件序號，根據該序號找出當前郵件序列中對應郵件返回。當給定的郵件號index不在有效范圍時，以據該序號找出當前郵件序列中對應郵件返回。當給定的郵件號index不在有效范圍時，以
　　　　return null;(19行)
返回一個定值。這一句看上去并沒有完成什么實質性的工作，但如果省略則編譯時會出錯。因為getMails方法的返回值已聲明為Mails類，這就要求在任何情況下都返回一個符合這一要求的值。而空變量null可與任何類型匹配，恰好能適合這樣的要求。
　　第21行的方法showAll顯示showList[]中所有郵件的信息。每一郵件首先顯示自己的郵件號。因為showList[]數組的下標從0開始，為了符合人們的日常習慣，將每一個下標加1后再作為郵件號輸出。各個郵件的顯示是調用郵件的showMe()方法來實現的。因為showMe()方法已經在虛類Mails中定義了，所以不管showList[]中的實際元素是Parcel還是Remittance，編譯器總能順利地連接調用相應的代碼。Java面向對象特性中的動態綁定(Dynamic Binding)，保證了無需在編譯前確定地知道showList[]每一個數組元素的類型，就能成功地實現這樣的鏈接。
　　最后給出的類是實際執行的Shos類。
　　例4.8 類Show程序文件
　　1: package ch4package;
　　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("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){//輸入匯款金額
　　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:　}
　　　//鍵盤輸入獲取整數
　　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中用到了許多輸入輸出語句，我們在程序第2行用
　　　　import java.io.*;
引入Java的IO包。這個包封裝了大量有關輸入輸出的方法，具體內容將在第七章中詳細介紹。這里我們只需要弄清楚所用到的輸入/出語句的功能。
　　在輸入/出中，總有可能產生輸入輸出錯誤，Java反這引起錯誤都歸入IOException(IO異常)因為我們不打算在程序中加入對這些異常的處理，所以需要在每個方法的參數表后用關鍵字throws“扔出”這些異常，如第6行
　　　　public static void main(String args[])throws IOException
這樣異常發生時，將自動中止程序運行并進行標準處理。請參看第五章的內容。
　　程序的輸入來源是一個BufferedReader類的對象in，它的聲明在第８行：
　　BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
因而具有BufferedReader中定義的所有輸入功能。
　　in.readLine()
是讀入一行輸入，并返回一字符串。而
　　charAt(i)
是String類的一個方法，取得指定字符串的第i個元素作為字符型返回。這兩上方法邊用，則可取得想要的輸入。而在輸入前用
　　System.out.flush();
將緩沖清空，以保證輸入的正確性。
　　System.out.print
　　System.out.println
都是輸出語句，不同的只是后者在輸出結束后自動換行。類System和getInt()中用到的類都是Interger(注意不是int!)都在Java的lang名中定義，我們將在第六章詳細介紹。
　　在了解以上的基本輸入輸出后，這個程序就變得較等了。為了方便起見，我們不失一般性的將Show類的所有成員都定義為static的，這樣，類Show就不同志需要特別定義的構造方法了。在第５行聲明的變量board是ShowMails類的對象，用來建立郵件庫：
　　public static ShowMails board=new ShowMails();
第44行開始的getInt方法用來從鍵盤輸入獲得一個整數。第6行開始的main方法則是程序的主體。它實現的功能是不斷詢問是否要加入新郵件，肯定回答時要求選擇郵件類型并輸入相應信息。據此創建郵件子類對象并加入board中，直至得到不定回答退出。最后顯示此時已有的郵件信息。郵件的加入和顯示都通過簡單的
　　　　board.pubMails()
　　　　board.showAll()
調用ShowMails的方法來實現的，簡潔明了而層次清晰。這就是面向對象進行數據封裝和重用的優點所在。要執行類Show，我們需要將例4.5～例4.8的文件依次輸入、編譯。最后用解釋器java執行類Show。下面給出的是Show的運行結果，其中加下劃線“_”的是鍵盤輸入。
　　例4.9　類Show運行結果。
　　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//要求輸入匯款金額

　　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 引進接口的目的

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

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

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

　　4.4.2 接口的聲明和使用

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

　　4.4.3 多繼承

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

4.5 實現了接口的郵件類例子

　　這一節我們將4.3節郵件類的例子加以改進和擴展，加入有關接口的內容，以說明接口和多繼承的概念。
　　首先定義一個名為MailPost的接口，其中沒有定義變量，而是給出兩個有關郵寄方法原型。
　　calPrice()計算郵費并以浮點數形式返回；
　　post()完成郵寄。
　　例4.11 接口MailPost。
　　//MailPost.java
　　package ch4package;
　　public interface MailPost{
　　　public float claPrice();
　　　public void post();
　　}
　　接下來在包裹Parcel和匯款Remittance的基礎上分別派生出可郵寄的包裹和匯款：PostParcel和PostRemit兩個子類。
　　例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){
//構造方法
super(address1,address2,w);
postage=p;
postable=false;
posted=false;
}
public float calPrice(){//計算郵資
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){
//構造方法
super(address1,address2,m);
postage=p;
postable=false;
posted=false;
}
public float calPrice(){//計算郵資
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");
}
}
}
}

　　---------------------------------
　　這兩個類都實現了接口MailPost。由于兩個類非常相似，我們仍然重點講解其中一個：類PostParce。
　　PostParcel仍是包ch4package中的一員，它是類Parcel的子類(extends Parcel)，又實現了接口MailPost(implements MailPost)：
　　　　public class PostParcel extends Parcel implements MailPost
　　在Parcel的基礎上，它新增加了三個變量：
　　　　postage，posted，postable
其中整型的postage用來記錄郵寄人提供的郵資，布爾型的posted和postable分別用來記錄是否被嘗試郵寄過以及郵寄是束成功。在PostParcel的構造方法中，第9行語句
　　　　super(address1,address2,w);
調用了它的父類Parcel的構造方法，設定它從Parcel中繼承的變量寄出地址、寄達地址和重量的初值。這就是我們在前面提到過的super變量在構造方法中的用途：調用父類的相應構造方法。這樣做的一個好處是可以重用父類的代碼，然后PostParcel就只需設定郵資，并將posted和postable初值都置為false。
　　PostParcel和PostRemit都實現了接口MailPost，國而在它們的定義中，都必須給出方法calPrice()和post()的具體實現。在PostParcel中，為了簡單起見，郵費只是根據重量每克收到0.05元，而不考慮寄達的距離，如語句第15行：
　　　　return ((float)0.05*weight);
在post()方法中，將計算所得郵資與瑞有郵費加以比較，若郵費已夠將postable設為true，包裹可郵寄；否則postable為false，包裹不可郵寄。無論postable取值如何，都已試圖郵寄，所以將posted置為true。處理過程見第18行至20行。
　　最后一個方法是showMe()。在這里，PostParcel重寫(Overriding)了它的父類Parcel中的同名方法。當包裹尚未被試圖郵寄過，則在基本信息后附加有關的郵寄信息，若未郵寄成功，給出所需最費提示。
　　PostRemit類的基本構成與PostParcel是一致的，讀者可以自己試著讀懂它的源文件。
　　在包ch4package中，類Mails，Parcel，Remittance以及ShowMails都無需改動，只有最后的可執行類Show需要相應的修改。它的源程序如下。
　　例4.13 可執行類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();
}
}
　　-------------------------
　　與第三節例4.8中類的Show相比，改動后的Show的main方法增加了詢問是否要將郵件設為可郵寄類型的功能以及相應的處理段，并調用Post()方法郵寄郵件并給出郵寄情況說明。類Show定義了兩個post方法來實惠郵寄。這兩個方法雖同名，但參數不同，完成的功能也大相徑庭。
　　第72行至92行的第一個post方法沒有參數。它首先給出現有郵件數量，然后根據輸入的郵件號通過ShowMails的getMails方法取得郵件，再調用第二個post方法實際將郵件寄出；當輸入的郵件號為零時結束。在調用第二個post方法時，需要將郵件顯式轉換為接口類MailPost:
　　83:Mails obj=bord.getMails(i-1);
　　84:post((MailPost)obj);
因為PostParcel和PostRemit都實現了接口MailPost，都支持這樣的轉換，就可以通過種形式從功能上將它們統一起來。如果該郵件所屬的類沒有實現接口MailPost ,如類Parcel或類Remittance，這樣的類型轉換就不能實現，將引發類型轉換異常(ClassCastException)，不再轉去調用post方法，而由catch結構給出“郵件無法被郵寄”的報錯信息：
　　86:}catch(ClassCastException ex){
　　87:　System.out.println("Mail is not postable!");}
其中的try-catch結構是Java中異常處理的典型結構。
　　第二個post方法帶一個MailPost接口類的參數，它實際調用接口定義的方法calPrice和post將郵件寄出。
　　下面我們來看一個Show的執行實例，其中帶下劃線“_”的部分為執行的鍵盤輸入。
　　例4.14　Show的執行結果。
　　--------------------
　　--------------------
　　當啟動Show的運行后，首先依照提示創建三個郵件對象，其中第一個是不可郵寄包裹后兩個分別是可郵寄的包裹和匯款。停止添加郵件后順序顯示現有郵件信息，包括郵件號、郵件類別、地址信息、重量／金額以及已付郵資，并提示現有郵件總數。此時我們可依次檢查郵件是否可寄出：
　　輸入郵件號“１”，由于此包裹不是可郵寄包裹類，給出報告：郵件不可寄出；
　　輸入郵件號“２”，該郵件是可郵寄包裹，且通過郵資計算已付足，給出報告：郵件可寄出；
　　輸入郵件號“３”，該郵件是可郵寄匯款，但欠缺郵資，給出報告：郵件需補足郵資，然后列出應交郵費與實交郵費比較。
　　最后輸入數字“０”，結束本次執行。
　　這樣我們就完成了對第三節中郵件類的擴充和改進，最終得到的包ch4package中所有類和接口的層次繼承關系，如圖4.2所示。讀者可以對照這個圖理清它們的繼承和實現關系。
　　　　　　　　　　　　　Object
　　　　　　　　┌─────┼─────┐
　　　　　　　　↓　　　　　↓　　　　　↓
　　　　　　　Mails　　ShowMails　　show
　　　　┌───┴───┐
　　　　↓　　　　　　　↓
　　　Parcel　　　　Remittance
　　　　↓　　　　　　　↓
　　PostParcel　　PostRemit
　　　　　　↖　　↗
　　　　　　MailPost
　　　　圖4.2 包ch4package的類和接口層次