简单工厂模式
场景 : 当某一类型的 实例对象 创建过程较为复杂时，我们可以采用此设计思想。
拿线程池的创建举个例子，看看 这么多参数！
每次在创建的时候 都要考虑很多。
于是有了工厂模式的思想：
我们把繁杂的创建过程 交给工厂去做，将面对客户的方法简单化。
场景分析：现在我们有一个车场的需求，每生产一辆车要创建一个车的实例。
比如 生产一个 特斯拉：
new Tesla("tesla",1,2);
特斯拉对应类：
public class Tesla{
private String name;
private int size;
private int spice;
public Tesla(String name, int size, int spice) {
this.name = name;
this.size = size;
this.spice = spice;
}
public void name() {
System.out.println("特斯拉!!!");
}
}
我这里只设计了三个参数，但实际中应该会有很多属性。那时候就会比较麻烦。
最总要的是还会有其他厂商的车，此时我们用一个接口（Car）来加一个约束，降低耦合度。
引入接口 Car :
public interface Car {
void name();
}
Tesla：
public class Tesla implements Car{
private String name;
private int size;
private int spice;
public Tesla(String name, int size, int spice) {
this.name = name;
this.size = size;
this.spice = spice;
}
@Override
public void name() {
System.out.println("特斯拉!!!");
}
}
WuLing：
public class WuLing implements Car{
private String name;
private int size;
private int spice;
public WuLing(String name, int size, int spice) {
this.name = name;
this.size = size;
this.spice = spice;
}
@Override
public void name() {
System.out.println("五菱红光!!");
}
}
我们引入一个工厂类来管理我们这些车的创建：
public class Factory {
public Car getCar(String name){
if (name.equals("tesla")){
return new Tesla("tesla",1,2);
}else if (name.equals("wuLing")){
return new WuLing("wuLing",1,2);
}
return null;
}
}
此时我们通过Factory创建汽车实例时就会方便很多。
Factory factory = new Factory();
Car tesla = factory.getCar("tesla");
Car wuLing = factory.getCar("wuLing");
tesla.name();
wuLing.name();
特斯拉!!!
五菱红光!!
简单工厂逻辑图
这样的确解决了创建的麻烦，但每次增加厂商的时候就会比麻烦。
如果此时 加入一个新的汽车厂商，就需要修改 Factory 类，这不符合 OOP的开闭原则。
于是有了 方法工厂模式
方法工厂模式
为了符合 开闭原则 ，我再次将工厂抽象。
我们引入一个 工厂的接口来约束 各个厂商的工厂。
public interface CarFactory {
Car getCar();
}
每个厂商都有自己的工厂
TeslaFactory：
public class TeslaFactory implements CarFactory{
@Override
public Car getCar() {
return new Tesla("tesla",1,2);
}
}
WuLingFactory：
public class WuLingFactory implements CarFactory{
@Override
public Car getCar() {
return new WuLing("wuLing",2,1);
}
}
此时我们在加一个厂商：Cadillac
public class Cadillac implements Car{
private String name;
private int size;
private int spice;
public Cadillac(String name, int size, int spice) {
this.name = name;
this.size = size;
this.spice = spice;
}
@Override
public void name() {
System.out.println("凯迪拉克!");
}
}
以及其对应的 工厂：CadillacFactory
public class CadillacFactory implements CarFactory{
@Override
public Car getCar() {
return new Cadillac("cadillac",1,2);
}
}
当我们创建时，通过各自的工厂来创建对应汽车的实例：
Car car = new TeslaFactory().getCar();
Car car1 = new WuLingFactory().getCar();
Car car2 = new CadillacFactory().getCar();
car.name();
car1.name();
car2.name();
特斯拉!!!
五菱红光!!
凯迪拉克!
这次加了新厂商 ，但我们并没有改之前的代码。
没错，这非常符合 开闭原则 ！！！
方法工厂逻辑图
这样就符合了开闭原则，但代码量也大了不少。
在时间的项目开发中，大多数情况下 大家还是选择 简单工厂模式，
因为方法工厂模式 代码复杂度大了好多。
开发原则只针对开发，但在实际业务问题上还是要综合考虑取舍的。