作為一個合格的程式設計師所寫出來的程式是要具有靈活性的，就是寫的程式碼，要維護性高，複用性高，擴充套件性高。通過面向物件的特點（封裝，繼承，多型...）把程式的耦合度降低，使其達到高內聚，低耦合。那麼在有些時候使用適當的設計模式可以使得程式更加的靈活，易於修改，易於複用。

設計模式的六大原則

一、單一職責原則

該原則是指一個類只負責一個功能領域中的相應職責，或者可以定義為：就一個類而言，應該只有一個引起它變化的原因。它是實現高內聚、低耦合的指導方針，它是最簡單但又最難運用的原則，需要設計人員發現類的不同職責並將其分離，而發現類的多重職責需要設計人員具有較強的分析設計能力和相關實踐經驗。

二、開閉原則

該原則是面向物件的可複用設計的第一塊基石，它是最重要的面向物件設計原則。一個軟體實體應當對擴充套件開放，對修改關閉。即軟體實體應儘量在不修改原有程式碼的情況下進行擴充套件，軟體實體可以指一個軟體模組、一個由多個類組成的區域性結構或一個獨立的類。

三、里氏替換原則

該原則是指所有引用基類（父類）的地方必須能透明地使用其子類的物件。在軟體中將一個基類物件替換成它的子類物件，程式將不會產生任何錯誤和異常，反過來則不成立，如果一個軟體實體使用的是一個子類物件的話，那麼它不一定能夠使用基類物件。

四、依賴倒置原則

抽象不應該依賴於細節，細節應當依賴於抽象。換言之，要針對介面程式設計，而不是針對實現程式設計。
在實現依賴倒轉原則時，我們需要針對抽象層程式設計，而將具體類的物件通過依賴注入(DI)

五、介面隔離原則

使用多個專門的介面，而不使用單一的總介面，即客戶端不應該依賴那些它不需要的介面。
在使用介面隔離原則時，我們需要注意控制介面的粒度，介面不能太小，如果太小會導致系統中介面氾濫，不利於維護；介面也不能太大，太大的介面將違背介面隔離原則，靈活性較差，使用起來很不方便。一般而言，介面中僅包含為某一類使用者定製的方法即可，不應該強迫客戶依賴於那些它們不用的方法。

六、迪米特法則

一個軟體實體應當儘可能少地與其他實體發生相互作用。迪米特法則可降低系統的耦合度，使類與類之間保持鬆散的耦合關係。迪米特法則要求我們在設計系統時，應該儘量減少物件之間的互動，如果兩個物件之間不必彼此直接通訊，那麼這兩個物件就不應當發生任何直接的相互作用，如果其中的一個物件需要呼叫另一個物件的某一個方法的話，可以通過第三者轉發這個呼叫。簡言之，就是通過引入一個合理的第三者來降低現有物件之間的耦合度。

在將迪米特法則運用到系統設計中時，要注意下面的幾點：

1）在類的劃分上，應當儘量建立鬆耦合的類，類之間的耦合度越低，就越有利於複用，一個處在鬆耦合中的類一旦被修改，不會對關聯的類造成太大波及；

2）在類的結構設計上，每一個類都應當儘量降低其成員變數和成員函式的訪問許可權；

3）在類的設計上，只要有可能，一個型別應當設計成不變類；在對其他類的引用上，一個物件對其他物件的引用應當降到最低。

簡單工廠模式

現在我們有一個要做計算器需求，要求實現加減乘除的演算法，用簡單工廠模式就如下：

類圖：

1、新建一個Operation類

public class Operation {
    private double NumberA;
    private double NumberB;
    public Operation() {
        NumberA = 0.00;
NumberB = 0.00;
}

    public double getNumberA() {
        return NumberA;
}

    public void setNumberA(double numberA) {
        NumberA = numberA;
}

    public double getNumberB() {
        return NumberB;
}

    public void setNumberB(double numberB) {
        NumberB = numberB;
}

    public double getResult(double NumberA,double NumberB) throws Exception {

        double result = 0.0;
        return result;
}
}

2、分別新建加、減、乘、除的類來繼承這個Operation父類

1）加法：

public class OperationAdd extends Operation {
    /**
     * 加法
*/
@Override
public double getResult(double NumberA,double NumberB) {
        double result = NumberA + NumberB;
        return result;
}
}

2）減法：

public class OperationSub extends Operation {
    /**
     * 減法
*/
@Override
public double getResult(double NumberA, double NumberB) {
        double result = NumberA - NumberB;
        return result;
}
}

3）乘法：

public class OperationMul extends Operation {
    /**
     * 乘法
*/
@Override
public double getResult(double NumberA, double NumberB) {
        double result = NumberA * NumberB;
        return result;
}
}

4）除法：

public class OperationDiv extends Operation {
    /**
     * 除法
*/
@Override
public double getResult(double NumberA, double NumberB) throws Exception {

        if (NumberB == 0) {
            throw new Exception("除數不能為0");
}

        double result = NumberA / NumberB;
        return result;
}
}

3、新建一個運算工廠類在實現這個運算

public class OperationFactory {
    public static Operation createOperation(String operate) {

        Operation ope = null;
        switch (operate) {
            case "+":
                ope = new OperationAdd();
                break;
            case "-":
                ope = new OperationSub();
                break;
            case "*":
                ope = new OperationMul();
                break;
            case "/":
                ope = new OperationDiv();
                break;
}
        return ope;
}
}

4、執行

public class Run {

    public static void main(String[] args) throws Exception{

        Operation operation = OperationFactory.createOperation("-");
        double NumberA = 1;
        double NumberB = 2;
        double result = operation.getResult(NumberA,NumberB);
System.out.println(result);
}
}

 簡單工廠模式的優點：

 模組清晰化，每個部分都各司其職，分工明確。

缺點：

如果此時需要增加一產品，比如在計算器中加入一個新的功能，可以求M的N次方，這樣個小功能我們就要去新增一個新的類，同時我們需要在Factory中改動到switch裡面的程式碼，這是耦合性很高的表現。