工厂模式

作者: PC_Repair | 来源:发表于2020-06-11 10:12 被阅读0次

常用设计模式
工厂模式
工厂模式
找女朋友之简单工厂模式，工厂模式，抽象工厂模式
【设计模式】- 工厂模式
工厂模式
Java设计模式——工厂模式
设计模式-3种工厂模式
设计模式-工厂模式
第一章2.0工厂- 基础类准备

工厂模式

一、简单工厂模式

简单工厂模式更多的时候是一种编程习惯，并不算是一种设计模式。

定义：

定义一个工厂类，根据传入的参数返回不同的实例，被创建的实例具有共同的父类或接口。

适用场景：

其实由定义也大概能推测出其使用场景，首先由于只有一个工厂类，所以工厂类中创建的对象不能太多，否则工厂类的业务逻辑就太复杂了，其次由于工厂类封装了对象的创建过程，所以客户端应该不关心对象的创建。总结一下适用场景：

需要创建的对象较少。
客户端不关心对象的创建过程。

实例：

创建一个可以绘制不同形状的绘图工具，可以绘制圆形，正方形，三角形，每个图形都会有一个draw()方法用于绘图，不看代码先考虑一下如何通过该模式设计完成此功能。

由题可知圆形，正方形，三角形都属于一种图形，并且都具有draw方法，所以首先可以定义一个接口或者抽象类，作为这三个图像的公共父类，并在其中声明一个公共的draw方法。

public interface Shape {
    void draw();
}

这里定义成抽象类也是可以的，只不过接口是更高一级的抽象，所以习惯定义成接口，而且接口支持多实现，方便以后扩展。

下面就是编写具体的图形，每种图形都实现Shape 接口。

圆形

public class CircleShape implements Shape {
    public CircleShape() {
        System.out.println("CircleShape: created");
    }

    @Override
    public void draw() {
        System.out.println("draw: CircleShape");
    }
}

正方形

public class RectShape implements Shape {
    public RectShape() {
       System.out.println("RectShape: created");
    }

    @Override
    public void draw() {
       System.out.println("draw: RectShape");
    }
}

三角形

public class TriangleShape implements Shape {
    public TriangleShape() {
        System.out.println("TriangleShape: created");
    }

    @Override
    public void draw() {
        System.out.println("draw: TriangleShape");
    }
}

工厂类的具体实现

 public class ShapeFactory {
     public static final String TAG = "ShapeFactory";
     public static Shape getShape(String type) {
         Shape shape = null;
         if (type.equalsIgnoreCase("circle")) {
             shape = new CircleShape();
         } else if (type.equalsIgnoreCase("rect")) {
             shape = new RectShape();
         } else if (type.equalsIgnoreCase("triangle")) {
             shape = new TriangleShape();
         }
         return shape;
     }
 }

在这个工厂类中通过传入不同的type可以new不同的形状，返回结果为Shape 类型，这个就是简单工厂核心的地方了。

客户端使用：

//画圆形
Shape shape = ShapeFactory.getShape("circle");
shape.draw();
//画正方形
Shape shape= ShapeFactory.getShape("rect");
shape.draw();
//画三角形
Shape shape= ShapeFactory.getShape("triangle");
shape.draw();

只通过给 Shape Factory 传入不同的参数就实现了各种形状的绘制，以上就是简单工厂方式。

二、工厂方法模式

工厂方法模式是简单工厂的仅一步深化，在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。也就是说每个对象都有一个与之对应的工厂。

定义：

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

实例：

现在需要设计一个这样的图片加载类，它具有多个图片加载器，用来加载JPG、PNG、GIF格式的图片，每个加载器都有一个read()方法，用于读取图片。下面我们完成这个图片加载类。

首先完成图片加载器的设计，编写一个加载器的公共接口。

public interface Reader {
    void read();
}
// Reader里面只有一个read()方法，然后完成各个图片加载器的代码。

JPG图片加载器

public class JpgReader implements Reader {
    @Override
    public void read() {
        System.out.print("read jpg");
    }
}

PNG图片加载器

public class PngReader implements Reader {
    @Override
    public void read() {
        System.out.print("read png");
    }
}

GIF图片加载器

public class GifReader implements Reader {
    @Override
    public void read() {
        System.out.print("read gif");
    }
}

现在我们按照定义所说定义一个抽象的工厂接口 ReaderFactory。

public interface ReaderFactory {
    Reader getReader();
}

里面有一个getReader()方法返回我们的Reader 类，接下来我们把上面定义好的每个图片加载器都提供一个工厂类，这些工厂类实现了ReaderFactory 。

JPA加载器工厂

public class JpgReaderFactory implements ReaderFactory {
    @Override
    public Reader getReader() {
        return new JpgReader();
    }
}

PNG加载器工厂

public class PngReaderFactory implements ReaderFactory {
    @Override
    public Reader getReader() {
        return new PngReader();
    }
}

