设计模式——工厂模式

目录

前言：

简单工厂模式

创建运算类

创建继承于运算类的加法类和减法类

创建工厂类 

客户端调用

简单工厂总结：

工厂方法模式

创建工厂接口

创建加法工厂类

客户端代码

 工厂方法总结：

 抽象工厂

抽象工厂模式的优缺点：

前言：

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂模式一共分为三种 ：

简单工厂模式

工厂方法模式

抽象工厂模式

三种方法分别适用于不同的背景，大同小异。

在本篇文章中 ，我们通过创建计算器系统来进行代码演示。

简单工厂模式

创建运算类

public class Operation {
    private double a;
    private double b;

    public double getA() {
        return a;
    }

    public void setA(double a) {
        this.a = a;
    }

    public double getB() {
        return b;
    }

    public void setB(double b) {
        this.b = b;
    }
    public double getResult() {
        double res = 0.0;
        return res;
    }

}

在该类中 ， 包含一个计算机类最基本的属性 ： 参与运算的数字 ， 运算的结果方法。

创建继承于运算类的加法类和减法类

// 加法类
public class OperationAdd extends Operation{

    public double getResult() {
        double res = 0.0;
        res = getA() + getB();
        return res;
    }
}
// 减法类
public class OperationSub extends Operation{
    public double getResult(){
        double res = 0.0;
        res = getA() - getB();
        return res;
    }
}

重写父类的 getResult方法 ， 返回该所属运算的结果。

创建工厂类 

public class OperationFactory {
    public static Operation createOperation(String op) {
        Operation operation = null;
        switch (op) {
            case "+" :
                operation = new OperationAdd();
                break;
            case "-" :
                operation = new OperationSub();
                break;
        }
        return operation;
    }
}

在该类中 ， 通过调用 createOperation方法传入不同的运算参数 （例如：“+” 、 “-” 、 “*”），实例化不同的运算类。

客户端调用

public class Client {
    public static void main(String[] args) {
        Operation operation = OperationFactory.createOperation("-");
        operation.setA(10);
        operation.setB(100);
        System.out.println(operation.getResult());
    }
}

简单工厂总结：

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

对于客户端来说 ， 只需要把 “+” 传给工厂 ，工厂就直接给出想用的实例 ， 然后条用 getResult方法即可 。

缺点 ：每次想要添加一个操作 例如 ：根号运算 ， 就需要添加一个类 ， 并且修改工厂里面的代码，违背了 “开闭原则”。 故而引出另一种实现方式——工厂方法模式。

工厂方法模式

工厂方法模式（Factory Method） 定义一个用于创建对象的接口 ， 让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

 源自《大话设计模式 》 p71

根据 UML图 ， 发现与简单工厂所不同的是 ： 我们将工厂抽象化 ， 通过接口实现不同的工厂方法。

创建工厂接口

public interface Ifactory {
    Operation createFactory();
}

创建加法工厂类

public class addFactory implements Ifactory{
    @Override
    public Operation createFactory() {
        return new OperationAdd();
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        Ifactory addfactory = new addFactory();
        Operation operation = addfactory.createFactory();
        operation.setB(100);
        operation.setA(50);
        System.out.println(operation.getResult());

    }
}

 工厂方法总结：

1. 工厂方法避免了简单工厂在添加新方法时候会违背开闭原则的情况。

2. 根据依赖倒转原则 ， 把工厂类抽象出一个接口，这个接口只有一个方法 ， 就是创建抽象产品的方法，然后所有的要生产具体类的工厂，就去实现这个接口，这样，一个简单工厂模式的工厂类，编程一个工厂抽象接口和多个具体生成对象的工厂，我们要去添加一个 “开根号” 的操作，只需要增加此功能的运算类和响应的工厂类。

 抽象工厂

抽象工厂： 提供一个创建一系列相关或相互依赖对象的接口 ， 而无需指定它们具体的类。

这里与工厂方法主要的区别在于 ， 工厂方法中一次只能创建一个对象 ， 而且抽象工厂方法可以通过实现接口 ， 传入的不同的参数，构建不同的对象实例 ， 相当于 简单工厂和工厂方法 的结合

这个借用网上一段代码来演示：

public interface AbstractFactory {
    Pizza createPizza(String orderType);
    ···········
    //创建酱的方法
    ········
    //创建蔬菜的方法
    ········
}

public class BJFactory implements AbstractFactory {


    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~~~使用的是抽象工厂模式~~~");
        Pizza pizza = null;
        if (orderType.equals("chess")){
            pizza = new BJChessPizza();
        }else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
    //实现其他佐料方法
}

抽象工厂模式呢，相当于抽象了两层，一层是抽象层，另一层是实现抽象层的具体层

抽象工厂模式的优缺点：

1. 易于交换产品系列。

2. 具体的创建实例过程与客户端分离 ， 客户端通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离、解耦， 不会出现在客户代码中。