1 設計模式中經常用到程序設計中的封裝，繼承，多態的思想。不同的設計模式使代碼更加靈活，容易擴展。

2 設計模式中一般都會存在父類的概念，父類一般是抽象類，內部維護的變量，用於子類繼承；維護的抽象方法，用於子類去具體實現。

3 對於一個方案的模式設計，要首先抽象出父類，想出父類中要維護哪些子類都要用到的變量；維護哪些子類都要去實現的方法。

擴展性的體現：主要體現在多態的實現部分，比如增加新的需求，要求可以計算a的b次冪，不需要動加減乘除的具體實現代碼（類），只需要增加新類，去實現冪運算，在工廠類中，增加一個case語句即可。

解耦合的體現：不同的加減乘除具體實現方法通過不同的類來實現，這樣它們之間基本沒關聯，實現解耦合。

本例子應用簡單工廠的設計模式，返回不同的加減乘除運算類的對象。

package com.biao.factory.simplefactory;

/*
 *0 簡單工廠類：根據傳遞的不同參數，通過多態，創建不同的對象，進行不同的運算操作。
 *1 可擴展：比如增加新的開方運算，只需要增加一個具體的運算類OperationSqur即可，不用更改原有代碼，此為可擴展。
 *2 封裝：比如不同的具體的運算類對於加減乘除的不同方法進行了封裝，這樣使加減乘除運算之間的耦合度降低。
 *3 繼承：父類中定義變量，以及方法；子類去繼承父類，用父類的變量，重寫父類的方法，實現具體的運算。
 *4 多態：簡單工廠類中，通過傳遞的不同參數，去創建不同的對象
 
 
*/
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Operation operation = null;
        /*測試1*/
        operation = OperationFactory.createOperation("+");
        operation.numberA = 5;
        operation.numberB = 10;
        Double result = operation.getResult();
        System.out.println(
 
"result:"+result);
        /*測試2*/
        operation = OperationFactory.createOperation("/");
        operation.numberA = 15;
        operation.numberB = 3;
        Double result2 = operation.getResult();
        System.out.println("result:"+result2);
    }
}
/**
 * 1 內部維護兩個操作數，用於進行運算
 * 2 內部維護一個返回結果的方法，用於子類重寫,並返回子類特有的結果。
 * 3 這是一個父類。父類主要定義有哪些東西，具體如何操作，需要各個子類去實現。
 */
class Operation{
    public double numberA = 0;
    public double numberB = 0;
    public double getNumberA() {
        return numberA;
    }
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }
    public double getNumberB() {
        return numberB;
    }
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }
    
    public double getResult(){
        double result = 0d;
        return result;
    }
}
/**
 * 1 以下為具體的運算類，即加減乘除類。
 */
class OperationAdd extends Operation{
    public double getResult(){
        double result = 0d;
        result = numberA + numberB;
        return result;
    }
}
class OperationSub extends Operation{
    public double getResult(){
        double result = 0d;
        result = numberA - numberB;
        return result;
    }
}
class OperationMul extends Operation{
    public double getResult(){
        double result = 0d;
        result = numberA * numberB;
        return result;
    }
}
class OperationDiv extends Operation{
    public double getResult(){
        double result = 0d;
        if(numberB == 0){
            try {
                throw new Exception("除數為0");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else{
            result = numberA/numberB;
        }
        return result;
    }
}
/**
 * 1 以下為運算符工廠類，通過多態，生成不同的運算類。
 *
 */
class OperationFactory{
    public static Operation createOperation(String operate){
        Operation oper = null;
        switch (operate) {
        case "+":
            oper = new OperationAdd();
            break;
        case "-":
            oper = new OperationSub();
            break;
        case "*":
            oper = new OperationMul();
            break;
        case "/":
            oper = new OperationDiv();
            break;

        default:
            break;
        }
        return oper;
    }
}

如上demo的改進，改進運算操作的父類為一個抽象類，抽象類中維護兩個操作數，用於進行計算，維護一個方法，用於返回計算結果。

代碼如下：

package com.biao.factory.simplefactory.again;
/**
 * @改進：運算類更改為抽象類，抽象類中維護兩個變量，（就是操作數，用於進行運算），還有一個抽象方法，
 *         用於子類繼承重寫，返回不同的運算結果。
 */
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Operation oper;
        /*測試1*/
        oper = OperationFactory.createOperation("+");
        oper.NumberA = 1;
        oper.NumberB = 6;
        System.out.println(oper.getResult());
        /*測試2*/
        oper = OperationFactory.createOperation("/");
        oper.NumberA = 42;
        oper.NumberB = 6;
        System.out.println(oper.getResult());
    }

}

/*此類進行了改進*/
abstract class Operation{
    public double NumberA;
    public double NumberB;
    public abstract double getResult();
}

/*具體運算類*/
class OpetationAdd extends Operation{
    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return NumberA + NumberB;
    }
}
class OpetationSub extends Operation{
    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return NumberA - NumberB;
    }
}
class OpetationMul extends Operation{
    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return NumberA * NumberB;
    }
}
class OpetationDiv extends Operation{
    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        double result =0;
        if(NumberB == 0){
            try {
                throw new Exception("除數為0");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            result = NumberA/NumberB;
        }
        return result;
    }
}

/*運算工廠生成類*/
class OperationFactory{
    public static Operation createOperation(String operate){
        Operation oper = null;
        switch (operate) {
        case "+":
            oper = new OpetationAdd();
            break;
        case "-":
            oper = new OpetationSub();
            break;
        case "*":
            oper = new OpetationMul();
            break;
        case "/":
            oper = new OpetationDiv();
            break;
        default:
            break;
        }
        return oper;
    }
}

一（1）簡單工廠模式