Law of Demeter (LOD)

定義：

也稱最少知識原則(Principle of Least Knowledge)。
模組應該儘可能的減少其他模組交互，目的在於降低彼此之間的依賴。
 

說明：

以下為必須遵循 LOD 的條件
類別 O 的任何方法 m 只能呼叫屬於以下情況的方法
1. 類別 O 本身的方法。
2. 傳入 m 的參數的方法。
3. 在 m 中建立對象的方法。
4. 任何直接持有的對象方法。
 
Example Code :

public class Man {
    private Vehicle mVehicle;
    private void methodInMan(){}
    public void driveVehicle(Vehicle vehicle){
    	methodInMan();// Rule 1
        vehicle.drive();// Rule 2
        new Car().drive();// Rule 3
        mVehicle = new Bike();
        mVehicle.drive();//Rule 4
        new Bike().getClass().getName(); //violation at getName()
    }
}

如何修改遵循 LOD ，可以在 Bike 中直接建立方法來取得 class name，如下

public class Bike implements Vehicle{
    ...
    public String getClassName(){
        return getClass().getName();
    }
}

client 端呼叫

public class Man {
    private Vehicle mVehicle;
    private void methodInMan(){}
    public void driveVehicle(Vehicle vehicle){
    	methodInMan();// Rule 1
        vehicle.drive();// Rule 2
        new Car().drive();// Rule 3
        mVehicle = new Bike();
        mVehicle.drive();//Rule 4
        new Bike().getClassName(); //Rule 3
    }
}

 
注意：
在重構中的程式碼壞味道第15點 Message Chain (過度耦合的消息鏈) 其本身也是描述相同的問題:
一個對象請求另一個對象，然後再向後者請求一個對象。
代表對象之間的結構緊密耦合，一旦對象關係發生變化，客戶端不得不做出相應修改。
可以使用 Hide Delegate 來重構！！
 

Interface Segregation Principle (ISP)

定義：

客戶端不應該被強迫依賴不需要的方法。（介面應該只提供客戶端需要的方法）
 
 

說明：

一個過大的 interface ，通常代表其中有某些功能是客戶端不需要的，如果客戶端實作了不需要的功能 ，這些功能會造成不必要的耦合。
我們可以把過大的 interface 分離，將其中某些功能拆離到另一個 interface 中。
 

Example Code：

回到 OCP 的初始範例，其中 Bike , Car 都有類似的方法( driveBike , driveCar)。

public class Bike {
    public void driveBike(){
        System.out.println("drive Bike");
    }
}
public class Car {
    public void driveCar(){
        System.out.println("drive Car");
    }
    public void openWindow(){
        System.out.println("open window");
    }
}

現在必須建立抽象層 Vehicle，和 OCP 不同的是我們把 openWindow 也放到 Vehicle 中。

public interface Vehicle {
    public void drive();
    public void openWindow();
}

對 Bike 而言，必須實作 openWindow 行為，但該行為對 Bike 是沒有意義，也違反了 ISP。

public class Bike implements Vehicle{
    public void drive(){
        System.out.println("drive Bike");
    }
    @Override
    public void openWindow() {
        // unmeaning action for Bike
    }
}

為了遵循 ISP，可以另外建立 Window 介面，並把 openWindow 移到 Window 介面中。

public interface Window {
    public void openWindow();
}

現在 Bike 可以不必實作 openWindow 方法。

public class Bike implements Vehicle{
    public void drive(){
        System.out.println("drive Bike");
    }
}

Dependence Inversion Principle (DIP)

定義：

高層模組不應該相依於低層模組，兩者都應該相依於抽象。
抽象不應該相依於細節，細節應該相依於抽象。
 

說明：

傳統的軟體開發方法，如結構化分析與設計傾向於創造高階模組相依於低階模組。目標就是描述高階模組如何呼叫低階模組的子程式結構。
相較於以傳統程序化方法的相依結構，設計良好的物件導向程式的相依結構應該是反向的。
高層指的是依賴者 , 低層指的是被依賴者。如下圖

模組之間的依賴應該透過抽象，而不應該透過具體的方式(針對介面寫程式)
對象的引用盡量是抽象型態而不是具體型態。
因此使用DIP之後應該為

HighLevel 和 LowLevel 都相依於 abstract level。
 

注意：

若是具體類別已經相當穩定，不太會變化，依賴於該具體類別也是無妨。
 
Example Code：
以先前的 LSP 的範例 來說明

public interface Vehicle {
    public void drive();
}
public class Bike implements Vehicle{
    public void drive(){
        System.out.println("drive Bike");
    }
}
public class Car implements Vehicle{
    public void drive(){
        System.out.println("drive car");
    }
    public void openWindow(){
        System.out.println("open window");
    }
}

