设计模式学习 - 抽象工厂模式

抽象工厂模式介绍

抽象工厂模式（Abstract Factory Pattern),也是创建型设计模式之一。抽象工厂模式源于以前对不同操作系统的图形化操作方案，对于每一个操作系统，其本身构成一个产品类，而文本和按钮控件也构成一个产品类，两种产品类两种变化，各自有自己的特性。

抽象工厂模式的定义

为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定他们具体类

抽象工厂模式的使用场景

一个对象族有相同的约束时可以使用抽象工厂模式。举个例子，Android、ios下都有短信和拨号软件，两者都属于软件范畴，但是，它们所在的操作系统平台不一样，即便是同一家公司出品的软件，其代码实现逻辑也是不同的，这时候就可以考虑抽象工厂来产生Android、ios下的短信和拨号平台。

抽象工厂模式的UML类图

UML图角色介绍：

• AbstractFactory: 抽象工厂角色，声明一组用于创建一种产品的方法，每一种方法对于一个产品。
• ConcreateFactory : 具体工厂角色，实现了在抽象工厂种定义的方法，生产具体的产品。
• AbstractProduct : 抽象产品角色，他为每种产品声明接口。
• ConcreteProduct : 具体产品角色，定义具体工厂生产的具体产品对象，实现抽象产品接口种声明的业务方法。

通用代码

创建顺序：AbstractProduct角色->ConcreteProduct角色->AbstractFactory角色->ConcreteFactory角色（可参考）

AbstractProduct角色

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/03
 *     desc   : 抽象产品类A
 * </pre>
 */
public abstract class AbstractProductA {
    public abstract void method();
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/03
 *     desc   : 抽象产品类B
 * </pre>
 */
public abstract class AbstractProductB {
    public abstract void method();
}

ConcreteProduct角色

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/03
 *     desc   : 具体产品类A1
 * </pre>
 */
public class ConcreteProductA1 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("具体产品类A1的方法");
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/03
 *     desc   : 具体产品类A2
 * </pre>
 */
public class ConcreteProductA2 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("具体产品A2的方法");
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/03
 *     desc   : 具体产品类B1
 * </pre>
 */
public class ConcreteProductB1 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("具体产品B1的方法");
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/03
 *     desc   : 具体产品类B2
 * </pre>
 */
public class ConcreteProductB2 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("具体产品B2的方法");
    }
}

AbstractFactory角色

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 抽象工厂类
 * </pre>
 */
public abstract class AbstractFactory {
    /**
     * 创建产品A的对象
     * @return
     */
    public abstract AbstractProductA createProductA();

    /**
     * 创建产品B的对象
     * @return
     */
    public abstract AbstractProductB createProductB();
}

ConcreteFactory角色

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 具体工厂类
 * </pre>
 */
public class ConcreateFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 具体工厂类
 * </pre>
 */
public class ConcreateFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

抽象工厂方法模式的简单实现

背景：Q3,Q5,Q7都是一个车系，但三者间的零部件还是有很大的差距，就拿Q3和Q7来说，Q3的轮胎是普通轮胎，Q7的轮胎是越野型轮胎；Q3的发动机是国产发动机，Q7的发动机是进口发动机；Q3的制动系统是普通的制动系统，而Q7则使用性能极好的制动系统。Q3，Q7对应的是一系列车，而发动机、轮胎、制动系统则对应的是一系列零部件，两者是两种不同的产品类型，故这时候就可以将抽象工厂模式应用其中，首先，汽车工厂需要生产轮胎，发动机，制动系统这3种部件，故先定义这3种部件，即我们从AbstractProduct角色开始创建。

AbstractProduct角色

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 抽象轮胎产品
 * </pre>
 */
public interface ITire {
    /**
     * 轮胎
     */
    void tire();
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 抽象发动机产品
 * </pre>
 */
public interface IEngine {
    /**
     * 发动机
     */
    void engine();
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 抽象制动系统产品
 * </pre>
 */
public interface IBrake {
    /**
     * 制动系统
     */
    void brake();
}

ConcreteProduct角色：具体产品

轮胎相关

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 普通轮胎
 * </pre>
 */
public class NormalTire implements ITire{

    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 越野轮胎
 * </pre>
 */
public class SUVTire implements ITire{
    @Override
    public void tire() {
        System.out.println("越野轮胎");
    }
}

发动机相关

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 国产发动机
 * </pre>
 */
public class DomesticEngine implements IEngine{
    @Override
    public void engine() {
        System.out.println("国产发动机");
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 进口发动机
 * </pre>
 */
public class ImportEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("进口发动机");
    }
}

制动系统相关

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 普通制动
 * </pre>
 */
public class NormalBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 高级制动
 * </pre>
 */
public class SeniorBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}

AbstractFactory角色：生产轮胎、发动机、制动系统

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 抽象工厂类
 * </pre>
 */
public abstract class CarFactory {
    /**
     * 生产轮胎
     * @return 轮胎
     */
    public abstract ITire createTire();

    /**
     * 生产发动机
     * @return 发动机
     */
    public abstract IEngine createEngine();

    /**
     * 产生制动系统
     * @return 制动系统
     */
    public abstract IBrake createBrake();
}

ConcreateFactory角色：具体工厂，Q3生产工厂、Q7生产工厂

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : Q3工厂类
 * </pre>
 */
public class Q3Factory extends CarFactory {
    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEngine() {
        return new DomesticEngine();
    }

    @Override
    public IBrake createBrake() {
        return new NormalBrake();
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : Q7工厂类
 * </pre>
 */
public class Q7Factory extends CarFactory{
    @Override
    public ITire createTire() {
        return new SUVTire();
    }

    @Override
    public IEngine createEngine() {
        return new ImportEngine();
    }

    @Override
    public IBrake createBrake() {
        return new SeniorBrake();
    }
}

Client角色：测试

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/04/06
 *     desc   : 客户类
 * </pre>
 */
public class Client {
    public static void main(String [] args){
        //构建一个生产Q3的工厂
        CarFactory factoryQ3 = new Q3Factory();
        factoryQ3.createTire().tire();
        factoryQ3.createEngine().engine();
        factoryQ3.createBrake().brake();

        System.out.println("------------------");
        //构造一个生产Q7的工厂
        CarFactory factoryQ7 = new Q7Factory();
        factoryQ7.createTire().tire();
        factoryQ7.createEngine().engine();
        factoryQ7.createBrake().brake();
    }
}

输出结果：

普通轮胎
国产发动机
普通制动
------------------
越野轮胎
进口发动机
高级制动

总结

• 优点： 分离接口和实现，客户端使用抽象工厂来创建需要的对象，而客户端根本不知道具体的实现是谁，客户端只是面向产品的接口编程。使其从具体的产品实现中解耦，同时基于接口和实现的分离，使抽象工厂方法模式在切换产品类时更加灵活、容易
• 缺点：
• 类文件的爆炸性增加
• 不太容易扩展新的产品类。因为每当增加一个产品类就需要修改抽象工厂，那么所有的具体工厂类均会被修改。

本文相关源码
注：选自《Android源码设计模式》