面向對象思想之 -- 繼承以及多態

　　在"OOP簡介:理解類和對象"這篇文章中,我們討論了繼續和多態性的好處.我們還粗略的學習了如何擴展基類定義子類,繼續基類中合適的行為和屬性而重載那些并不適合的行為和屬性.這種方式能夠削減代碼宏余以及錯誤的堆積.
　　
　　現在我們將更深入的考察多重繼續性以及java是如何處理它的.我們還將通過學習動態綁定來學習多態性.
　　
　　深入繼續性
　　一些面向對象的語言提供叫做"多重繼續"的特點,當一個對象需要從多于一個的基類繼續行為和屬性的時候這是有價值的.多重繼續在有些情況下是復雜的.例如,假設我們需要定義一個基類,Animal,然后是Animal的兩個子類,LandAnimal 和 WaterAnimal.現在我們想要定義一個類來代表青蛙.青蛙是兩棲動物,所以我們自然會想到定義Frog類從LandAnimal和WaterAnimal類繼續.這使得Frog類能夠同時從LandAnimal 和WaterAnimal類繼續所需的行為和屬性.
　　
　　初看起來這是相當簡單的;但是,讓我們為Animal添加一個叫做LivingEnvironment的屬性,并用方法getLivingEnvironment來返回它.我們假設LandAnimal 和 WaterAnimal類都重載了這個方法來實現非凡的功能.LandAnimal將返回Land作為它的LivingEnvironment屬性的值,而WaterAnimal將返回Water作為它的LivingEnvironment屬性的值.現在,當我們將Frog類作為LandAnimal 和 WaterAnimal 子類實現的時候,想要得到Frog的LivingEnvironment屬性值,這時將碰到一個麻煩:Frog類的getLivingEnvironment方法是返回Land值呢還是Water值?答案取決于編譯器如何處理多重繼續.
　　
　　我在前面的文章里就已經說過,Java不支持多重繼續.但它確實答應一個對象通過使用叫做"接口"的功能擁有多個特性.下面的例子顯示了定義LandAnimal的接口的可能的定義代碼:
　　public interface LandAnimal
　　{
　　　　public int getNumberOfLegs();
　　　　public boolean hasATail();
　　}
　　
　　一個使用接口的類在類定義語句的開始添加implements+接口名.例如,在Java中,我們會以下面的方式定義Frog類:
　　
　　public class Frog extends Animal implements LandAnimal, WaterAnimal
　　
　　接口并沒有什么實際的功能;相反,它的作用是聯系使用者和實現了這個接口的對象.接口保證了對象實現接口定義的方法.而且,一個實現接口的對象能夠在運行時被強制轉換成接口類型.例如,使用上面的Frog定義,并且假設LandAnimal類定義了一個叫做getNumberOfLegs的方法而WaterAnimal定義了一個叫做hasGills的方法,那么一個Frog類的實例可以在運行時被強制轉換成LandAnimal或WaterAnimal對象:
　　
　　Frog aFrog = new Frog();
　　int legCount = ((LandAnimal)aFrog).getNumberOfLegs();
　　Boolean gillFlag = ((WaterAnimal)aFrog).hasGills();
　　
　　注重Forg為什么能夠被強制轉換成一個LandAnimal對象即使實際的LandAnimal對象并沒有被創建.這使得我們能夠在運行時以其帶有的任何"身份"調用一個對象,這就是所謂的"動態綁定"或"運行時綁定".
　　
　　深入多態性
　　Java使用動態綁定來使多態成為可能,它指的是Java用來在運行時選擇調用的方法或對象的機制.重載構成了了Java中的一種非凡的多態機制,它表現在當一個類的兩個或者兩個以上的方法擁有相同的名字但是不同的參數列表,或者說"方法簽名".一個方法的簽名指的是方法的名字以及參數的類型和數目.類的每一個方法都有與之相關的唯一的簽名.類可以有多個名字相同的方法只要它們的參數列表是唯一的.例如,我們能夠為Animal類定義兩個名字為getHello的方法,用其中一個方法來獲得動物通常的叫聲,而用另一個獲得當動物被驚嚇或是撫摩的時候的叫聲.我們將給每一個方法唯一的簽名:
　　
　　public String getHello();
　　public String getHello(int mood);
　　
　　現在,讓我們修改例子程序來將我們討論的一些概念付諸實踐:
　　　
　　public class HelloWorld
　　{
　　public static void main(String[] args)
　　{
　　Dog animal1 = new Dog();
　　Cat animal2 = new Cat();
　　DUCk animal3 = new Duck();
　　
　　System.out.　　+", when scared says: " +animal1.getHello(Animal.SCARED)
　　+", is carnivorous: " +animal1.isCarnivorous()
　　+", is a mammal: " +animal1.isAMammal());
　　System.out.println("A cat says " +animal2.getHello()
　　+", when comforted says: " +animal2.getHello(Animal.COMFORTED)
　　+", is carnivorous: " +animal2.isCarnivorous()
　　+", is a mammal: " +animal2.isAMammal());
　　System.out.println("A duck says " +animal3.getHello()
　　+", when scared says: " +animal3.getHello(Animal.SCARED)
　　+", is carnivorous: " +animal3.isCarnivorous()
　　+", is a mammal: " +animal3.isAMammal());
　　}
　　}
　　
　　abstract class Animal
　　{
　　public static final int SCARED = 1;
　　public static final int COMFORTED = 2;
　　
　　public boolean isAMammal()
　　{
　　return(true);
　　}
　　
　　public boolean isCarnivorous()
　　{
　　return(true);
　　}
　　
　　abstract public String getHello();
　　abstract public String getHello(int mood);
　　}
　　
　　interface LandAnimal
　　{
　　public int getNumberOfLegs();
　　public boolean hasATail();
　　}
　　
　　interface WaterAnimal
　　{
　　public boolean hasGills();
　　public boolean laysEggs();
　　}
　　
　　class Dog extends Animal implements LandAnimal
　　{
　　// 重載父類的方法
　　public String getHello()
　　{
　　return("Bark");
　　}
　　
　　public String getHello(int mood)
　　{
　　switch (mood) {
　　case SCARED:
　　return("Growl");
　　case COMFORTED:
　　return("");
　　}
　　
　　return("Bark");
　　}
　　
　　// LandAnimal 接口的實現
　　public int getNumberOfLegs()
　　{
　　return(4);
　　}
　　
　　public boolean hasATail()
　　{
　　return(true);
　　}
　　}
　　
　　class Cat extends Animal implements LandAnimal
　　{
　　// 重載父類的方法
　　public String getHello()
　　{
　　return("Meow");
　　}
　　
　　public String getHello(int mood)
　　{
　　switch (mood) {
　　case SCARED:
　　return("Hiss");
　　case COMFORTED:
　　return("Purr");
　　}
　　
　　return("Meow");
　　}
　　
　　// LandAnimal 接口實現
　　public int getNumberOfLegs()
　　{
　　return(4);
　　}
　　
　　public boolean hasATail()
　　{
　　return(true);
　　}
　　}
　　
　　class Duck extends Animal implements LandAnimal, WaterAnimal
　　{
　　// 重載父類的方法
　　public String getHello()
　　{
　　return("Quack");
　　}
　　
　　public String getHello(int mood)
　　{
　　switch (mood) {
　　case SCARED:
　　return("Quack, Quack, Quack");
　　case COMFORTED:
　　return("");
　　}
　　
　　return("Quack");
　　}
　　
　　public boolean isAMammal()
　　{
　　return(false);
　　}
　　
　　public boolean isCarnivorous()
　　{
　　return(false);
　　}
　　
　　// WaterAnimal 接口實現
　　public boolean hasGills()
　　{
　　return(false);
　　}
　　
　　public boolean laysEggs()
　　{
　　return(true);
　　}
　　
　　// LandAnimal 接口實現
　　public int getNumberOfLegs()
　　{
　　return(2);
　　}
　　
　　public boolean hasATail()
　　{
　　return(false);
　　}
　　}
　　
　　程序執行后輸出的結果如下:
　　
　　A dog says Bark, when scared says: Growl, is carnivorous: true, is a mammal: true
　　A cat says Meow, when comforted says: Purr, is carnivorous: true, is a mammal: true
　　A duck says Quack, when scared says: Quack, Quack, Quack, is carnivorous: false, is a mammal: false
　　
　　總結
　　綜合繼續,多態和接口的概念提供了一組強大的編程工具,答應我們重用代碼,隔離錯誤的發生,并獲得動態/運行時綁定帶來的好處.在下一篇文章里,我們將討論如何使用Java的變量作用域/可見域規則來控制方法和屬性的暴露問題.