面向對象五大原則-----里氏代換原則

　　什么是里氏代換原則　

　　里氏代換原則(Liskov Substitution Principle LSP)面向對象設計的基本原則之一。 里氏代換原則中說，任何基類可以出現的地方，子類一定可以出現。 LSP是繼承復用的基石，只有當衍生類可以替換掉基類，軟件單位的功能不受到影響時，基類才能真正被復用，而衍生類也能夠在基類的基礎上增加新

的行為。里氏代換原則是對“開-閉”原則的補充。實現“開-閉”原則的關鍵步驟就是抽象化。而基類與子類的繼承關系就是抽象化的具體實現，所以里氏代換原則是對實現抽象化的具體步驟的規范。

　　簡單的理解為一個軟件實體如果使用的是一個父類，那么一定適用於其子類，而且它察覺不出父類對象和子類對象的區別。也就是說，軟件里面，把父類都替換成它的子類，程序的行為沒有變化。

　　但是反過來的代換卻不成立，里氏代換原則(Liskov Substitution Principle)：一個軟件實體如果使用的是一個子類的話，那么它不能適用於其父類。

 　　舉個例子解釋一下這個概念

　　先創建一個Person類

public class Person {
    public void display() {
        System.out.println("this is person");
    }
}

　　再創建一個Man類，繼承這個Person類

public class Man extends Person {

    public void display() {
        System.out.println("this is man");
    }
    
}

　　運行一下

public class MainClass {
    public static void main(String[] args) {
        Person person = new Person();//new一個Person實例
        display(person);
        
        Person man = new Man();//new一個Man實例
        display(man);
    }
    
    public static void display(Person person) {
        person.display();
    }
}

　　可以看到

　　運行沒有影響，符合一個軟件實體如果使用的是一個父類的話，那么一定適用於其子類，而且它察覺不出父類和子類對象的區別這句概念，這也就是java中的多態。

　　而反之，一個子類的話，那么它不能適用於其父類，這樣，程序就會報錯

public class MainClass {
    public static void main(String[] args) {
        Person person = new Person();
        display(person);//這里報錯
        
        Man man = new Man();
        display(man);
    }
    
    public static void display(Man man) {//傳入一個子類
        man.display();
    }
}

 

　　繼續再舉一個很經典的例子，正方形與長方形是否符合里氏代換原則，也就是說正方形是否是長方形的一個子類，

 　　以前，我們上學都說正方形是特殊的長方形，是寬高相等的長方形，所以我們認為正方形是長方形的子類，但真的是這樣嗎？

　　

　　從圖中，我們可以看到長方形有兩個屬性寬和高，而正方形則只有一個屬性邊長

　　所以，用代碼如此實現

//長方形
public class Changfangxing{
    private long width;
    private long height;
    
    public long getWidth() {
        return width;
    }
    public void setWidth(long width) {
        this.width = width;
    }
    public long getHeight() {
        return height;
    }
    public void setHeight(long height) {
        this.height = height;
    }
}

//正方形
public class Zhengfangxing{
    private long side;

    public long getSide() {
        return side;
    }

    public void setSide(long side) {
        this.side = side;
    }
}

 

　　可以看到，它們的結構根本不同，所以正方形不是長方形的子類，所以長方形與正方形之間並不符合里氏代換原則。

　　當然我們也可以強行讓正方形繼承長方形

//正方形
public class Zhengfangxing extends Changfangixng{
    private long side;

    public long getHeight() {
        return this.getSide();
    }

    public long getWidth() {
        return this.getSide();
    }

    public void setHeight(long height) {
        this.setSide(height);
    }

    public void setWidth(long width) {
        this.setSide(width);
    }

    public long getSide() {
        return side;
    }

    public void setSide(long side) {
        this.side = side;
    }
}

 

 　　這個樣子，編譯器是可以通過的，也可以正常使用，但是這樣就符合里氏代換原則了嗎，肯定不是的。

