設計模式之里氏替換原則示例

　　里氏替換原則強調的是設計和實現要依賴於抽象而非具體；子類只能去擴展基類，而不是隱藏或者覆蓋基類，它包含4層含義.

一、里氏替換4原則

　　1、子類可以實現父類的抽象方法，但不能覆蓋父類的非抽象方法

　　子類可以實現父類的抽象方法，但不能覆蓋父類的非抽象方法，父類中凡是已經實現好的方法（相對於抽象方法而言），實際上是在設定一系列的規范和契約，雖然它不強制要求所有的子類必須遵從這些契約，但是如果子類對這些非抽象方法任意修改，就會對整個繼承體系造成破壞。舉例：

public class C {
    public int func(int a, int b){
        return a+b;
    }
}

public class C1 extends C{
    @Override
    public int func(int a, int b) {
        return a-b;
    }
}

public class Client{
    public static void main(String[] args) {
        C c = new C1();
        System.out.println("2+1=" + c.func(2, 1));
    }
}

　　運行結果：2+1=1

　　上面的運行結果明顯是錯誤的。類C1繼承C，后來需要增加新功能，類C1並沒有新寫一個方法，而是直接重寫了父類C的func方法，違背里氏替換原則，引用父類的地方並不能透明的使用子類的對象，導致運行結果出錯。

　　2、子類可以有自己的個性

　　在繼承父類屬性和方法的同時，每個子類也都可以有自己的個性，在父類的基礎上擴展自己的功能。前面其實已經提到，當功能擴展時，子類盡量不要重寫父類的方法，而是另寫一個方法，所以對上面的代碼加以更改，使其符合里氏替換原則，代碼如下：

public class C {
    public int func(int a, int b){
        return a+b;
    }
}

public class C1 extends C{
    public int func2(int a, int b) {
        return a-b;
    }
}

public class Client{
    public static void main(String[] args) {
        C1 c = new C1();
        System.out.println("2-1=" + c.func2(2, 1));
    }
}

　　運行結果：2-1=1

　　3、覆蓋或實現父類的方法時輸入參數可以被放大

　　當子類的方法重載父類的方法時，方法的前置條件（即方法的形參）要比父類方法的輸入參數更寬松，通過代碼來講解一下：

public class ParentClazz {
    public void say(CharSequence str) {
        System.out.println("parent execute say " + str);
    }
}

public class ChildClazz extends ParentClazz {
    public void say(String str) {
        System.out.println("child execute say " + str);
    }
}

/**
 * 測試
 */
public class Main {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        ParentClazz parent = new ParentClazz();
        parent.say("hello");
        ChildClazz child = new ChildClazz();
        child.say("hello");

    }
}

// 執行結果：
// parent execute say hello
// child execute say hello

　　以上代碼中我們並沒有重寫父類的方法，只是重載了同名方法，具體的區別是：子類的參數 String 實現了父類的參數 CharSequence。此時執行了子類方法，在實際開發中，通常這不是我們希望的，父類一般是抽象類，子類才是具體的實現類，如果在方法調用時傳遞一個實現的子類可能就會產生非預期的結果，引起邏輯錯誤，根據里氏替換的子類的輸入參數要寬於或者等於父類的輸入參數，我們可以修改父類參數為String，子類采用更寬松的 CharSequence，如果你想讓子類的方法運行，就必須覆寫父類的方法。代碼如下：

public class ParentClazz {
    public void say(String str) {
        System.out.println("parent execute say " + str);
    }
}

public class ChildClazz extends ParentClazz {
    public void say(CharSequence str) {
        System.out.println("child execute say " + str);
    }
}

public class Main {
    public static void main(String[] args) {
        ParentClazz parent = new ParentClazz();
        parent.say("hello");
        ChildClazz child = new ChildClazz();
        child.say("hello");
    }
}

// 執行結果：
// parent execute say hello
// parent execute say hello

　　4、覆寫或實現父類的方法時輸出結果可以被縮小

　　當子類的方法實現父類的抽象方法時，方法的后置條件（即方法的返回值）要比父類更嚴格。代碼實現案例如下：

public abstract class Father {
    public abstract Map hello();
}

public class Son extends Father {
    @Override
    public Map hello() {
        HashMap map = new HashMap();
        System.out.println("son execute");
        return map;
    }
}

public class Main {
    public static void main(String[] args) {
        Father father = new Son();
        father.hello();
    }
}

// 執行結果：
// son execute

二、里氏替換原則優點

　　保證了父類的復用性，同時也能夠降低系統出錯誤的故障，防止誤操作，同時也不會破壞繼承的機制，這樣繼承才顯得更有意義。

　　增強程序的健壯性,版本升級是也可以保持非常好的兼容性.即使增加子類,原有的子類還可以繼續運行.在實際項目中,每個子類對應不同的業務含義,使用父類作為參數,傳遞不同的子類完成不同的業務邏輯,完美!

三、里氏替換原則總結

　　繼承作為面向對象三大特性之一，在給程序設計帶來巨大便利的同時，也帶來了弊端。比如使用繼承會給程序帶來侵入性，程序的可移植性降低，增加了對象間的耦合性，如果一個類被其他的類所繼承，則當這個類需要修改時，必須考慮到所有的子類，並且父類修改后，所有涉及到子類的功能都有可能會產生故障。

　　里氏替換原則的目的就是增強程序健壯性，版本升級時也可以保持非常好的兼容性。

　　有人會說我們在日常工作中，會發現在自己編程中常常會違反里氏替換原則，程序照樣跑的好好的。所以大家都會產生這樣的疑問，假如我非要不遵循里氏替換原則會有什么后果？后果就是：你寫的代碼出問題的幾率將會大大增加。