工厂设计模式-Java实现（简单工厂模式、工厂方法模式、抽象工厂模式）

工厂模式介绍

凡是需要创建复杂对象的地方，都可以尝试考虑使用工厂模式来代替。

注意：上述复杂对象指的是类的构造函数参数过多等对类的构造有影响的情况，因为类的构造过于复杂，如果直接在其他业务类内使用，则两者的耦合过重，后续业务更改，就需要在任何引用该类的源代码内进行更改，光是查找所有依赖就很消耗时间了，更别说要一个一个修改了。

工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。

简单工厂模式

如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。简单工厂模式只有一个具体的工厂类，可以生成多种不同的产品，由一个工厂对象决定创建出哪一种产品类的实例，属于创建型设计模式。

简单工厂模式不在 GoF 23 种设计模式之列。

在简单工厂模式中创建实例的方法通常为静态方法，因此简单工厂模式，又叫作静态工厂方法模式。

简单工厂模式每增加一个产品就要增加一个具体产品类并增加工厂类的判断逻辑，这增加了系统的复杂度，违背了“开闭原则”。

模式的结构与实现

模式的结构

简单工厂模式的主要角色如下：

• 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品：是简单工厂模式的创建目标。
• 简单工厂：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类创建产品的方法可以被外界直接调用，创建所需的产品对象。

模式的实现

案例演示：生产手机案例

传统方式实现

//抽象产品：手机
interface Phone {
    void callUp();//打电话
    void sendMsg();//发短信
}

//具体产品：小米手机
class MiPhone implements Phone {

    @Override
    public void callUp() {
        System.out.println("小米手机打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米手机发短信");
    }
}
//具体产品：华为手机
class HuaweiPhone implements Phone {

    @Override
    public void callUp() {
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("华为手机发短信");
    }
}

//客户类
public class Customer {
    public static void main(String[] args) {
        Phone phone1 = new MiPhone();
        phone1.callUp();
        phone1.sendMsg();

        Phone phone2 = new HuaweiPhone();
        phone2.callUp();
        phone2.sendMsg();
    }
}

优缺点

优点是代码简单容易理解
缺点是客户端依赖具体手机产品类，客户端对所需手机的生产要有足够了解（具体类名、构造方法需要传递哪些参数等）

简单工厂模式实现

//抽象产品：手机
interface Phone {
    void callUp();//打电话
    void sendMsg();//发短信
}

//具体产品：小米手机
class MiPhone implements Phone {

    @Override
    public void callUp() {
        System.out.println("小米手机打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米手机发短信");
    }
}
//具体产品：华为手机
class HuaweiPhone implements Phone {

    @Override
    public void callUp() {
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("华为手机发短信");
    }
}
//简单工厂
public class PhoneFactory {
    //静态方法，注意：返回类型为抽象产品类型
    public static Phone producePhone(String s) {
        //判断逻辑，根据传入的参数创建具体产品对象并返回
        if ("mi".equalsIgnoreCase(s))
            return new MiPhone();
        else if ("huawei".equalsIgnoreCase(s))
            return new HuaweiPhone();

        return null;
    }
}

public class Customer {
    public static void main(String[] args) {
        Phone miPhone = PhoneFactory.producePhone("mi");
        miPhone.callUp();
        miPhone.sendMsg();

        Phone huaweiPhone = PhoneFactory.producePhone("huawei");
        huaweiPhone.callUp();
        huaweiPhone.sendMsg();
    }
}

优缺点

优点

1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
2. 客户端无需知道所创建具体产品的类名，只需知道参数即可。
3. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点

1. 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重
2. 系统扩展困难，一旦增加新产品不得不修改工厂类的判断逻辑，在产品类型较多时，可能造成逻辑过于复杂

应用场景

对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类静态方法的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

简单工厂模式在JDK中的应用

例如，java.util.Calendar类的createCalendar方法

工厂方法模式

定义一个抽象工厂，每一种产品由抽象工厂的具体子工厂来创建，对象的创建越来越专业化，分工越来越细。

简单工厂模式违背了开闭原则，而“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

模式的结构与实现

模式的结构

工厂方法模式的主要角色如下。

1. 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
2. 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
3. 抽象工厂：创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
4. 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

模式的实现

package demo1;

//抽象产品：手机
interface Phone {
    void callUp();//打电话
    void sendMsg();//发短信
}

//具体产品：小米手机
class MiPhone implements Phone {

    @Override
    public void callUp() {
        System.out.println("小米手机打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米手机发短信");
    }
}
//具体产品：华为手机
class HuaweiPhone implements Phone {

    @Override
    public void callUp() {
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("华为手机发短信");
    }
}

//抽象工厂：生产手机
interface Factory {
    Phone producePhone();
}

