SOLID設計原則與工廠模式

在面向對象設計領域裏，SOLID是很是經典的設計原則，能夠認爲它是道，設計模式是術，只有深入理解了道，才能用好術。下面簡單總結一下SOLID原則：

• Single Responsibility Principle: 每一個類只能有一個被修改的緣由
• Open-Close Principle: 對擴展開發，對修改關閉
• Liskov's Substitution Principle: 派生類必須可以徹底替換基類Liskov's Substitution Principle(LSP)
• Interface Segregation Principle：客戶端不該該被強制依賴他們不須要使用的接口
• Dependency Inversion Principle: 高層次的模塊不該該依賴低層次的模塊, 雙方都應該依賴抽象。抽象不該該依賴具體細節。細節應該依賴抽象。Dependency Inversion Principle

下面以工廠模式爲例，說明一下SOLID原則在設計模式裏的體現：
工廠模式屬於建立型模式，主要分三種：

• 簡單工廠模式
• 工廠方法模式
• 抽象工廠模式

我的以爲第三種模式使用場景較少且比較雞肋，主要介紹前兩種。
先來看下簡單工廠模式：

public abstract class Operation{
    private double value1;
    private double value2;

    public double getValue1() {
        return value1;
    }

    public void setValue1(double value1) {
        this.value1 = value1;
    }

    public double getValue2() {
        return value2;
    }

    public void setValue2(double value2) {
        this.value2 = value2;
    }
    
    protected abstract double getResult();
}
public class OperationAdd extends Operation {
    @Override
    protected double getResult(){
        return getValue1() + getValue2();
    }
}
public class OperationMinus extends Operation {
    @Override
    protected double getResult(){
        return getValue1() - getValue2();
    }
}
public class OperationMul extends Operation {
    @Override
    protected double getResult(){
        return getValue1() * getValue2();
    }
}
public class OperationFactory{
    public static Operation createOperation(String operation){
        Operation operation = null;
        switch(operation){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationMinus();
                break;
            case "*":
                operation = new OperationMul();
                break;
            default:
                throw new UnsupportedOperationException("Unsupported Operation:" + operation);
        }
        return operation;
    }
}

首先，咱們必須令Operation的派生類遵循Liskov's Substitution Principle，才能放心的說，不管咱們在工廠中建立出哪一種Operation的派生類，都可以利用多態替換其後對Operation的引用。
其次，工廠模式返回抽象類，使調用工廠的高層模塊依賴Operation這個抽象類而不是其某個具體的派生類，這知足了Dependency Inversion Principle。
可是，OperationFactory類中包含了全部Operation派生類的建立，後面若是不斷的須要增長新的Operation派生類，就須要不斷的修改OperationFactory，這違反了Open-Close Principle，就須要引入工廠方法模式：

public interface IFactory {
    Operation CreateOption();
}
public class AddFactory implements IFactory {
    public Operation CreateOption() {
        return new OperationAdd();
    }
}
public class MulFactory implements IFactory {
    public Operation CreateOption() {
        return new OperationMul();
    }
}
public class SubFactory implements IFactory {
    public Operation CreateOption() {
        return new OperationSub();
    }
}

這樣每當有新的Operation派生類，只須要對應新建新的工廠類就能夠了，這其實也是將工廠類與其調用者用抽象層隔離了。但要注意這也會由於建立過多的類而難以管理。