工厂模式 (Factory Method)

目录

基本介绍

分类

简单工厂模式

工厂方法模式

抽象工厂模式

基本介绍

概述：定义一个用于创建产品的接口，由子类决定生产什么产品。

作用：实现了创建者和调用者的分离。

本质：

• 实例化对象不使用new，用工厂方法代替
• 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

分类

简单工厂模式

概述：用来生产统一等级结构中的任意产品 (对于增加新的产品，需要扩展已有代码)。

说明：虽然某种程度上不符合设计原则，但实际使用最多。

结构图：

 

代码实现：

//运算类
public class Operation {
    private double numberA = 0;
    private double numberB = 0;

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

    public double getResult(){
        double result = 0;
        return result;
    }
}

//加减乘除类
public class OperationAdd extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() + getNumberB();
        return result;
    }
}

//减
class OperationSub extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() - getNumberB();
        return result;
    }
}

//乘
class OperationMul extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() * getNumberB();
        return result;
    }
}

//除
class OperationDiv extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        if (getNumberB() == 0){
            System.out.println("除数不能为0");
        }
        result = getNumberA() / getNumberB();
        return result;
    }
}

//简单运算工厂类
public class OperationFactory {
    public static Operation createOperation(String operation){
        Operation oper = null;
        switch (operation){
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

//测试类
public class OperationTest {
    public static void main(String[] args) {
        Operation oper;
        oper = OperationFactory.createOperation("+");
        oper.setNumberA(1);
        oper.setNumberB(2);
        double result = oper.getResult();
        System.out.println(result);
    }
}

//运行结果：3.0

工厂方法模式

概述：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

说明：不修改已有类的前提下，通过增加新的工厂类实现扩展。

结构图：

具体实现：

结构图

//工厂接口
public interface IFactory {
    Operation CreateOperation();
}

//加减乘除工厂类
public class AddFactory implements IFactory {
    @Override
    public Operation CreateOperation() {
        return new OperationAdd();
    }
}

//减
class SubFactory implements IFactory{
    @Override
    public Operation CreateOperation() {
        return new OperationSub();
    }
}

//乘
class MulFactory implements IFactory{
    @Override
    public Operation CreateOperation() {
        return new OperationMul();
    }
}

//除
class DivFactory implements IFactory{
    @Override
    public Operation CreateOperation() {
        return new OperationDiv();
    }
}

//测试类
public class OperationTest {
    //工厂方法
    public static void main(String[] args) {
        IFactory operFactory = new AddFactory();
        Operation oper = operFactory.CreateOperation();
        oper.setNumberA(1);
        oper.setNumberB(2);
        double result = oper.getResult();
        System.out.println(result);
    }
}

//运行结果：3.0

注意：此模式下的具体实现也要使用上述的 Operation 类和具体的加减乘除类，虽然代码量增多了，但是扩展功能时不用修改原来的代码，满足了开闭原则。

抽象工厂模式

概述：围绕一个超级工厂创建其他工厂，改超级工厂又称为其他工厂的工厂。

说明：不可以增加产品，可以增加产品族，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。

单独介绍！

---