设计模式-工厂方法模式的原理和实现

1）基本原理

在这个模式中，工厂和产品类往往可以一一对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。该模式中包含的角色及其职责。

• 抽象工厂（Creator）角色：工厂方法模式的核心，与应用程序无关。任何在模式中创建对象的工厂必须实现这个接口。
• 具体工厂(Concerete Creator)角色：这个实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
• 抽象产品（Product）角色：工厂方法模式所创建的对象的父类型，也就是产品对象的共同父类或共同拥有的接口。
• 具体产品（Concerte Product）角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，他们之间往往一一对应。

2)优点

• 客户端不负责对象的创建，而且由专门的工厂类完成；
• 客户端只负责对象的调用，实现了创建和调用的分离，降低了客户端代码的难度；
• 若增加和减少产品子类，不需要修改工厂类，只增加产品子类和工厂子类，符合开闭原则。即使产品子类过多，不会导致工厂类的庞大，利于后期维护；

3)缺点

• 需要额外的代码编写，增加了工作量；

4)适用情况

• 所有的产品子类都有同一个父类（或接口），属于同一个产品系列产品子类比较多的，创建操作比较复杂；

抽象工厂（Creator）角色

public abstract class Calculator {

    protected int num1;//运算数1

    protected int num2;//运算数1

    //生成有参无参构造方法，getset方法
    public int getNum1() {
        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }

    public Calculator(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }
    public Calculator() {}

    /**
     * 不同的运算，运算规则不同
     * @return
     */
    public abstract int calc();

}

具体工厂(Concerete Creator)角色

public class AddCalculator extends Calculator {
    public AddCalculator(int num1, int num2) {
        super(num1, num2);
    }

    public AddCalculator() {
    }

    public int calc() {
        return num1+num2;
    }
}

class SubtractCalculator extends Calculator {
    public SubtractCalculator(int num1, int num2) {
        super(num1, num2);
    }

    public SubtractCalculator() {
    }

    public int calc() {
        return num1-num2;
    }
}

class MultractCalculator extends Calculator {
    public MultractCalculator(int num1, int num2) {
        super(num1, num2);
    }

    public MultractCalculator() {
    }

    public int calc() {
        if(num2!=0){
            return num1*num2;
        }else{
            throw new RuntimeException("除数不能是0");
        }
    }
}

class DivideCalculator extends Calculator {
    public DivideCalculator(int num1, int num2) {
        super(num1, num2);
    }

    public DivideCalculator() {
    }

    public int calc() {
        return num1/num2;
    }
}

抽象产品（Product）角色

public interface CalcFactory {
    /**
     * 创建运算对象
     * @return
     */
    public Calculator getCalc();

}

具体产品（Concerte Product）角色

/**
 * 添加工厂
 */
public class AddFactory implements CalcFactory{

    public Calculator getCalc() {
        return new AddCalculator();
    }
}
/**
 * 减去工厂
 */
class SubtractFactory implements CalcFactory{

    public Calculator getCalc() {
        return new SubtractCalculator();
    }
}
/**
 * 除法工厂
 */
class DivideFactory implements CalcFactory{

    public Calculator getCalc() {
        return new DivideCalculator();
    }
}
/**
 * 乘法工厂
 */
class MultractFactory implements CalcFactory{

    public Calculator getCalc() {
        return new MultractCalculator();
    }
}

简单测试

public class Test {

    //创建工厂
    static CalcFactory factory = new AddFactory();

    public static void main(String[] args) {

        //从工厂中直接获取产品
        Calculator calc = factory.getCalc();
        calc.setNum1(1);
        calc.setNum2(2);

        //产品的调用
        int calc1 = calc.calc();
        System.out.println(calc1);
    }
}

这里还有两种工厂模式大家有时间可以自己去拓展：

抽象工厂模式

构建者模式

三连就是对我最大的支持！！！

技术的升级迭代只是为了淘汰那些不学习的人！！！