工厂模式的练习与使用。

构建者模式，单例模式经常用，但工厂模式理解模模糊糊的，在项目中碰到了，就顺便写个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();
    }
}