重載,重寫以及繼承,多態

繼承是子類得到父類的成員， 重寫是繼承後從新實現父類的方法。 重載是在一個類裏一系列參數不一樣名字相同的方法。 多態則是用基類的引用指向子類的對象。
        網上看到一個有趣的說法是：繼承是子類使用父類的方法，而多態則是父類使用子類的方法。
下面的例子包含了這四種實現：
class Triangle extends Shape {
      public int getSides() {
             return 3;
      }
}
class Rectangle extends Shape {
      public int getSides(int i) {
            return i;
      }
}
public class Shape {
      public boolean isSharp(){
             return true;
       }
       public int getSides(){
             return 0 ;
       }
      public int getSides(Triangle tri){
            return 3 ;
      }
      public int getSides(Rectangle rec){
            return 4 ;
      }
     public static void main(String[] args) {
            Triangle tri = new Triangle();
            System.out.println("Triangle is a type of sharp? " + tri.isSharp());
            Shape shape = new Triangle();
            System.out.println("My shape has " + shape.getSides() + " sides.");
      }
}
紅色是重載， 綠色是重寫， 藍色是繼承， 粉紅是多態
注意Triangle類的方法是重寫，而Rectangle類的方法是重載。

比較紅色的和粉紅的部分就能夠發現多態對重載的優勢：若是用重載，則在父類裏要對應每個子類都重載一個取得邊數的方法；若是用多態，則父類只提供取得邊數的接口，至於取得哪一個形狀的邊數，怎樣取得，在子類裏各自實現(重寫)。

 

什麼是多態?爲何用多態?有什麼好處?

多態能夠分爲變量的多態,方法的多態,類的多態.我這裏強調的是類的多態,這是在之後的工做中常常會用到的。

 

首先,有這樣一個系統:有個學生從達內畢業了,作得還不錯.買了輛捷達汽車.這個系統應該如何設計呢?

按照OO的思想,咱們會抽象出來一個類,表示捷達汽車,其中有個run()方法

public class JD{

    public void run(){

         System.out.println("JD在以120邁的速度在run");

    }

}

咱們還會抽象出一個類,來表明人.其中有個drive()方法,須要一個汽車類型做爲參數,咱們先傳入一個JD類型的參數

 

// 這是咱們的核心業務類

public class Person{

    public void drive(JD jd){

         jd.run();

    }

 

    public static void main(String args[]){

        Person p =new Person();

       JD jd = new JD();

       p.drive(jd);

    }

}

 

若是你寫出這樣的代碼的話,恭喜你!你中大獎了!---------------------你會被項目經理砍死的!!!!!!!

項目經理爲何會砍你呢?

由於你寫的代碼偶合性太強了!

 

若是咱們的需求變了,這個學生後來更有錢了,買了一兩Benz.那麼咱們之前的系統怎麼辦啊.不要期望你做的系統永遠不會變化， 咱們的系統只能修改!這就是項目經理砍你的緣由

咱們的系統會增長一個Benz類,也有個run()方法

 

public class Benz{

    public void run(){

       System.out.println("Benz在以200邁的速度在run");

    }

}

 

咱們的核心業務類也要修改

 

public class Person{

 

    /*

public void drive(JD jd){

       jd.run();

}

*/

 

public void drive(Benz b){

       b.run();

}

 

public static void main(String args[]){

   Person p =new Person();

   Benz b = new Benz();

   p.drive(b);

}

}

 

之後的狀況,咱們能夠把車抽象出來:

public abstract class Driver{

   /*屬性*/

   public void run();//讓子類來運行

}

 

public Benz extends Driver{

   public void run(){

System.out.println("Benz在以200邁的速度在run");

   }

}

public JD extends Driver{

   public void run(){

        System.out.println("JD is running...");

   }

}

 

public class Person{

private Driver driver;

public Person(){

 

}

public Person(Driver driver){

   this.driver = driver;

}

public void drive(){

       driver.run();

}

public void setDriver(Driver driver){//運用參數多態,之後無論買什麼車均可以

   this.driver = driver;

}

 

 

public static void main(String args[]){

   Person p =new Person();

   JD jd = new JD();//剛開始沒錢就買輛JD吧

   p.setDriver(jd);

   p.driver();

   Benz benz = new Benz{();//有錢換車了

   p.setDriver(benz);

   p.driver();

}

}

 -------------------------

什麼是多態? 

簡單的說:就是用基類的引用指向子類的對象

 

提問:多態能夠用在什麼地方呢?

回答:能夠用在方法的參數中和方法的返回類型中

 

其中方法的參數樓上的兄弟已經給出了代碼.我這裏給出在方法的返回類型中如何使用多態

 

上面的例子中,無論是JD仍是Benz都是咱們本身直接new出來的.咱們能夠設計一個工廠類,專門生成汽車

 

/**

*   咱們將多態使用在方法的返回類型中

*   Car能夠是抽象類,也能夠是接口,JD和Benz分別繼承該類或實現該藉口

*/

public class CarFactory{

public Car factory(String carName){

   if(carName.equals("JD")){

      return new JD();

   }else if(carName.equals("Benz")){

      return new Benz();

   }else{

      System.out.println("對比起,不伺候");

      return null;

   }

}

}

 

這實際上就是設計模式中的簡單工廠模式!

 

另外,我咱們在JDK中能夠大量的看到多態的應用,好比在Object類中的equals(Object obj)方法中,參數是個Object

 

類型的參數.由於Object是Java中全部類的基類.,可是才傳入參數的時候,能夠傳入任何一個類的對象

這就是多態的應用!

 

使用多態能夠解決項目中緊偶合的問題,提升程序的可擴展性.是OCP原則的一個具體的實現。