工廠模式的練習與使用。

構建者模式，單例模式經常用，但工廠模式理解模模糊糊的，在項目中碰到了，就順便寫個demo熟悉練習下，熟悉掌握。

例子是一個加減乘除的方式。

先看簡單工廠模式：

public interface IOperation {

    double getResult(double numberA, double numberB);

    void printInput();
}

先定義一個操作的接口。下面四個不同實現。

public class AddOperationImpl implements IOperation {
    private double mNumberA;
    private double mNumberB;
    @Override
    public double getResult(double numberA, double numberB) {
        this.mNumberA = numberA;
        this.mNumberB = numberB;
        return numberA + numberB;
    }

    @Override
    public void printInput() {
        System.out.println(" print numberA = " + mNumberA);
        System.out.println(" print numberB = " + mNumberB);
        System.out.println(" current Operation is Addition ");
    }
}

public class SubtractOperationImpl implements IOperation {
    private double mNumberA;
    private double mNumberB;
    @Override
    public double getResult(double numberA, double numberB) {
        this.mNumberA = numberA;
        this.mNumberB = numberB;
        return numberA - numberB;
    }

    @Override
    public void printInput() {
        System.out.println(" print numberA = "+mNumberA);
        System.out.println(" print numberB = "+mNumberB);
        System.out.println(" current Operation is Subtraction ");
    }
}

public class MultipleOperationImpl implements IOperation {
    private double mNumberA;
    private double mNumberB;
    @Override
    public double getResult(double numberA, double numberB) {
        this.mNumberA = numberA;
        this.mNumberB = numberB;
        return numberA * numberB;
    }

    @Override
    public void printInput() {
        System.out.println(" print numberA = "+mNumberA);
        System.out.println(" print numberB = "+mNumberB);
        System.out.println(" current Operation is Multiplication ");
    }
}

public class DivideOperationImpl implements IOperation {
    private double mNumberA;
    private double mNumberB;
    @Override
    public double getResult(double numberA, double numberB){
        if (numberB == 0) throw new IllegalArgumentException("被除數不能爲0");
        this.mNumberA = numberA;
        this.mNumberB = numberB;
        return numberA/numberB;
    }

    @Override
    public void printInput() {
        System.out.println(" print numberA = "+mNumberA);
        System.out.println(" print numberB = "+mNumberB);
        System.out.println(" current Operation is Division ");
    }
}

public class SimpleFactory {
    public enum OpENUM {
        ADD, SUBSTRACT,
        MULTIPLE, DIVIDE
    }

    public static IOperation createOperation(OpENUM type) {
        IOperation operation;
        switch (type) {
            case ADD:
                operation = new AddOperationImpl();
                break;
            case SUBSTRACT:
                operation = new SubtractOperationImpl();
                break;
            case MULTIPLE:
                operation = new MultipleOperationImpl();
                break;
            case DIVIDE:
                operation = new DivideOperationImpl();
                break;
            default:
                throw new UnsupportedOperationException("parameter error, unsupport current parameters");
        }
        return operation;
    }
}

最後一個是簡單工廠模式，通過枚舉進行測試。

抽象工廠模式相當於在簡單工廠模式上進一步解耦：

先定義一個工廠接口，然後對應不同的實現。

public interface IOperationFactory {
     IOperation createOperation();
}

public class AddFactory implements IOperationFactory {

    @Override
    public IOperation createOperation() {
        return new AddOperationImpl();
    }
}

public class SubstractFactory implements IOperationFactory {
    @Override
    public IOperation createOperation() {
        return new SubtractOperationImpl();
    }
}

最後看下測試類以及測試結果：

public class LearningTest {

    public static void main(String[] args) {
        // SimpleFactory
        IOperation operation = SimpleFactory.createOperation(SimpleFactory.OpENUM.ADD);
        double result = operation.getResult(1, 2);
        System.out.println(" result = " + result);
        // abstract Factory
        IOperationFactory addFactory = new AddFactory();
        IOperation addFactoryOperation = addFactory.createOperation();
        double result1 = addFactoryOperation.getResult(3, 4);
        System.out.println(" \n result = " + result1);
        addFactoryOperation.printInput();

        IOperationFactory substractFactory = new SubstractFactory();
        IOperation substractFactoryOperation = substractFactory.createOperation();
        double result2 = substractFactoryOperation.getResult(3, 4);
        System.out.println(" /n result = " + result2);
        substractFactoryOperation.printInput();
    }
}