设计模式-工厂方法模式

1 工厂方法模式介绍

工厂方法模式（Factory Pattern）是创建型设计模式之一。工厂方法模式是一种结构简单的模式，在我们平时的开发中应用很广发。其中工厂模式仔细区分的话，可以分为三种，分别是简单工厂模式、工厂方法模式以及抽象工厂模式。在这里我们学习工厂方法模式。

2 工厂方法模式定义

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

工厂方法模式UML类图：

工厂方法模式-UML类图

在工厂方法模式中主要分为四大模块：

• Product:抽象产品类，是工厂方法模式所创建的产品的父类;
• ConcreteProduct:具体产品类，实为实现抽象产品的某个具体产品的对象，现Product接口;
• Factory:抽象工厂类，为工厂方法模式的核心，该方法返回一个Product类型的对象;
• ConcreteFactory:具体工厂类，其实现了具体的业务逻辑，返回ConcreteFactory实例。

3 工厂方法模式的使用场景

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式。

4 工厂方法模式使用示例

具体的工厂模式我们如下示例：

产品抽象类

public abstract class Product {
    /**
     * 产品类的抽象方法
     * 由具体的产品类去实现
     */
    public abstract void method();
}

具体的产品类

可以有多个产品类，都继承于抽象产品类，实现其抽象方法

public class ConcreteProductA extends Product{
    @Override
    public void method() {
       System.out.println("我是具体的产品A");
    }
}

public class ConcreteProductB extends Product{
    @Override
    public void method() {
       System.out.println("我是具体的产品B");
    }
}

抽象工厂类

public abstract class Factory {
    /**
     * 抽象工厂方法
     * 具体生产什么由子类去实现
     *
     * @return 具体产生的对象
     */
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

具体工厂类

具体如何生产一个产品的对象，是由具体的工厂类实现的。

public class ConcreteFactory extends Factory{
    /**
     * 抽象工厂方法
     * 具体生产什么由子类去实现
     * @param clz  产品对象类的类型
     * @return 具体的产品对象
     */
    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product p = null;
        try {
            p = (Product)Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) p;
    }
}

客户端类

public class Client {
    public static void main(String[] args){
        Factory factory = new ConcreteFactory();
        Product pA = factory.createProduct(ConcreteProductA.class);
        pA.method();
        Product pB = factory.createProduct(ConcreteProductB.class);
        pB.method();
    }
}

//打印的日志：
//我是具体的产品A
//我是具体的产品B

从客户端类中可以看出，需要哪一个类的对象就传入哪一个类的类型即可，这种方法比较简单，动态实现。当然也可以为每一个产品都定义一个具体的工厂来实现。具体实现如下：

public class ConcreteFactoryA extends Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class Client {
    public static void main(String[] args){
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.method();
    }
}

5 总结

我们可以看到工厂方法模式是完全符合设计原则的，其降低了对象之间的耦合度，而且工厂方法模式依赖于抽象的架构，将实例化的任务交由子类去完场，有非常好的扩展性。

优点

• 客户端想要创建一个对象，只要知道其名称就看了；
• 扩展性高，在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类；
• 屏蔽产品的具体实现，客户端只关心产品的接口。

缺点

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。