1、作用：实现了创建者呵调用者的分离。

2、详细分类

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

 

3、OOP七大原则

• 开闭原则：一个软件的实体应当对扩展开放，对修改关闭
• 依赖倒转原则：对接口编程，不应该对实现编程
• 迪米特法则：不要和模式人说话

 

4、核心本质

（1）实例化对象不使用new，用工厂方法代替；

（2）将选择实现类，创建对象统一管理和控制，从而将调用者跟我们的实现类解耦。

 

5、三种模式

• 简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要修改已有代码）
• 工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）
• 抽象工厂模式：围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂

 

6、简单工厂模式

增加一个新的产品，如果不修改代码，做不到。

代码如下：

1 /**
2  * @author it-小林
3  * @desc 汽车接口
4  * @date 2021年07月05日 21:05
5  */
6 public interface Car {
7 
8     void name();
9 }

/**
 * @author it-小林
 * @desc
 * @date 2021年07月05日 21:06
 */
public class WuLing implements Car{


    @Override
    public void name() {
        System.out.println("五菱宏光神车");
    }
}

 1 /**
 2  * @author it-小林
 3  * @desc
 4  * @date 2021年07月05日 21:24
 5  */
 6 public class Dazhong implements Car{
 7 
 8     @Override
 9     public void name() {
10         System.out.println("大众");
11     }
12 }

 

 

 1 /**
 2  * @author 林瑞涛
 3  * @desc
 4  * @date 2021年07月05日 21:07
 5  */
 6 public class Tesla implements Car {
 7 
 8     @Override
 9     public void name() {
10         System.out.println("特斯拉豪华车！！");
11     }
12 }

 

工厂类的代码：

/**
 * @author it-小林
 * @desc 静态工厂模式
 * @date 2021年07月05日 21:16
 */
public class CarFactory {

    public static Car getCar(String car){
        if(car.equals("五菱")){
            return new WuLing();
        }else if(car.equals("特斯拉")){
            return new Tesla();
        }else if(car.equals("大众")){
            return new Dazhong();
        }else{
            return null;
        }
    }
}

 

调用者：

 1 /**
 2  * @author it-小林
 3  * @desc
 4  * @date 2021年07月05日 21:09
 5  */
 6 public class Consumer {
 7     public static void main(String[] args) {
 8 
 9         /*Car car = new WuLing();
10         Car car2 = new Tesla();*/
11 
12         //2.使用工厂创建
13         Car car = CarFactory.getCar("五菱");
14         Car car2 = CarFactory.getCar("特斯拉");
15 
16         car.name();
17         car2.name();
18     }
19 }

 注：大多数情况下用的都是简单工厂模式，这种模式仍有不足，如果再增加一辆车，则会修改CarFactory.java的getCar方法，违反了开闭原则，我们应该扩展，不应该修改。

 

7、工厂方法模式

       我们新建一个CarFactory的接口，然后为每种Car都建一个Factory类。这样就可以使得每次新加入一种车时，只为这种车建立一个对应的工厂就行，不会影响到原来的代码。

 

 

/**
 * @author it-小林
 * @desc
 * @date 2021年07月06日 17:47
 */
public interface CarFactory {
    Car getCar();
}

 

 1 /**
 2  * @author it-小林
 3  * @desc
 4  * @date 2021年07月06日 17:48
 5  */
 6 public class DaZhongFactory implements CarFactory{
 7     @Override
 8     public Car getCar() {
 9         return new Dazhong();
10     }
11 }

 

 1 /**
 2  * @author it-小林
 3  * @desc
 4  * @date 2021年07月06日 17:49
 5  */
 6 public class AbstractFactoryTest {
 7     public static void main(String[] args) {
 8         Car car = new DaZhongFactory().getCar();
 9         car.name();
10     }
11 }

 

 

优点：下次加入一种大众车，只需要新建一个 DazhongFactory 就行，不会影响到别的工厂。

缺点：代码量加大，管理复杂，结构复杂，实际业务一般使用简单工厂模式

 

总结：不一定要符合设计原则，要根据实际情况加以分析取舍。