第三章：类创建型模式之工厂模式

1.什么是工厂模式？

工厂模式是一种创建型模式，具体属于类创建型模式，它提供了一种创建对象的最佳实现。在工厂模式中有一个专门的工厂类来负责实例化各种产品实例，而客户端代码通过工厂类对象来获得所需要的产品实例。工厂模式有三种实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式是工厂模式的基础形式，它通过一个简单的工厂类来实现所有的产品实例，根据传入的参数来决定实例化特定的产品实例。

工厂方法模式定义了一个用于创建实例的接口或抽象类，由实现它的具体工厂子类决定实例化的产品类型。

抽象工厂模式的核心是一个抽象工厂接口，该接口声明了一系列创建相关或相互依赖产品的方法，用于创建一系列相关或相互依赖的对象，而不需要指定他们具体的类。实现抽象工厂接口的具体工厂类负责创建相关或相互依赖的产品实例。客户端通过抽象的工厂接口进行交互，避免与具体产品产生直接依赖。

2.为什么要使用工厂模式？

1.给系统带了了较好的可扩展性和尽量少的修改。

2.使用工厂模式，可以避免大量的new操作。

3.通过传入不同的参数来创建不同的实例对象，可以替代条件分支。

3.使对象创建逻辑和使用逻辑之间解耦，让客户端只关注自身逻辑，增加代码可读性。

3.什么情况下可以使用工厂模式？

1.如果一个对象有复杂的创建逻辑，例如需要根据条件创建不同的对象，或创建对象需要很多步骤，工厂模式可以将创建逻辑封装起来，简化客户端代码。

2.如果客户端不需要知道创建对象的细节，可以使用工厂模式隐藏对象的创建细节，使客户端只关注自身逻辑。

3.如果系统需要很方便的引入新的产品或更改现有产品，工厂模式可以在不更改现有客户端代码的情况下实现。

4.如果系统需要创建一系列相关或相互依赖的对象，可以使用抽象工厂模式。

4.有哪些框架使用了工厂模式？

1.Spring框架中提供一个Bean工厂，用来管理Bean的创建和生命周期。

2.SLF4J日志门面实现了工厂方法模式来创建日志对象。它允许用户在项目部署时插入所需的日志框架。

5.怎么使用工厂模式？

工厂模式的核心元素包含以下几个：

1.抽象产品接口：定义了产品的接口，也就是某一类产品的共同操作，具体产品必须实现这些操作。

2.具体产品类：实现抽象产品接口，表示某一具体产品

3.抽象工厂接口：定义抽象工厂方法，须由具体工厂类实现，简单工厂模式可以没有抽象工厂接口

4.具体工厂类：实现抽象工厂接口，负责生产具体产品的实例，客户端通过工厂获得所需的具体产品。

5.1简单工厂模式实现demo

1.创建抽象产品类并定义产品可以执行操作

//定义抽象产品
public interface Shape {
    //定义产品可以执行的操作
    void draw();
}

2.创建具体产品类并实现抽象产品接口 

//定义具体产品类<矩形>并实现抽象产品
public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("绘制矩形图案");
    }
}

//定义具体产品类<三角形>并实现抽象产品
public class Triangle implements  Shape{
    @Override
    public void draw() {
        System.out.println("绘制三角形图案");
    }
}

//定义具体产品类<圆形>并实现抽象产品
public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("绘制圆形图案");
    }
}

3.创建工厂类，根据传入的参数创建不同的产品实

//创建工厂类，通过传入参数创建具体产品
public class ShapeFactory {
    
    public static Shape creator(String shapeType) {
        if("rectangle".equals(shapeType)) {
            return new Rectangle();
        } else if("triangle".equals(shapeType)) {
            return new Triangle();
        } else if("circle".equals(shapeType)) {
            return new Circle();
        }
        return null;
    }
}

模拟客户端使用代码如下：

public class Client {

    public static void main(String[] args) {
        //绘制一个圆形图案
        Shape shape = ShapeFactory.creator("circle");
        shape.draw();
        //绘制一个矩形图案
        shape = ShapeFactory.creator("rectangle");
        shape.draw();
        //绘制一个三角形图案
        shape = ShapeFactory.creator("triangle");
        shape.draw();
    }
}

测试结果如下图：

5.2工厂方法模式实现demo

1.创建抽象产品并定义客户共同操作

这块代码和简单工厂模式第一步相同，如需要请参考简单工厂模式第一步。

2.创建具体产品类并实现抽象产品接口

代码和简单工厂模式第二步相同，如需要请参考简单工厂模式第二步。

3.创建抽象产品接口，定义产品创建方法

//定义抽象<形状>工厂接口
public interface AbstractFactory {
    Shape creator();
}

