工厂方法模式（Factory Method）

工厂方法模式（Factory Method）是一种创建型的设计模式，在该模式中父类决定实例的生成方式。但是不决定它要生成的具体的类，具体的处理是交给子类完成的，这样将生成实例的框架和负责生成实例的类解耦。

接下来通过一个制作身份证明的IDCard来学习工厂方法模式，照例先来一张类图，对该例程序有大概的认识。

类图：

这里写图片描述

产品类Product

Product属于工厂方法模式中的”产品”类，在该类中仅仅声明了一个抽象方法use(),定义了任意产品都可以use的方法，即定义了生成的实例所持有的接口方法。

public abstract class Product {
    public abstract void use();
}复制代码

工厂类Factory

该类是生产Product的类，该类内部提供了一个create方法创建产品，并且提供抽象方法createProduct创建产品和registerProduct注册产品。他在工厂方法模式充当创建者这一角色，负责生成产品Product，但是具体处理交由具体创建者。对于使用生成实例的专用方法createProduct创建实例，而不用new关键字来生成，这样做的好处是可以防止
父类与其他类耦合。

public abstract class Factory {
    public final Product create(String owner) {
        Product p = createProduct(owner);
        registerProduct(p);
        return p;
    }
    protected abstract Product createProduct(String owner);
    protected abstract void registerProduct(Product product);
}复制代码

具体产品类IDCard

在上面说到产品类Product，它需要子类去实现具体的产品IDCard，而IDCard和Product是分离的。

public class IDCard extends Product {
    private String owner;
    IDCard(String owner) {
        System.out.println("制作ID卡"+owner);
        this.owner = owner;
    }
    public void use() {
        System.out.println("使用ID卡"+owner);
    }
    public String getOwner() {
        return owner;
    }
}复制代码

具体工厂类IDCardFactory

IDCardFactory是工厂类Factory的具体实现，通过createProduct方法生成具体的产品，并通过registerProduct方法将有owner生成的具体产品IDCard保存到owners实现产品注册。

public class IDCardFactory extends Factory {
    private List owners = new ArrayList();
    protected  Product createProduct(String owner) {
        return new IDCard(owner);
    }
    protected void registerProduct(Product product) {
        IDCard card = (IDCard)product;
        owners.add(card.getOwner());
    }
    public List getOwners() {
        return owners;
    }
}复制代码

测试类Main

public class Main {
    public static void main(String[] args) {
        Factory factory = new IDCardFactory();
        Product card1 = factory.create("小明");
        Product card2 = factory.create("小红");
        Product card3 = factory.create("小刚");
        card1.use();
        card2.use();
        card3.use();
    }
}复制代码

输出信息

制作ID卡小明
制作ID卡小红
制作ID卡小刚
使用ID卡小明
使用ID卡小红
使用ID卡小刚复制代码

在上面的介绍中我们的需求是生产一个IDCard，那么如果我们生成一个电视机呢，我们只需要创建一个电视机Televison和生成电视机的具体工厂类TelevisionFactory,在此，我们不需要修改产品类Product和工厂类Factory,就可以创建我们需要的产品。

抽象工厂模式

在上面的工厂方法中具体的产品和具体的工厂是一一对应的，一个工厂只能生产一种产品，结构单一，例如小米公司刚开始是只生产小米手机，但是伴随着公司的发展，他们需要生产不同型号的手机，也会生产路由器，小米电视等等，那么工厂方法模式已不能满足业务的需求了，此时我们就需要抽象工厂模式，即一个工厂可以生产多种产品。（当然使用工厂方法也是可以的，不过需要创建多个具体工厂）
在抽象工厂模式中引入两个重要的概念一个是产品等级结构，它是产品的继承结构例如一个抽象产品电视类它的子类可以为各种型号或的电视。那么产品族是什么呢？在上面提到小米可以生产手机，电视，路由器等，那么这些就是一个产品族。

