工厂模式（Factory Pattern）

1.什么是工厂模式

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

2.工厂模式的作用

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

3.工厂模式的分类

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

4.工厂模式的优缺点

优点： 

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

缺点：

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

 

简单工厂模式：

创建 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();
}

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

工厂方法模式：

创建一个车工厂接口 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();

对比：

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

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

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

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