4.创建具体工厂类，实现抽象产品接口，并决定生产的具体产品类型

//生产<矩形>产品的矩形工厂
public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape creator() {
        return new Rectangle();
    }
}

//生产<圆形>产品的圆形工厂
public class CircleFactory implements ShapeFactory {
    @Override
    public Shape creator() {
        return new Circle();
    }
}

//生产<三角形>产品的三角形工厂
public class TriangleFactory implements ShapeFactory {
    @Override
    public Shape creator() {
        return new Triangle();
    }
}

模拟客户端使用代码如下：

public class Client {

    public static void main(String[] args) {
        Shape shape;
        ShapeFactory shapeFactory;
        //绘制一个矩形图案
        shapeFactory = new RectangleFactory();
        shape = shapeFactory.creator();
        shape.draw();
        
        //绘制一个三角形图案
        shapeFactory = new TriangleFactory();
        shape = shapeFactory.creator();
        shape.draw();
        
        //绘制一个圆形图案
        shapeFactory = new CircleFactory();
        shape = shapeFactory.creator();
        shape.draw();
        
    }
}

运行结果如下：

5.3抽象工厂实现demo

1.创建一系列相关的抽象产品族

//抽象引擎产品
public interface Engine {
    void production();
}

//抽象外观产品
public interface Shell {
    void production();
}

//抽象轮子产品
public interface Wheel {
    void production();
}

2.创建具体产品类

//生产Benz引擎
public class BenzEngine implements Engine{
    @Override
    public void production() {
        System.out.println("开始生产Benz汽车引擎...");
    }
}

//生产Audi引擎
public class AudiEngine implements Engine {
    @Override
    public void production() {
        System.out.println("开始生产Audi汽车引擎...");
    }
}

//生产Benz外观
public class BenzShell implements Shell {
    @Override
    public void production() {
        System.out.println("开始生产Benz汽车外壳...");
    }
}

//生产Audi外观
public class AudiShell implements Shell {
    @Override
    public void production() {
        System.out.println("开始生产Audi汽车外壳...");
    }
}

//生产Benz轮子
public class BenzWheel implements Wheel{
    @Override
    public void production() {
        System.out.println("开始生产Benz汽车轮子...");
    }
}

//生产Audi轮子
public class AudiWheel implements Wheel {
    @Override
    public void production() {
        System.out.println("开始生产Audi汽车轮子...");
    }
}

3.创建抽象产品接口

//汽车生产抽象工厂
public interface AbstractCarFactory{
    //负责生产引擎
    Engine engine();
    //负责生产轮子
    Wheel wheel();
    //负责生产外观
    Shell shell();
}

4.创建具体工厂类

//Benz生产线
public class BenzCarFactory implements AbstractCarFactory {
    @Override
    public Engine engine() {
        return new BenzEngine();
    }

    @Override
    public Wheel wheel() {
        return new BenzWheel();
    }

    @Override
    public Shell shell() {
        return new BenzShell();
    }
}

//Audi生产线
public class AudiCarFactory implements AbstractCarFactory {
    @Override
    public Engine engine() {
        return new AudiEngine();
    }

    @Override
    public Wheel wheel() {
        return new AudiWheel();
    }

    @Override
    public Shell shell() {
        return new AudiShell();
    }
}

模拟汽车代工厂生产汽车代码如下：

//汽车生产代工厂
public class Client {

    public static void main(String[] args) {
        //奔驰生产线生产1台奔驰
        benzProductionLine(1);
        System.out.println();
        //奥迪生产线生产1台奥迪
        audiProductionLine(1);
        
    }
    
    private static void benzProductionLine(int task) {
        for(int i = 1; i<=task; i++) {
            System.out.println("开始生产第 " + i + " 台Benz");
            production(new BenzCarFactory());
        }
    }

    private static void audiProductionLine(int task) {
        for(int i = 1; i<=task; i++) {
            System.out.println("开始生产第 " + i + " 台Audi");
            production(new AudiCarFactory());
        }
    }

    private static void production(AbstractCarFactory abstractCarFactory) {
        abstractCarFactory.wheel().production();
        abstractCarFactory.engine().production();
        abstractCarFactory.shell().production();
    }
}

代码测试结果如下：

6.工厂模式符合哪些软件设计原则？

1.开放封闭原则

工厂模式允许在不修改现有代码的情况下，增加新的产品。如果要增加新产品，只需要实现工厂类即可，不需要修改现有的客户端代码。

2.依赖倒转原则

工厂模式使客户端只依赖于抽象的工厂接口，避免与具体产品产生依赖。这使得客户端与具体产品的实现细节解耦。