GIF加载器工厂

public class GifReaderFactory implements ReaderFactory {
    @Override
    public Reader getReader() {
        return new GifReader();
    }
}

在每个工厂类中我们都通过复写的getReader（）方法返回各自的图片加载器对象。

客户端使用：

//读取JPG
ReaderFactory factory = new JpgReaderFactory();
Reader reader = factory.getReader();
reader.read();
//读取PNG
ReaderFactory factory = new PngReaderFactory();
Reader reader = factory.getReader();
reader.read();
//读取GIF
ReaderFactory factory = new GifReaderFactory();
Reader reader = factory.getReader();
reader.read();

和简单工厂对比，最根本的区别在于，简单工厂只有一个统一的工厂类，而工厂方法是针对每个要创建的对象都会提供一个工厂类，这些工厂类都实现了一个工厂基类（本例中的ReaderFactory ）。下面总结一下工厂方法的适用场景。

适用场景：

客户端不需要知道它所创建的对象的类，例子中我们不知道每个图片加载器具体叫什么名字，只知道创建它的工厂名就完成了创建过程。
客户端可以通过子类来指定创建对应的对象。

三、抽象工厂模式

这个模式最不好理解，而且在实际应用中局限性也蛮大的，因为这个模式并不符合开闭原则。实际开发还需要做好权衡。

抽象工厂模式是工厂方法的仅一步深化，在这个模式中的工厂类不单单可以创建一个对象，而是可以创建一组对象。这是和工厂方法最大的不同点。

定义：

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。（在抽象工厂模式中，每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的对象）

抽象工厂和工厂方法一样可以划分为4大部分：

AbstractFactory（抽象工厂）：声明了一组用于创建对象的方法，注意是一组。
ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建对象的方法，生成一组具体对象。
AbstractProduct（抽象产品）：它为每种对象声明接口，在其中声明了对象所具有的业务方法。
ConcreteProduct（具体产品）：它定义具体工厂生成的具体对象。

实例：

现在需要做一款跨平台的游戏，需要兼容Android，IOS，WP三个移动操作系统，该游戏针对每个系统都设计了一套操作控制器（OperationController）和界面控制器（UIController），下面通过抽闲工厂方式完成这款游戏的架构设计。

由题可知，游戏里边的各个平台的 UIController 和 OperationController 应该是我们最终生产的具体产品。所以新建两个抽象产品接口。

抽象控制器

public interface OperationController {
    void control();
}

抽象界面控制器

public interface UIController {
    void display();
}

然后完成各个系统平台的具体操作控制器和界面控制器。

Android

public class AndroidOperationController implements OperationController {
    @Override
    public void control() {
        System.out.println("AndroidOperationController");
    }
}

public class AndroidUIController implements UIController {
    @Override
    public void display() {
        System.out.println("AndroidInterfaceController");
    }
}

public class IosOperationController implements OperationController {
    @Override
    public void control() {
        System.out.println("IosOperationController");
    }
}

public class IosUIController implements UIController {
    @Override
    public void display() {
        System.out.println("IosInterfaceController");
    }
}

public class WpOperationController implements OperationController {
    @Override
    public void control() {
        System.out.println("WpOperationController");
    }
}
public class WpUIController implements UIController {
    @Override
    public void display() {
        System.out.println("WpInterfaceController");
    }
}

下面定义一个抽象工厂，该工厂需要可以创建 OperationController 和 UIController。

public interface SystemFactory {
    public OperationController createOperationController();
    public UIController createInterfaceController();
}

在各平台具体的工厂类中完成操作控制器和界面控制器的创建过程。

Android

public class AndroidFactory implements SystemFactory {
    @Override
    public OperationController createOperationController() {
        return new AndroidOperationController();
    }

    @Override
    public UIController createInterfaceController() {
        return new AndroidUIController();
    }
}

public class IosFactory implements SystemFactory {
    @Override
    public OperationController createOperationController() {
        return new IosOperationController();
    }

    @Override
    public UIController createInterfaceController() {
        return new IosUIController();
    }
}

public class WpFactory implements SystemFactory {
    @Override
    public OperationController createOperationController() {
        return new WpOperationController();
    }

    @Override
    public UIController createInterfaceController() {
        return new WpUIController();
    }
}

客户端调用：

SystemFactory mFactory;
UIController interfaceController;
OperationController operationController;

//Android
mFactory = new AndroidFactory();
//IOS
mFactory = new IosFactory();
//WP
mFactory = new WpFactory();

interfaceController = mFactory.createInterfaceController();
operationController = mFactory.createOperationController();
interfaceController.display();
operationController.control();

针对不同平台只通过创建不同的工厂对象就完成了操作和UI控制器的创建。可以对比一下，如果这个游戏使用工厂方法模式搭建需要创建多少个工厂类呢？下面总结一下抽象工厂的适用场景。

适用场景：