在图解设计模式一书中，是通过将带有层次结构关系的集合标签制成HTML文件的示例讲解抽象工厂模式的，不过我感觉示例代码稍微有点多，所以基于自己的理解，通过开始所说的小米生产手机和电视的这个例子来总结抽象工厂模式。

照例先看类图：

这里写图片描述

抽象产品

抽象产品角色负责定义抽象工厂生成的产品的接口，在本例中有两个抽象产品类，分别是手机和电视的抽象类，对应有一个打电话dial()和watchTV（）方法

public abstract class IMobilePhone {
    public abstract void dial();
}
public abstract class ITelevision {
    public abstract void watchTV();
}复制代码

具体产品类

具体产品角色负责实现抽象产品角色的接口。

public class MobilePhone extends IMobilePhone {
    private String name;
    public MobilePhone(String name) {
        this.name=name;
        System.out.println("制作手机"+name);
    }

    @Override
    public void dial() {
        System.out.println("使用"+name+"打电话");
    }
}


public class Television extends ITelevision {
    private String name;
    public Television(String name) {
        this.name=name;
        System.out.println("制作电视"+name);
    }

    @Override
    public void watchTV() {
        System.out.println("通过"+name+"看电视");
    }
}复制代码

抽象工厂类

抽象工厂角色是负责定义用于生成抽象产品的接口。

public abstract class Factory {
    public static Factory getFactory(String classname) {
        Factory factory = null;
        try {
            factory = (Factory)Class.forName(classname).newInstance();
        } catch (ClassNotFoundException e) {
            System.err.println("没有找到 " + classname + "类。");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return factory;
    }
    public abstract MobilePhone createMobilePhone(String type);
    public abstract Television createTelevision(String type);
}复制代码

具体工厂

实现抽象工厂的抽象方法生成产品。

public class XiaoMiFactory extends Factory{
    @Override
    public MobilePhone createMobilePhone(String type) {
        return new MobilePhone(type);
    }
    @Override
    public Television createTelevision(String type) {
        return new Television(type);
    }
}复制代码

测试类

public class Main {
    public static void main(String[] args) {
        Factory factory = Factory.getFactory("com.abstractfactory.XiaoMiFactory");
        IMobilePhone mobilePhone1=factory.createMobilePhone("小米2");
        IMobilePhone mobilePhone2=factory.createMobilePhone("小米5");

        ITelevision television1=factory.createTelevision("小米电视2");
        ITelevision television2=factory.createTelevision("小米电视3");

        mobilePhone1.dial();
        mobilePhone2.dial();

        television1.watchTV();
        television2.watchTV();

    }
}复制代码

输出信息

制作手机小米2
制作手机小米5
制作电视小米电视2
制作电视小米电视3
使用小米2打电话
使用小米5打电话
通过小米电视2看电视
通过小米电视3看电视复制代码

两者关系分析

对于工厂方法它是通过类继承创建抽象产品，并且是创建一种产品，如果创建新的产品，只需新建一个工厂重载工厂方法以创建新的产品。

在抽象工厂模式中，它实现了具体类生成的分离，因此增加具体工厂变的很简单，例如现在华为也生产手机和电视，我们只需要创建具体的工厂类就可以了。对于工厂类抽象工厂模式是很容易增加的，但是如果小米公司现在业务又拓展了，开始做机器人，这样就困难了，我们需要将所有的工厂做修改，新增创建机器人的方法，如果之前工厂类很多，那么这个工作量就会很大了。

总而言之，这两种都是工厂模式，形式上很相似，最终的目的都是为了解耦，实现低耦合。而且它们之间很容易互相转换，当我们使用工厂模式后可能加了一个方法就成为了抽象工厂模式。不管你如何使用，只有达到我们代码低耦合，清晰明了的目的就可以。当然这是个人感觉。

好了，自己关于工厂模式的理解到这里已经总结完毕了。有问题欢迎留言指出，Have a wonderful day .

如需文章中所写代码，请移步GitHub查看