　　我們不是為了繼承而繼承，只有真正符合繼承條件的情況下我們才去繼承，所以像這樣為了繼承而繼承，強行實現繼承關系的情況也是不符合里氏代換原則的。

　　但這是為什么呢？，我們運行一下

public class MainClass {
    public static void main(String[] args) {
        Changfangxing changfangxing = new Changfangxing();
        changfangxing.setHeight(10);
        changfangxing.setWidth(20);
        test(changfangxing);
        
        Changfangxing zhengfangxing = new Zhengfangxing();
        zhengfangxing.setHeight(10);
        test(zhengfangxing);
    }
    
    public static void test(Changfangxing changfangxing) {
        System.out.println(changfangxing.getHeight());
        System.out.println(changfangixng.getWidth());
    }
}

　　結果：

　　我們忽然發現，很正常啊，為什么不可以，但是我們繼續修改

public class MainClass {
    public static void main(String[] args) {
        Changfangxing changfangxing = new Changfangxing();
        changfangxing.setHeight(10);
        changfangxing.setWidth(20);
        resize(changfangxing);
        
        Changfangxing zhengfangxing = new Zhengfangxing();
        zhengfangxing.setHeight(10);
        resize(zhengfangxing);
    }
    
    public static void test(Changfangxing changfangxing) {
        System.out.println(changfangxing.getHeight());
        System.out.println(changfangxing.getWidth());
    }
    
    public static void resize(Changfangxing changfangxing) {
        while(changfangxing.getHeight() <= changfangxing.getWidth()) {
            changfangxing.setHeight(changfangxing.getHeight() + 1);
            test(changfangxing);
        }
    }
}

　　當長方形運行時，可以正常運行，而正方形則會造成死循環，所以這種繼承方式不一定恩能夠適用於所有情況，所以不符合里氏代換原則。

　　還有一種形式，我們抽象出一個四邊形接口，讓長方形和正方形都實現這個接口

public interface Sibianxing {
    public long getWidth();
    public long getHeight();
}

public class Changfangxing implements Sibianxing{
    private long width;
    private long height;
    
    public long getWidth() {
        return width;
    }
    public void setWidth(long width) {
        this.width = width;
    }
    public long getHeight() {
        return height;
    }
    public void setHeight(long height) {
        this.height = height;
    }
}

package com.ibeifeng.ex3;

public class Zhengfangxing implements Sibianxing{
    private long side;

    public long getHeight() {
        return this.getSide();
    }

    public long getWidth() {
        return this.getSide();
    }

    public void setHeight(long height) {
        this.setSide(height);
    }

    public void setWidth(long width) {
        this.setSide(width);
    }

    public long getSide() {
        return side;
    }

    public void setSide(long side) {
        this.side = side;
    }
}

　　運行

public class MainClass {
    public static void main(String[] args) {
        Changfangxing changfangxing = new Changfangxing();
        changfangxing.setHeight(10);
        changfangxing.setWidth(20);
        test(changfangxing);
        
        Zhengfangxing zhengfangxing = new Zhengfangxing();
        zhengfangxing.setHeight(10);
        test(zhengfangxing);
    }
    
    public static void test(Sibianxing sibianxing) {
        System.out.println(sibianxing.getHeight());
        System.out.println(sibianxing.getWidth());
    }
}

　　對於長方形和正方形，取width和height是它們共同的行為，但是給width和height賦值，兩者行為不同，因此，這個抽象的四邊形的類只有取值方法，沒有賦值方法。上面的例子中那個方法只會適用於不同的子類，LSP也就不會被破壞。

　　注意事項

　　在進行設計的時候，盡量從抽象類繼承，而不是從具體類繼承。如果從繼承等級樹來看，所有葉子節點應當是具體類，而所有的樹枝節點應當是抽象類或者接口。當然這個只是一個一般性的指導原則，使用的時候還要具體情況具體分析。