设计模式（二）-工厂模式

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

2、详细分类

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

 

3、OOP七大原则

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

 

4、核心本质

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

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

 

5、三种模式

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

 

6、简单工厂模式

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

代码如下：

/**
 * @author it-小林
 * @desc 汽车接口
 * @date 2021年07月05日 21:05
 */
public interface Car {

    void name();
}

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


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

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

    @Override
    public void name() {
        System.out.println("大众");
    }
}

 

 

/**
 * @author 林瑞涛
 * @desc
 * @date 2021年07月05日 21:07
 */
public class Tesla implements Car {

    @Override
    public void name() {
        System.out.println("特斯拉豪华车！！");
    }
}

 

工厂类的代码：

/**
 * @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;
        }
    }
}

 

调用者：

/**
 * @author it-小林
 * @desc
 * @date 2021年07月05日 21:09
 */
public class Consumer {
    public static void main(String[] args) {

        /*Car car = new WuLing();
        Car car2 = new Tesla();*/

        //2.使用工厂创建
        Car car = CarFactory.getCar("五菱");
        Car car2 = CarFactory.getCar("特斯拉");

        car.name();
        car2.name();
    }
}

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

 

7、工厂方法模式

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

 

 

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

 

/**
 * @author it-小林
 * @desc
 * @date 2021年07月06日 17:48
 */
public class DaZhongFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Dazhong();
    }
}

 

/**
 * @author it-小林
 * @desc
 * @date 2021年07月06日 17:49
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        Car car = new DaZhongFactory().getCar();
        car.name();
    }
}

 

 

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

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

 

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

 

应用场景：

• JDK中Calendar的getInstance方法；
• JDBC中的Connection对象的获取；
• Spring中IOC容器创建管理Bean对象；
• 反射中Class对象的newInstance方法。