快捷導(dǎo)航

Java設(shè)計模式之里氏替換原則精解

更新時間：2022年02月08日 11:06:45 作者：張起靈-小哥

設(shè)計模式（Design pattern）代表了最佳的實踐，通常被有經(jīng)驗的面向?qū)ο蟮能浖_發(fā)人員所采用。設(shè)計模式是軟件開發(fā)人員在軟件開發(fā)過程中面臨的一般問題的解決方案。本篇介紹設(shè)計模式七大原則之一的里氏替換原則

1.什么是里氏替換原則？

我們都知道，在面向?qū)ο缶幊讨杏腥筇匦裕ǚ庋b、繼承、多態(tài)），在這里我們來說繼承這個東西。

繼承包含這樣一層含義:父類中凡是已經(jīng)實現(xiàn)好的方法，實際上是在設(shè)定規(guī)范和契約，雖然它不強制要求所有的子類必須遵循這些契約，但是如果子類對這些已經(jīng)實現(xiàn)的方法任意修改，就會對整個繼承體系造成破壞。

也就是說：繼承在給程序設(shè)計帶來便利的同時，也帶來了弊端。比如使用繼承會給程序帶來侵入性,程序的可移植性降低，增加對象間的耦合性，如果一個類被其他的類所繼承，則當這個類需要修改時，必須考慮到所有的子類，并且父類修改后，所有涉及到子類的功能都有可能產(chǎn)生故障。

問題提出:在編程中，如何正確的使用繼承? => 里氏替換原則 ??????

里氏替換原則(Liskov Substitution Principle)在1988年，由麻省理工學(xué)院的以為姓里的女士提出的。
如果對每個類型為Tl的對象o1，都有類型為T2的對象o2，使得以Tl定義的所有程序Р在所有的對象o1都代換成o2時，程序Р的行為沒有發(fā)生變化，那么類型T2是類型TI的子類型。換句話說，所有引用基類的地方必須能透明地使用其子類的對象。
在使用繼承時，遵循里氏替換原則，在子類中盡量不要重寫父類的方法。
里氏替換原則告訴我們，繼承實際上讓兩個類耦合性增強了，在適當?shù)那闆r下，可以通過聚合，組合，依賴來解決問題。

2.代碼案例

package com.szh.principle.liskov;
 
/**
 *
 */
// A類
class A {
    // 返回兩個數(shù)的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
 
// B類繼承了A
// 增加了一個新功能：完成兩個數(shù)相加,然后和9求和
class B extends A {
    //這里，重寫了A類的方法, 可能是無意識
    public int func1(int a, int b) {
        return a + b;
    }
 
    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
}
 
public class Liskov {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3=" + a.func1(11, 3));
        System.out.println("1-8=" + a.func1(1, 8));
        System.out.println("-----------------------");
 
        B b = new B();
        System.out.println("11-3=" + b.func1(11, 3));  //這里本意是求出11-3
        System.out.println("1-8=" + b.func1(1, 8));    //這里本意是求出1-8
        System.out.println("11+3+9=" + b.func2(11, 3));
    }
}

從代碼運行結(jié)果中看到，有兩行出了問題，這是因為B繼承A之后，并且重寫了func1方法，那么此時就不會再去執(zhí)行A類的func1方法了，而是執(zhí)行B自己的func1方法，而B中func1方法的邏輯是對兩個數(shù)求和，所以這里你以為的就不再是你以為的了。

3.改進代碼

我們發(fā)現(xiàn)原來運行正常的相減功能發(fā)生了錯誤。原因就是類B無意中重寫了父類的方法，造成原有功能出現(xiàn)錯誤。在實際編程中，我們常常會通過重寫父類的方法完成新的功能，這樣寫起來雖然簡單，但整個繼承體系的復(fù)用性會比較差。特別是運行多態(tài)比較頻繁的時候。

通用的做法是: 原來的父類和子類都繼承一個更通俗的基類，原有的繼承關(guān)系去掉，采用依賴，聚合，組合等關(guān)系代替。

package com.szh.principle.liskov.improve;
 
/**
 *
 */
//創(chuàng)建一個更加基礎(chǔ)的基類
class Base {
    //把更加基礎(chǔ)的方法和成員寫到Base類
}
 
// A類
class A extends Base {
    // 返回兩個數(shù)的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
 
// B類繼承了A
// 增加了一個新功能：完成兩個數(shù)相加,然后和9求和
class B extends Base {
    //如果B需要使用A類的方法,使用組合關(guān)系
    private A a = new A();
 
    //這里，重寫了A類的方法, 可能是無意識
    public int func1(int a, int b) {
        return a + b;
    }
 
    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
 
    //我們?nèi)匀幌胧褂肁的方法
    public int func3(int a, int b) {
        return this.a.func1(a, b);
    }
}
 
public class Liskov {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3=" + a.func1(11, 3));
        System.out.println("1-8=" + a.func1(1, 8));
        System.out.println("-----------------------");
 
        B b = new B();
        //因為B類不再繼承A類，因此調(diào)用者不會再認為func1方法是求減法
        //調(diào)用完成的功能就會很明確
        System.out.println("11+3=" + b.func1(11, 3));//這里本意是求出11+3
        System.out.println("1+8=" + b.func1(1, 8));//這里本意是求出1+8
        System.out.println("11+3+9=" + b.func2(11, 3));
        //使用組合仍然可以使用到A類相關(guān)方法
        System.out.println("11-3=" + b.func3(11, 3));// 這里本意是求出11-3
    }
 
}

此時我們創(chuàng)建一個更基礎(chǔ)的Base類，讓A和B都繼承這個類，如果還想像之前那樣在B中使用A，那么就采用組合來解決，即在B類中聲明一個私有的A類成員變量就可以了。