工厂模式（Factory Pattern）

落日映苍穹つ 2024-03-27 17:29 201阅读 0赞

### 1.什么是工厂模式 ###

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

### 2.工厂模式的作用 ###

实现创建者和调用者的分离

### 3.工厂模式的分类 ###

*  简单工厂模式
 *  工厂方法模式
 *  抽象工厂模式

### 4.工厂模式的优缺点 ###

**优点：**

1.  一个调用者想创建一个对象，只要知道其名称就可以了。
2.  扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3.  屏蔽产品的具体实现，调用者只关心产品的接口。

**缺点：**

1、每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

![af74b9c4447b4b129cf4418e4139997d.png][]

![2b52a4f98e7541d7878bd054c5b37141.png][]

**简单工厂模式** ：

创建  maven  项目  factory

在项目路径下创建接口  cn.xs.simple.Car  ，作为汽车的抽象

public interface Car {
    /**
    * 车的名字
    */
    void name();
    }

创建两个汽车类，cn.xs .simple.Wuling ， cn.xs .simple.Tesla

public class Wuling implements Car {
    /**
    * 车的名字
    */
    public void name() {
    System.out.println("五菱宏光");
    }
    }
    package cn.baisee.simple;
    /**
    * @Description: Tesla
    * @Author: 喝热水治百病
    * @CreateDate: 2021/3/9 14:05
    * @UpdateUser: 喝热水治百病
    * @UpdateDate: 2021/3/9 14:05
    * @UpdateRemark: 修改内容
    * @Version: 1.0
    */
    public class Tesla implements Car {
    /**
    * 车的名字
    */
    public void name() {
    System.out.println("特斯拉");
    }
    }

新建消费者测试类：  cn.xs.simple.Consumer

public class Consumer {
    /**
    * 测试方法
    *
    * @param args
    */
    public static void main(String[] args) {
    // 买一辆五菱宏光
    Car wuling = new Wuling();
    // 买一辆特斯拉
    Car tesla = new Tesla();
    wuling.name();
    tesla.name();
    }
    }

运行  main  方法

根据工厂模式的特点，实例化对象不应该直接  new  ，我们创建一个车工厂

cn.xs.simple.CarFactory  的实现帮我们完成  new  的动作，代码如下：

public class CarFactory {
    /**
    * 封装生产车的细节
    *
    * @param name
    * @return
    */
    public static Car getCar(String name) {
    if ("五菱宏光".equals(name)) {
    return new Wuling();
    } else if ("特斯拉".equals(name)) {
    return new Tesla();
    }
    return null;
    }
    }

测试：

/**
    * 测试方法
    *
    * @param args
    */
    public static void main(String[] args) {
    // 买一辆五菱宏光
    // Car wuling = new Wuling();
    // 买一辆特斯拉
    // Car tesla = new Tesla();
    // 1. 简单工程模式（静态工厂模式）
    Car wuling = CarFactory.getCar("五菱宏光");
    Car tesla = CarFactory.getCar("特斯拉");
    wuling.name();
    tesla.name();
    }

简单工厂模式又叫静态工厂模式的弊端，想要再增加一个产品，必须要修改已有代码

![d0c8bed6f48a4025bfa119bd793eaafa.png][]

**工厂方法模式** ：

创建一个车工厂接口  cn.xs.method.CarFactory  ，代码如下：

public interface CarFactory {
    /**
    * 抽象的获取车的方法
    *
    * @return
    */
    Car getCar();
    }

创建五菱宏光车工厂  cn.baisee.method.WulingFactory  和特斯拉车工厂

cn.xs.method.TeslaFactory  ，实现车工厂接口

public class WulingFactory implements CarFactory {
    /**
    * 生产五菱宏光汽车
    *
    * @return
    */
    public Car getCar() {
    return new Wuling();
    }
    }
    package cn.baisee.method;
    import cn.baisee.simple.Car;
    import cn.baisee.simple.Tesla;
    /**
    * @Description: Tesla 工厂
    * @Author: 喝热水治百病
    * @CreateDate: 2021/3/9 14:58
    * @UpdateUser: 喝热水治百病
    * @UpdateDate: 2021/3/9 14:58
    * @UpdateRemark: 修改内容
    * @Version: 1.0
    */
    public class TeslaFactory implements CarFactory {
    /**
    * 生产特斯拉汽车
    *
    * @return
    */
    public Car getCar() {
    return new Tesla();
    }
    }

测试：

/**
    * 测试方法
    *
    * @param args
    */
    public static void main(String[] args) {
    // 买一辆五菱宏光
    // Car wuling = new Wuling();
    // 买一辆特斯拉
    // Car tesla = new Tesla();
    // 1. 简单工程模式（静态工厂模式）
    // Car wuling = CarFactory.getCar("五菱宏光");
    // Car tesla = CarFactory.getCar("特斯拉");
    // 2. 工厂方法模式
    Car wuling = new WulingFactory().getCar();
    Car tesla = new TeslaFactory().getCar();
    wuling.name();
    tesla.name();
    }

工厂方法模式将一开始直接消费者来生产汽车，创建车可能会有很多的细节等等，现在我将这些细节封装到每一种车工厂中，消费者要买车，直接找工厂生产即可，不用再自己来生产汽车，而且扩展也很方便,比如添加一个产品大众，创建大众汽车 cn.xs.method.Dazhong ：

public class Dazhong implements Car {
    /**
    * 车的名字
    */
    public void name() {
    System.out.println("大众");
    }
    }

创建大众汽车工厂  cn.xs.method.DazhongFactory  ：

public class DazhongFactory implements CarFactory {
    /**
    * 生产大众汽车
    *
    * @return
    */
    public Car getCar() {
    return new Dazhong();
    }
    }

测试代码只需添加：

// 2. 工厂方法模式
    Car wuling = new WulingFactory().getCar();
    Car tesla = new TeslaFactory().getCar();
    // 添加一个大众汽车即可
    Car dazhong = new DazhongFactory().getCar();
    wuling.name();
    tesla.name();
    dazhong.name();

![363f7860b1884d97aaab455b4e0bd5ee.png][]

对比：

工厂方法模式相对于简单工厂模式，结构更复杂，代码更复杂，管理更复杂，但是它符合我们编程的设计原则

根据设计原则：采用工厂方法模式

根据实际业务：通常采用简单工厂模式

所以，如果根据一个原则把代码设计的更加复杂，也是极其不好的

[af74b9c4447b4b129cf4418e4139997d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/b4d20456a92a4941872125d09d8dc4ba.png
[2b52a4f98e7541d7878bd054c5b37141.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e9ba463e81dd41108a53d48f342c64a4.png
[d0c8bed6f48a4025bfa119bd793eaafa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ed8a822431d74bc2a2085f36d4700fcc.png
[363f7860b1884d97aaab455b4e0bd5ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/abb2c3a6a055486ab43ee4f591ea3174.png