【浅谈设计模式】:(3) 工厂模式–将实例的生成交给子类

这是我参与更文挑战的第5天，活动详情查看： 更文挑战

一、初识工厂模式

1.1 概述

今天，开始学习设计模式中创建者模式的第二种–工厂模式（Factory Method）。

老规矩，先上百度百科定义：

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

通过百度百科，我们知道平常使用最多的new操作来创建实例的时候，可能并不是最好的生成实例的策略，每次 new 一个对象的时候，它会有一些列复杂的初始化过程，例如进行在内存开辟空间、对变量进行初始化、还有检查配置文件等等校验操作，重复的new对象就相当于我们做月饼，如果每次都手工去做，那么就要把这个面团里面放馅，然后将它捏成圆形，在雕刻上字样，过程非常复杂，而使用工厂模式，就只需要将放完馅后的面团经过模具直接复印出来即可，在工厂模式种判断，如果是要刻上“花好月圆”就使用花好月圆的模具来打造，如果是要刻上“中秋佳节”就使用中秋佳节的模具来打造。

那么对应到工厂模式，就是我们不妨定义一个类（月饼模具）来 专门负责对象的创建，这样的类称为工厂类。在任何需要生成复杂对象的地方，都可以使用工厂模式来打造。这样，就把模具的实例和月饼分离开，一个是负责创建实例，一个是使用实例。

1.2 使用场景

• 对象的创建过程准备工作很复杂，需要初始化很多参数、查询数据库等。
• 类本身有很多子类，这些类的创建过程在业务种容易发生改变，或者对类的调用容易发生改变。

分类：

• 1、简单工厂模式
• 2、工厂方法模式
• 3、抽象工厂模式

二、简单工厂模式

工厂模式最大的优点就是解耦，实现了面向接口编程思想。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类。

2.1 结构

简单工厂模式不是一种设计模式，反而像是一种编程习惯。

简单工厂包含如下角色：

• 抽象产品：定义了产品的规范，描述了产品的主要特性和功能
• 具体产品：实现或者继承抽象产品的子类
• 具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。

2.2 使用

创建不同字样的月饼。

1、创建抽象接口

/**
 * 定义一个月饼模具接口
 */
public interface MoonCakeMould {
    //使用模具
    void use();
}
复制代码

2、创建子类实例

public class GoodMoon implements MoonCakeMould {
    @Override
    public void use() {
        System.out.println("采用花好月圆模具");
    }
    public GoodMoon(){
        this.use();
    }
}

public class NotBadMoon implements MoonCakeMould {
    @Override
    public void use() {
        System.out.println("使用中秋快乐模具！");
    }
    public NotBadMoon(){
        this.use();
    }
}

复制代码

3、创建工厂类：

public class MoonCakeFactory {
    public MoonCakeMould makeMoon(String text){
        if(text.equals("花好月圆")){
            return new GoodMoon();
        }else if (text.equals("中秋快乐")){
            return new NotBadMoon();
        }
        return null;
    }

    public static void main(String[] args) {
        MoonCakeFactory factory = new MoonCakeFactory();
        MoonCakeMould moon = factory.makeMoon("花好月圆");
        MoonCakeMould moon1 = factory.makeMoon("中秋快乐");
        System.out.println("模具花好月圆："+moon+";模具中秋快乐："+moon1);
    }
}
复制代码

4、输出结果：

采用花好月圆模具
使用中秋快乐模具！
模具花好月圆：patten.facotry.GoodMoon@33a10788;模具中秋快乐：patten.facotry.NotBadMoon@7006c658
复制代码

2.3 优缺点

优点：简单工厂模式封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户端代码，如果需要新增新产品，直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

缺点：增加新产品需要修改工厂类的代码，违背了“开闭原则”，也就是多加几个if-else，所以简单工厂模式适合业务简单，工厂类不会经常变更的情况。

三、工厂方法模式

为了解决简单工厂模式的修改问题，既然要修改工厂类，那我们可以多建几个工厂这样就可以不用修改了，这些工厂统一继承一个抽象工厂，这样就完全遵循开闭原则。

3.1 结构

工厂方法模式的主要角色：

• 抽象工厂（Abstract Factory）：声明工厂方法接口，调用者通过它访问具体工厂的工厂方法来创建产品。
• 具体工厂（ConcreteFactory）：实现抽象工厂中的抽象方法，完成具体产品的创建。
• 抽象产品（product）：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品（concreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它由具体工厂之间一一对应。

3.2 实现

1、抽象工厂

public interface MoonCakeFactory {
     MoonCakeMould makeMoon();
}
复制代码

2、具体工厂

public class GoodMoonCakeFactory implements MoonCakeFactory {
    @Override
    public MoonCakeMould makeMoon() {
        return new GoodMoon();
    }
}

public class NotBadMoonCakeFactory implements MoonCakeFactory {
    @Override
    public MoonCakeMould makeMoon() {
        return new NotBadMoon();
    }
}
复制代码

3、抽象产品

public interface MoonCakeMould {
    //使用模具
    void use();
}
复制代码

4、具体产品

public class NotBadMoon implements MoonCakeMould {
    @Override
    public void use() {
        System.out.println("使用中秋快乐模具！");
    }
    public NotBadMoon(){
        this.use();
    }
}

