Java 设计模式之简单工厂模式和工厂方法模式

简单工厂模式

以计算器为例，实现客户的需求

运算类：

public interface Operator {
    double result(double num1,double number2);
}

加法：

public class AddOperator implements Operator {
    @Override
    public double result(double num1, double num2) {
        return num1 + num2;
    }
}

减法：

public class SubOperator implements Operator {
    @Override
    public double result(double num1, double num2) {
        return num1 - num2;
    }
}

除法:

public class SubOperator implements Operator {
    @Override
    public double result(double num1, double num2) {
        return num1 - num2;
    }
}

乘法：

public class MulOperator implements Operator {
    @Override
    public double result(double num1, double number2) {
        return num1 * number2;
    }
}

工厂类：

public class SimpleFactory {
    public static Operator creatOperator(String operate){
        Operator operator = null;
        switch (operate){
            case "+":
                operator= new AddOperator();
                break;
            case "-":
                operator = new SubOperator();
                break;
            case "*":
                operator = new MulOperator();
                break;
            case "/":
                operator = new DivOperator();
                break;
            default:
                System.out.println("输入错误");
                break;
        }
        return operator;
    }
}

客户端：

public class TestOperator {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入第一个数：");
        double num1 = input.nextDouble();
        System.out.println("请输入第二个数：");
        double num2 = input.nextDouble();
        System.out.println("请输入操作符：");
        String operator = input.next();
        Operator operator1 = SimpleFactory.creatOperator(operator);
        double num3 = operator1.result(num1, num2);
        System.out.println("结果为："+ num3);
    }

}

工厂方法模式

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

工厂接口：

public interface OperatorFactory {
    Operator CreateOperator();
}

加法工厂：

public class AddFactory implements OperatorFactory {
    @Override
    public Operator CreateOperator() {
        return new AddOperator();
    }
}

乘法工厂：

public class MulFactory implements OperatorFactory {
    @Override
    public Operator CreateOperator() {
        return new MulOperator();
    }
}

…减法 除法都是这样
客户端：

public class Client {
    public static void main(String[] args) {
       //实现加法
	OperatorFactory operatorFactory = new AddFactory();
	Operator addOperator = operatorFactory.CreateOperator();
	double num1 = 16d;
	double num2 = 19d;
	double result = addOperator.result(num1, num2);
	System.out.println("结果是："+result);

	//如果实现减法，只需把 OperatorFactory operatorFactory = new AddFactory();修改成
	// OperatorFactory operatorFactory = new SubFactory();
    }
}

区别

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。
工厂方法模式：

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类的，而现在是修改客户端。两者都集中封装了对象的创建。