//具体工厂：小米工厂
class MiFactory implements Factory {

    @Override
    public Phone producePhone() {
        return new MiPhone();
    }
}
//具体工厂：华为工厂
class HuaweiFactory implements Factory {

    @Override
    public Phone producePhone() {
        return new HuaweiPhone();
    }
}

//测试类
public class Customer {
    public static void main(String[] args) {
        Factory miFactory = new MiFactory();
        Phone phone1 = miFactory.producePhone();
        phone1.callUp();
        phone1.sendMsg();

        Factory huaweiFactory = new HuaweiFactory();
        Phone phone2 = huaweiFactory.producePhone();
        phone2.callUp();
        phone2.sendMsg();
    }
}

优缺点

优点

• 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
• 灵活性增强，对于新产品的创建，只需增加相应的产品类和工厂类。

缺点

• 类的个数容易过多，每个产品都需要配一个相应的工厂，增加了复杂度
• 增加了系统的抽象性和理解难度
• 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

应用场景

• 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
• 客户不关心创建产品的细节，只关心产品的品牌

工厂方法模式在JDK中的应用

例如，Collection集合的迭代器：

java.util.Iterator接口是抽象产品，源码：

public interface Iterator<E> {
	boolean hasNext();
	E next();
}

java.util.Collection接口是抽象工厂，源码：

public interface Collection<E> {
    Iterator<E> iterator();
}

java.util.ArrayList类是具体工厂，ArrayList类的内部类Itr实现了Iterator接口，相当于具体产品，源码：

public class ArrayList<E> implements List<E> {
   /**
	*  ArrayList实现接口Collection
    *  重写方法iterator()
    *  返回Iterator接口实现类Itr类的对象
	*/
	public Iterator<E> iterator() {
        return new Itr();
    }
    
   /**
    * ArrayList中定义内部类Itr，实现接口Iterator
    * 重写hasNext()、next()方法
    */
    private class Itr implements Iterator<E> {
        
    	public boolean hasNext() {...}
        
        public E next() {...}
    }
}

抽象工厂模式

工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。

同种类称为同等级，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

模式的定义与特点

抽象工厂模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件：

• 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
• 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下：

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

模式的结构与实现

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。

模式的结构

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

1. 抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
2. 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
3. 抽象工厂：创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
4. 具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。

模式的实现

抽象工厂模式的结构同工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。

//抽象产品：手机
interface Phone {
    void callUp();//打电话
    void sendMsg();//发短信
}
//抽象产品：电脑
interface Computer {
    void open();
    void close();
}
//具体产品：小米手机
class MiPhone implements Phone {

    @Override
    public void callUp() {
        System.out.println("小米手机打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米手机发短信");
    }
}
//具体产品：小米电脑
class MiComputer implements Computer {

    @Override
    public void open() {
        System.out.println("小米电脑开机");
    }

    @Override
    public void close() {
        System.out.println("小米电脑关机");
    }
}
//具体产品：华为手机
class HuaweiPhone implements Phone {

    @Override
    public void callUp() {
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("华为手机发短信");
    }
}
//具体产品：华为电脑
class HuaweiComputer implements Computer {

    @Override
    public void open() {
        System.out.println("华为电脑开机");
    }

    @Override
    public void close() {
        System.out.println("华为电脑关机");
    }
}
//抽象工厂：生产手机、电脑等多个不同种类的产品
interface Factory {
    Phone producePhone();
    Computer produceComputer();
}
//具体工厂：小米工厂，生产手机、电脑等
class MiFactory implements Factory {

    @Override
    public Phone producePhone() {
        return new MiPhone();
    }

    @Override
    public Computer produceComputer() {
        return new MiComputer();
    }
}
//具体工厂：华为工厂，生产手机、电脑等
class HuaweiFactory implements Factory {

    @Override
    public Phone producePhone() {
        return new HuaweiPhone();
    }

    @Override
    public Computer produceComputer() {
        return new HuaweiComputer();
    }
}
//测试类
public class Customer {
    public static void main(String[] args) {
        MiFactory miFactory = new MiFactory();
        Phone phone = miFactory.producePhone();
        phone.callUp();
        phone.sendMsg();

        HuaweiFactory huaweiFactory = new HuaweiFactory();
        Computer computer = huaweiFactory.produceComputer();
        computer.open();
        computer.close();
    }
}

模式的应用场景

抽象工厂模式通常适用于以下场景：

1. 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
2. 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。

模式的扩展

抽象工厂模式的扩展有一定的“开闭原则”倾斜性：

1. 当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。
2. 当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则。

另一方面，当系统中只存在一个等级结构的产品时，抽象工厂模式将退化到工厂方法模式。