若用一個 Man 來代表使用者，並讓 Man 可以操縱 Bike，在未加考慮的情況會直接寫出以下 code，並違反了 DIP。
在 driveBike 的方法參數，並沒有依賴抽象(Vehicle)，相反的依賴具體型態(Bike)。

public class Man {
    public void driveBike(Bike bike){
        bike.drive();
    }
}

修改的方法很簡單，把參數型態改為 Vehicle。
另一個依賴抽象的好處是可以減少多餘的code，在依賴具體 Bike 的情況下, 若我們想讓 Man 可以駕駛 Car,  必須還要寫出另一個 driveCar 方法。

public class Man {
    public void driveBike(Bike bike){
        bike.drive();
    }
    public void driveCar(Car car){
        car.drive();
    }
}

修改 Man 的 driveVehicle 方法，讓其參數型態依賴抽象(Vehicle)。

public class Man {
    public void driveVehicle(Vehicle vehicle){
        vehicle.drive();
    }
}

調用端呼叫 driveVehicle 方法可以根據傳入參數型態的不同，具有不同的行為。

public class Main {
    public static void main(String[] args) {
        Man man = new Man();
        man.driveVehicle(new Bike());
        man.driveVehicle(new Car());
    }
}

 
另一種依賴具體的形式為基本型別。如

public int getSummary(int a, int b)
{
...
}

如果需要支援多種 Summary 算法，可以引入抽象層為參數。

public int getSummary(CustomType a, CustomType b){
...
}
public interface CustomType{
...
}

Liskov Substitution Principle (LSP)

定義：

衍生類別(Sub Type)必須能夠替換成他們的基礎類別(Base Type)。
衍生類別應該可以替換任何基楚類別出現的位置，且程序還能正常工作。
 

說明：

1. 不能僅用 is-a 的關係就建立繼承，必須考慮是否在基礎類別中有些方法對衍生類別而言是不需要或是無意義的。
這些沒有意義的方法會造成不可預期的結果。
2.一些違反 LSP 觀察點（基本上從衍生類別刪除基礎類別的功能就代表了無法取代基礎類別，因而違反了LSP）
1.退化函式(不一定絕對違反LSP，但需要檢查一下)，基本上退化函式就是繼承基礎類別的函式，但在該函式中沒有做任何事，這種函式就是沒有意義的。

public class BaseClass {
  public void method(){
    //do something
  }
}
public class DeriveClass extends BaseClass{
  @Override
  public void method() {
    //do nothing
  }
}

DeriveClass 的 method 可能違反了LSP
2.在衍生類別丟出基礎類別沒有的異常

注意：

必須要有繼承關係才需要考慮 LSP ，而 LSP 是讓設計達到 OCP 的規則之一 。
 

Example Code :

Vehicle 有2個簡單的方法, 分別是 drive (駕駛)和 openWindow (打開車窗)。

public class Vehicle {
    public void drive(){
        System.out.println("drive vehicle");
    }
    public void openWindow(){
        System.out.println("open window");
    }
}

若單以語意而言 Vehicle 和 Bike  有 is-a 的關係，也有共同的方法 drive , 但 openWindow 對 Bike 而言是沒有意義的。
若強制讓 Bike 繼承 Vehicle 會有2種情況。
1. Bike 不覆寫 openWindow 方法

public class Bike extends Vehicle{
    public void drive(){
        System.out.println("drive Bike");
    }
}

2. Bike 覆寫 openWindow 方法，但方法內容令人迷惑。

public class Bike extends Vehicle{
    public void drive(){
        System.out.println("drive Bike");
    }
    public void openWindow(){
        System.out.println("Bike can't open window");
    }
}

不論哪種方法都無法到達呼叫端預期的結果 e.g.

Vehicle bike = new Bike();
bike.openWindow();// why bike can open window?

因此 Bike 繼承 Vehicle 不符合 LSP 。
 
如何讓 Bike 符合 LSP?
我們可以重新建立抽象層 Vehicle 並提取 Bike 和 Car 共同的部份並放入 Vehicle 中，並讓2者都派生 Vehicle。

public interface Vehicle {
    public void drive();
}

Bike 實作 Vehicle

public class Bike implements Vehicle{
    public void drive(){
        System.out.println("drive Bike");
    }
}

Car 實作 Vehicle

public class Car implements Vehicle{
    public void drive(){
        System.out.println("drive car");
    }
    public void openWindow(){
        System.out.println("open window");
    }
}

最後以語意來說 Car , Bike 都是 Vehicle。 Vehicle 的方法對於 Car , Bike 都是有意義的。