Java的23种设计模式---(2)工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq1021979964/article/details/87544139

工厂模式

工厂模式：

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

详细分类：

简单工厂模式（静态工厂模式）

• 虽然某种程度不符合设计原则，但实际使用最多。

工厂方法模式

• 不修改已有类的前提下，通过增加新的工厂类实现扩展。

抽象工厂模式

• 不可以增加产品，可以增加产品族

面向对象设计的基本原则：

OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。

DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。

LOD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。

核心本质：

1. 实例化对象，用工厂方法代替new操作。
2. 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

工厂模式：

• 简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
• 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
• 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

需要使用的类和接口

package com.kevin.创建型模式.工厂模式.simplefactory;

/**
 * @author kevin
 * @version 1.0
 * @description     实现的接口类
 * @createDate 2019/2/17
 */
public interface Car {
    void run();
}

package com.kevin.创建型模式.工厂模式.simplefactory;

/**
 * @author kevin
 * @version 1.0
 * @description
 * @createDate 2019/2/17
 */
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪行驶中");
    }
}

package com.kevin.创建型模式.工厂模式.simplefactory;

/**
 * @author kevin
 * @version 1.0
 * @description
 * @createDate 2019/2/17
 */
public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪行驶中");
    }
}

不使用简单工厂的情况

package com.kevin.创建型模式.工厂模式.simplefactory;

/**
 * @author kevin
 * @version 1.0
 * @description     测试未使用工厂模式
 * @createDate 2019/2/17
 */
public class Test {

    public static void main(String[] args) {

        // 普通创建方式，需要选择调用哪个类
        Car c1 = new Audi();
        Car c2 = new Byd();
        c1.run();
        c2.run();
    }
}

UML类图

问题：调用方需要知道创建哪个类？比较麻烦

使用简单工厂模式

package com.kevin.创建型模式.工厂模式.simplefactory;

/**
 * @author kevin
 * @version 1.0
 * @description     简单工厂模式
 * 1.简单工厂模式也叫做静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数的不同来返回不同的对象实例。
 * 2.对于增加新产品无能为力，不修改代码的话是无法扩展的。
 * @createDate 2019/2/17
 */
public class CarFactory {

    // 方式一：
    public static Car createCar(String type) {
        if("奥迪".equals(type)){
            return new Audi();
        } else if("比亚迪".equals(type)){
            return new Byd();
        } else {
            return null;
        }
    }

    // 方式二：
    public static Car createAudi(){
        return new Audi();
    }
    public static Car createByd(){
        return new Byd();
    }

}

package com.kevin.创建型模式.工厂模式.simplefactory;

/**
 * @author kevin
 * @version 1.0
 * @description     测试工厂模式
 * @createDate 2019/2/17
 */
public class Test {

    public static void main(String[] args) {

        // 简单工厂模式
        // 方式一：调用方便，不需要有调用方选择调用那个实例，只需要传入参数
        CarFactory.createCar("奥迪").run();
        CarFactory.createCar("比亚迪").run();
        //c3.run();

        // 方式二：
        CarFactory.createAudi().run();
        CarFactory.createByd().run();
    }
}

UML类图

注：

• 简单工厂模式也叫做静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数的不同来返回不同的对象实例。
• 对于增加新产品无能为力，不修改代码的话是无法扩展的。

工厂方法模式

package com.kevin.创建型模式.工厂模式.factorymethod;

/**
 * @author kevin
 * @version 1.0
 * @description     工厂方法模式
 * @createDate 2019/2/17
 */
public interface CarFactory {

    Car createCar();
}

package com.kevin.创建型模式.工厂模式.factorymethod;

/**
 * @author kevin
 * @version 1.0
 * @description
 * 为了避免简单工厂模式的缺点，不完全满足OCP。
 * 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，
 * 而工厂方法模式有一组实现了相同接口的工厂类。
 * @createDate 2019/2/17
 */
public class AudiFactory implements CarFactory{

