设计模式-工厂模式

简介

工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：

简单工厂模式(Simple Factory)
工厂方法模式(Factory Method)
抽象工厂模式(Abstract Factory)

简单工厂模式

简单工厂模式属于类的创建型模式，又叫静态工厂方法模式。通过专门定义一个工厂类来负责创建其他类的实例，被创建的实例通常都具有共同的父类
简单工厂模式包含三种角色：

工厂角色（Creator）-负责实现创建所有实例的内部逻辑
抽象角色（Product）-描述所有实例所共有的公共接口，可以是父类接口或抽象类
具体产品角色（Concrete Product）-创建的具体的实例对象

/**
 * 计算器抽象类
 */
public abstract class Operator {

    private double numberA = 0.0;
    private double numberB = 0.0;

    protected abstract double getResult() throws Exception;

    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;
    }
}

/**
 * 加法类
 * Created by lixiuyu
 */
public class AddOperator extends Operator {

    protected double getResult() {
        return getNumberA() + getNumberB();
    }
}

/**
 * 减法类
 * Created by lixiuyu.
 */
public class SubOperation extends Operator {

    @Override
    protected double getResult() {
        return getNumberA() - getNumberB();
    }
}

/**
 * 乘法类
 * Created by lixiuyu.
 */
public class MulOperation extends Operator {
    @Override
    protected double getResult() {
        return getNumberA() * getNumberB();
    }
}

/**
 * 除法类
 * Created by lixiuyu.
 */
public class DivOperation extends Operator {
    @Override
    protected double getResult() throws Exception {
        if(getNumberB() == 0.0){
            throw new Exception("除数不能为0");
        }else{
            return getNumberA() / getNumberB();
        }
    }
}

/**
 * 工厂类
 * Created by lixiuyu.
 */
public class OperatorFactory {
    public static Operator createOperator(String operation) {
        Operator operator = null;
        switch (operation) {
            case "+":
                operator = new AddOperator();
                break;
            case "-":
                operator = new SubOperation();
                break;
            case "*":
                operator = new MulOperation();
                break;
            case "/":
                operator = new DivOperation();
                break;
        }
        return operator;
    }

    public static void main(String[] args) {
        Operator operator = OperatorFactory.createOperator("+");
        operator.setNumberA(10);
        operator.setNumberB(5);
        try {
            System.out.println(operator.getResult());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

工厂方法模式

/**
 * 工厂方法模式
 */
public class OperatorFactory1 {
    public static Operator createAddOperator() {
        return new AddOperator();
    }

    public static Operator createSubOperator() {
        return new SubOperation();
    }

    public static Operator createMulOperator() {
        return new MulOperation();
    }

    public static Operator createDivOperator() {
        return new DivOperation();
    }

    public static void main(String[] args) {
        Operator operator = OperatorFactory1.createAddOperator();
        operator.setNumberA(10);
        operator.setNumberB(5);
        try {
            System.out.println(operator.getResult());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

抽象工厂模式

抽象工厂模式就是将对象工厂的创建抽象到一个接口中。抽象工厂类不在负责产品的创建，仅仅负责定义具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得可以再不修改具体工厂角色的情况下引进新的产品
一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码，符合开闭原则。
抽象工厂模式角色及职责：

抽象工厂角色（Creator）-这是抽象工厂模式的核心，任何工厂类必须实现这个接口
具体工厂角色（Concrete Creator）-它是抽象工厂的一个实现，负责实例化产品对象 3.抽象角色（Product）-抽象工厂模式所创建的所有对象的父类，描述所有实例所共有的公共接口 3.具体产品角色（Concrete Product）-抽象工厂模式所创建的具体的实例对象

/**
 * 所有类需要实现的接口
 */
public interface OperatorFactory2 {
    public Operator createOperator();
}

/**
 * 当我们需要增加一种运算时，只需要增加一个具体运算及具体工厂类，原有的具体工厂类不需要做任何改动
 */
public class AddOperatorFactory implements OperatorFactory2 {
    @Override
    public Operator createOperator() {
        return new AddOperator();
    }

    public static void main(String[] args) {
        OperatorFactory2 factory = new AddOperatorFactory();
        Operator operator = factory.createOperator();
        operator.setNumberA(10.0);
        operator.setNumberB(5.0);
        try {
            System.out.println(operator.getResult());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/**
 * 当我们需要增加一种运算时，只需要增加一个具体运算及具体工厂类，原有的具体工厂类不需要做任何改动
 */

https://www.cnblogs.com/lixiuyu/p/5900597.html