设计模式-工厂模式

一、工厂模式介绍

目的： 工厂模式的主要解决的问题是，将原来分布在各个地方的对象创建过程单独抽离出来，交给工厂类负责创建。 其他地方想要使用对象直接找工厂（即调用工厂的方法）获取对象。

意义： 将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到主项目的依赖关系解耦。从而提高项目的拓展和维护性。

三种实现方式：

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

二、简单工厂模式

2.1 示例关系：

2.2 代码实现：

/* *
 * 移动电话接口。
 */

interface IMobile {
    /* *
     * 拨打电话方法。
     */

    void call();
}

/* *
 * OPPO、HUAWEI实体类分别实现IMobile接口方法。
 */

class OPPO implements IMobile {
    @Override
    public void call() {
        System.out.println("使用OPPO手机打电话");
    }
}

class HUAWEI implements IMobile {
    @Override
    public void call() {
        System.out.println("使用华为手机打电话");
    }
}

/* *
 * 定义一个简单工厂类。
 * 有自己的createMobile()方法。
 * 该方法能通过传入的不同品牌，生成指定的对象。
 */

public class SimpleFactory {

    IMobile mobile = null;

    public IMobile createMobile(String brand) {
        if ("OPPO".equalsIgnoreCase(brand)) {
            mobile = new OPPO();
        } else if ("HUAWEI".equalsIgnoreCase(brand)) {
            mobile = new HUAWEI();
        } else {
            System.out.println("类型不存在!");
        }
        return mobile;
    }

    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();

        // 客户端无需知道对象创建的具体细节，只需要从工厂类中获取对象即可。
        IMobile huawei = simpleFactory.createMobile("HUAWEI");
        huawei.call();
        // 使用华为手机打电话
    }
}

2.3 方式说明：

核心思想： 定义一个创建对象的类，由这个类封装实例化对象的行为。

优点： 客户端无需关注创建对象的细节。

缺点：

• 当不断有实体类型新增，该工厂类职责变得越来越多，不符合单一职责原则。

• 每次增加/删除某个子类对象，该工厂类也要修改，也违反了开闭原则。

适用场景： 较少子类实体对象且变更不大的场景。

三、工厂方法模式

3.1 示例关系：

3.2 代码实现：

/* *
 * 移动电话接口。
 */

interface IMobile {
    /* *
     * 拨打电话方法。
     */

    void call();
}

/* *
 * OPPO、HUAWEI实体类分别实现IMobile接口方法。
 */

class OPPO implements IMobile {
    @Override
    public void call() {
        System.out.println("使用OPPO手机打电话");
    }
}

class HUAWEI implements IMobile {
    @Override
    public void call() {
        System.out.println("使用华为手机打电话");
    }
}

/* *
 * 定义一个专门生产对象的IMobileFactory接口。
 */

interface IMobileFactory {
    /* *
     * 创建手机对象的方法。
     */

    IMobile createMobile();
}


/* *
 * OPPO、HUAWEI实体工厂类实现IMobileFactory接口。
 * 分别返回自己依赖的OPPO、HUAWEI的实体对象。
 */

class OPPOFactory implements IMobileFactory {
    @Override
    public IMobile createMobile() {
        return new OPPO();
    }
}

class HUAWEIFactory implements IMobileFactory {
    @Override
    public IMobile createMobile() {
        return new HUAWEI();
    }
}


public class FactoryMethod {
    public static void main(String[] args) {
        // 客户端通过不同工厂，创建所需对象。
        OPPOFactory oppoFactory = new OPPOFactory();
        IMobile oppo = oppoFactory.createMobile();
        oppo.call();
        // 使用OPPO手机打电话


        HUAWEIFactory huaweiFactory = new HUAWEIFactory();
        IMobile huawei = huaweiFactory.createMobile();
        huawei.call();
        // 使用华为手机打电话
    }
}

3.3 方式说明：

核心思想： 工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

优点：

• 它相当于是简单工厂解耦的一种方式，不同功能的实例对象并没有耦合在一起。

• 一个类通过其子类来指定创建对象，客户端不依赖产品实例如何创建和实现的细节。

缺点：

• 类的个数容易过多，增加复杂度。

• 增加了系统的抽象性和理解难度。

适用场景： 创建对象需要大量重复的代码的场景。

四、抽象工厂模式

4.1 示例关系：

4.2 代码实现：

/* *
 * 定义产品类型为：移动电话、耳机的接口。
 */

interface IMobile {
    void call();
}

interface IHeadset {
    void listen();
}

/* *
 * OPPO、HUAWEI实体类分别实现IMobile接口方法。
 */

class OPPO implements IMobile {
    @Override
    public void call() {
        System.out.println("使用OPPO手机打电话");
    }
}

class HUAWEI implements IMobile {
    @Override
    public void call() {
        System.out.println("使用华为手机打电话");
    }
}


/* *
 * Air2、FreeBudsPro实体类分别实现IHeadset接口方法。
 */

class Air2 implements IHeadset {
    @Override
    public void listen() {
        System.out.println("使用Air2听音乐");
    }
}

class FreeBudsPro implements IHeadset {
    @Override
    public void listen() {
        System.out.println("使用FreeBudsPro听音乐");
    }
}


/* *
 * 定义一个抽象工厂：可以创建不同产品类型的对象。
 */

interface AbstractFactory {

    IMobile createMobile();

    IHeadset createHeadset();
}

/* *
 * OPPO、HUAWEI实体工厂类实现AbstractFactory接口。
 * 分别返回不同产品类型下，自己依赖的OPPO、HUAWEI的实体对象。
 */

class OPPOFactory implements AbstractFactory {
    @Override
    public IMobile createMobile() {
        return new OPPO();
    }

    @Override
    public IHeadset createHeadset() {
        return new Air2();
    }
}

class HUAWEIFactory implements AbstractFactory {
    @Override
    public IMobile createMobile() {
        return new HUAWEI();
    }

    @Override
    public IHeadset createHeadset() {
        return new FreeBudsPro();
    }
}


public class AbstractFactoryMethod {
    public static void main(String[] args) {
        IMobile oppo = new OPPOFactory().createMobile();
        oppo.call(); // 使用OPPO手机打电话

        IHeadset air2 = new OPPOFactory().createHeadset();
        air2.listen(); // 使用Air2听音乐

        IMobile huawei = new HUAWEIFactory().createMobile();
        huawei.call(); // 使用华为手机打电话

        IHeadset freeBudsPro = new HUAWEIFactory().createHeadset();
        freeBudsPro.listen(); // 使用FreeBudsPro听音乐
    }
}

4.3 方式说明：

抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。

抽象工厂模式可以将简单工厂模式和工厂方法打模式进行整合。

与工厂方法模式不同在于，抽象工厂侧重生产不同产品族，而工厂方法则是侧重生产纵向类型对象。

五、工厂模式在JDK中的应用

java.util.Calendar.getInstance()

方法：简单工厂。

六 、结束语

---

“-------怕什么真理无穷,进一寸有一寸的欢喜。”

微信公众号搜索：饺子泡牛奶。