创建型模式 01 工厂模式

简单工厂模式

具体工厂类：

// 计算器简单工厂
public class OperationFactory {
    public static Operation create(String oper){
        Operation operation = null;
        switch (oper){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationMinus();
                break;
            default:
                System.out.println("输出有误");
        }
        return operation;
    }
}

抽象产品类：
抽象运算

public abstract class Operation {
    private double a;
    private double b;
    public void setA(double a) {
        this.a = a;
    }
    public void setB(double b) {
        this.b = b;
    }
    public double getA() {
        return a;
    }

    public double getB() {
        return b;
    }

    public double calculate()；
        
    
}

具体产品类：
加减法

public class OperationAdd extends Operation{
    @Override
    public double calculate() {
    	// 得到父类属性
        return getA()+getB();
    }
}

public class OperationMinus extends Operation{
    @Override
    public double calculate() {
    	// 得到父类的属性
        return getA()-getB();
    }
}

父类引用指向子类对象，由于子类中没有重写父类的getXxx，setXxx的方法，父类引用调用get，set时均是在操作父类的属性

判断在简单工厂内部，工厂类在每次 产品类增加具体产品时，仍要在内部新增case，明显违反开闭原则

工厂模式

在创建对象时，使用抽象工厂、原型、建造者的设计比使用工厂方法要更灵活，但它们也更加复杂，通常，设计是以使用工厂方法开始，当设计者发现需要更大的灵活性时，设计便会向其他创建型模式演化
工厂方法的实现并不能减少工作量，但是它能够在必须处理新情况时，避免使已经很复杂的代码更加复杂

把判断由工厂内部移到了客户端，遵守开闭原则
加入工厂接口以及对应的实例工厂
工厂接口

public interface IFactory {
    Operation product();
}

加法工厂

public class AddFactory implements IFactory {
    @Override
    public Operation product() {
        return new OperationAdd();
    }
}

减法工厂

public class MinusFactory implements IFactory {
    @Override
    public Operation product() {
        return new OperationMinus();
    }
}

测试

public class TestNormal {
    public static void main(String[] args) {
        IFactory iFactory = null;
        int i = 1;
        switch (2){
            case 1:
                iFactory = new AddFactory();
                break;
            case 2:
                iFactory = new MinusFactory();
                break;
        }
        Operation product = iFactory.product();
        product.setA(0.8);
        product.setB(2.0);
        double calculate = product.calculate();
        System.out.println(calculate);
    }
}