Java 设计模式之工厂方法模式

Java 设计模式之工厂方法模式

概述

• 工厂方法模式(Factory Method)：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
• 简单工厂模式：一个工厂类负责创建所有产品，集中管理产品对象的创建，违反开闭原则。
• 工厂方法模式：每个具体工厂类只负责创建一类产品，将产品对象的创建延迟到工厂子类，符合开闭原则。

UML

• Product：抽象产品类。
• ConcreteProduct：具体产品类。
• Factory：抽象工厂类。
• ConcreteFactory：具体工厂类。

代码实现

定义产品接口：

public interface IOperator {
    double calculate(double a, double b);
}

定义基础产品类：

public class Add implements IOperator {
    @Override
    public double calculate(double a, double b) {
        return a + b;
    }
}

public class Sub implements IOperator {
    @Override
    public double calculate(double a, double b) {
        return a - b;
    }
}

public class Mul implements IOperator {
    @Override
    public double calculate(double a, double b) {
        return a * b;
    }
}

public class Div implements IOperator {
    @Override
    public double calculate(double a, double b) {
        if (b == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        return a / b;
    }
}

定义高级产品类：

public class Pow implements IOperator {
    @Override
    public double calculate(double a, double b) {
        return Math.pow(a, b);
    }
}

定义工厂接口：

public interface IFactory {
    IOperator createOperator(String operationType);
}

定义基础工厂类：

public class BasicFactory implements IFactory {
    @Override
    public IOperator createOperator(String operationType) {
        IOperator operation = null;
        switch (operationType) {
            case "+":
                operation = new Add();
                break;
            case "-":
                operation = new Sub();
                break;
            case "*":
                operation = new Mul();
                break;
            case "/":
                operation = new Div();
                break;
        }
        return operation;
    }
}

定义高级工厂类：

public class AdvancedFactory implements IFactory {
    @Override
    public IOperator createOperator(String operationType) {
        IOperator operation = null;
        switch (operationType) {
            case "pow":
                operation = new Pow();
                break;
        }
        return operation;
    }
}

定义工厂管理类：

public class OperatorFactory {
    public static IOperator createOperator(String o) {
        IFactory factory;
        IOperator operator;
        switch (o) {
            case "+":
            case "-":
            case "*":
            case "/":
                factory = new BasicFactory();
                break;
            case "pow":
                factory = new AdvancedFactory();
                break;
            default:
                throw new IllegalArgumentException("未知操作符");
        }
        operator = factory.createOperator(o);
        return operator;
    }
}

使用：

public class Client {
    public static void main(String[] args) {
        double resultA = OperatorFactory.createOperator("+").calculate(10, 20);
        System.out.println("两数相加：" + resultA);
        double resultB = OperatorFactory.createOperator("*").calculate(2, 3);
        System.out.println("两数相乘：" + resultB);
        double subResult = OperatorFactory.createOperator("-").calculate(resultA, resultB);
        System.out.println("两数相减：" + subResult);
        double powResult = OperatorFactory.createOperator("pow").calculate(subResult, 2);
        System.out.println("两数次方：" + powResult);
    }
}

输出：

两数相加：30.0
两数相乘：6.0
两数相减：24.0
两数次方：576.0