    @Override
    public Car createCar() {
        return new Audi();
    }
}

package com.kevin.创建型模式.工厂模式.factorymethod;

/**
 * @author kevin
 * @version 1.0
 * @description
 * @createDate 2019/2/17
 */
public class BydFactory implements CarFactory{

    @Override
    public Car createCar() {
        return new Byd();
    }
}

package com.kevin.创建型模式.工厂模式.factorymethod;

/**
 * @author kevin
 * @version 1.0
 * @description     测试工厂方法模式
 * @createDate 2019/2/17
 */
public class Test {

    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();
        c1.run();
        c2.run();
    }
}

UML类图

注：

* 为了避免简单工厂模式的缺点，不完全满足OCP。
* 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，
* 而工厂方法模式有一组实现了相同接口的工厂类。

抽象工厂模式

用于生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

发动机

package com.kevin.创建型模式.工厂模式.abstractfactory;

/**
 * @author kevin
 * @version 1.0
 * @description     发动机
 * @createDate 2019/2/17
 */
public interface Engine {

    void run();
    void start();
}

class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("转的快");
    }

    @Override
    public void start() {
        System.out.println("启动快。可以自动启停");
    }
}

class LowEngine implements Engine{

    @Override
    public void run() {
        System.out.println("转的慢");
    }

    @Override
    public void start() {
        System.out.println("启动慢");
    }
}

座椅

package com.kevin.创建型模式.工厂模式.abstractfactory;

/**
 * @author kevin
 * @version 1.0
 * @description     座椅
 * @createDate 2019/2/17
 */
public interface Seat {

    void massage();
}

class LuxurySeat implements Seat{

    @Override
    public void massage() {
        System.out.println("可以自动按摩");
    }
}

class LowSeat implements Seat{

    @Override
    public void massage() {
        System.out.println("不能按摩");
    }
}

轮胎

package com.kevin.创建型模式.工厂模式.abstractfactory;

import javax.swing.plaf.synth.SynthOptionPaneUI;

/**
 * @author kevin
 * @version 1.0
 * @description     轮胎
 * @createDate 2019/2/17
 */
public interface Tyre {

    void revolve();
}

class LuxuryTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋转不磨损。");
    }
}

class LowTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋转磨损快。");
    }
}

工厂

package com.kevin.创建型模式.工厂模式.abstractfactory;

/**
 * @author kevin
 * @version 1.0
 * @description     工厂
 * @createDate 2019/2/17
 */
public interface CarFactory {

    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

高端产品族工厂

package com.kevin.创建型模式.工厂模式.abstractfactory;

/**
 * @author kevin
 * @version 1.0
 * @description 高端产品族工厂
 * @createDate 2019/2/17
 */
public class LuxuryCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

低端产品族工厂

package com.kevin.创建型模式.工厂模式.abstractfactory;

/**
 * @author kevin
 * @version 1.0
 * @description 低端产品族工厂
 * @createDate 2019/2/17
 */
public class LowCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

测试抽象工厂模式

package com.kevin.创建型模式.工厂模式.abstractfactory;

/**
 * @author kevin
 * @version 1.0
 * @description     测试抽象工厂模式
 * @createDate 2019/2/17
 */
public class Test {

    public static void main(String[] args) {

        // 高端工厂
        Engine luxuryEngine = new LuxuryCarFactory().createEngine();
        luxuryEngine.run();
        luxuryEngine.start();

        // 低端工厂
        Engine lowEngine = new LowCarFactory().createEngine();
        lowEngine.run();
        lowEngine.start();
    }
}

UML类图

注：抽象工厂模式，通过不同的产品族创建产品。

应用场景：

1. JDK中Calendar的getInstance方法
2. JDBC中Connection对象的获取
3. Hibernate中SessionFactory创建Session
4. spring中IOC容器创建管理bean对象
5. XML解析时的DocumentBuilderFactory创建解析器对象
6. 反射中Class对象的newInstance()