public class GoodMoon implements MoonCakeMould {
    @Override
    public void use() {
        System.out.println("采用花好月圆模具");
    }
    public GoodMoon(){
        this.use();
    }
}
复制代码

3.3 优缺点分析

优点：

• 解决了开闭原则，无需修改工厂类
• 用户只需要知道具体工厂的名称就可以得到所要的产品，无须知道产品的具体创建过程。

缺点：

• 每增加一个产品就要增加一个具体类和一个对应的具体工厂类，这增加了系统的复杂度。

四、抽象工厂模式

抽象工厂的出现是为了解决工厂模式的问题，尽可能缩减工厂实现子类的数量，不必给每一个产品分配一个工程类，能够将产品进行分组，然后在每组中由同一个工厂类的不同方法来创建。例如真正的工厂可能又造手机，又搞电视，最近还要搞车！

那么面对这种综合型能搞的公司，能够生产出多种类的产品，就可以采用抽象工厂模式考虑多个组。

抽象工厂模式将考虑多等级产品的生产和多品牌的产品。

如上所示，上面简单的按小米和红米来分，事实上一个一个产品可能有更多的类，那么如果每一个类都创建一个实例工厂，例如图中的小米汽车工厂类、红米汽车工厂类……等，那就需要六个工厂类。

4.1 结构

抽象工厂模式的主要角色如下：

• 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。例如：有小米手机、红米手机、黑鲨游戏机等等产品…..
• 具体工厂（Concrete Factory）：实现抽象工厂的多个抽象方法，完成具体产品的创建。
• 抽象产品（product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
• 具体产品（product）：实现了抽象产品角色定义的接口，由具体工厂创建。与具体工厂是多对一关系。

4.2 实现

1、抽象工厂

/**
 * 抽象工厂
 */
public interface TopFactory {
    //创建小米产品
    Xiaomi createXiaomiProduct();
    //创建红米产品
    RedMei createRedmiProduct();
}
复制代码

2、具体工厂（对应产品族）

/**
 * 手机工厂类
 */
public class PhoneFactory implements TopFactory{
    @Override
    public Xiaomi createXiaomiProduct() {
        return new XiaomiPhone();
    }

    @Override
    public RedMei createRedmiProduct() {
        return new RedmiPhone();
    }
}

/**
 * 电视工厂类
 */
public class TvFactory implements TopFactory {
    @Override
    public Xiaomi createXiaomiProduct() {
        return new XiaomiTv();
    }

    @Override
    public RedMei createRedmiProduct() {
        return new RedMiTv();
    }
}
复制代码

3、抽象产品（对应横轴）

/**
 * 产品抽象类：小米
 */
public interface Xiaomi {
    void print();
}

/**
 * 产品抽象类：红米
 */
public interface RedMei {
    void print();
}
复制代码

4、具体类

public class RedMiTv implements RedMei {
    public RedMiTv(){
        this.print();
    }
    @Override
    public void print() {
        System.out.println("生产一个红米手机");
    }
}

public class RedmiPhone implements RedMei {
    public RedmiPhone(){
        this.print();
    }
    @Override
    public void print() {
        System.out.println("生产一台红米手机");
    }
}

public class XiaomiTv implements Xiaomi {
    public XiaomiTv(){
        this.print();
    }
    @Override
    public void print() {
        System.out.println("生产一个小米电视");
    }
}

public class XiaomiPhone implements Xiaomi {
    public XiaomiPhone(){
        this.print();
    }
    @Override
    public void print() {
        System.out.println("生产一台小米手机");
    }
}
复制代码

5、测试

public class test {
    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();
        phoneFactory.createRedmiProduct(); //生产一台红米手机
        TvFactory tvFactory = new TvFactory();
        tvFactory.createXiaomiProduct();//生产一个小米电视
    }
}
复制代码

4.3 优缺点

优点：当一个产品族中的多个对象被设计程一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：当产品中需要增加一个新的产品时，所有的工厂类都需要进行修改。例如新增个黑鲨产品，那么父工厂就要新增一个创建黑鲨产品的方法，其他子工厂都要继承修改。

五、小结

• 简单工厂：唯一工厂类，一个产品抽象类，工程类的创建方法依据入参判断。

• 工厂方法：多个工厂类，一个产品抽象类，利用多态创建不同的产品对象，避免大量的if-else判断。

• 抽象工厂：多个工厂类，多个产品抽象类，产品子类分组，同一个工厂实现类创建同组的不同产品，减少了工厂子类的数量。

工厂模式使用场景：

1、对象的创建过程、实例化准备工作很复杂，需要初始化很多参数，查询数据库等。

2、类本身有很多子类，这些类的创建过程在业务中容易发生改变，或者对类的调用容易发生改变。

3、DateForamt类中的getInstance()方法使用的是工厂模式；

4、Calendar类中的getInstance()方法使用的是工厂模式；

总之，工厂模式的意义就是 ：其一为了方便将实例化过程和业务逻辑真正的解耦，其二是屏蔽复杂对象创建逻辑。工厂模式一般用来创建复杂对象，如果只需用new就可以创建成功的简单对象，就无需使用工厂模式，否则会增加系统的复杂度。

这是浅谈设计模式系列的第三篇文章，学习设计模式的目的就是尽快能看懂各种大神优雅的代码设计，并学着使用它，路漫漫其修远兮，求索之心不可断。