《Android源码设计模式》之抽象工厂模式

####抽象工厂模式介绍
　　抽象工厂模式（Abstract Factory Pattern），也是创建型设计模式之一。之前介绍过工厂方法模式，那么这个抽象工厂又是怎么回事呢？抽象工厂模式起源于以前对不同操作系统的图形化解决方案，如不同操作系统中的按钮和文本框控件其实现不同，展示效果也不一样，对于每一个操作系统，其本身就构成一个产品类，而按钮与文本框控件也构成一个产品类，两种产品类两种变化，各自有自己的特性，如Android中的Button和TextView，iOS中的Button和TextView，Windows Phone中的Button和TextView。
####抽象工厂模式的定义
　　为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定它们的具体类。
####抽象工厂模式的使用场景
　　一个对象族有相同的约束时可以使用抽象工厂模式。举个例子，Android、iOS、Windows Phone下都有短信软件和拨号软件，两者都属于Software软件的范畴，但是，它们所在的操作系统平台不一样，即便是同一家公司出品的软件，其代码的实现逻辑也是不同的，这时候就可以考虑使用抽象工厂方法模式来产生Android、iOS、Windows Phone下的短信软件和拨号软件。
####抽象工厂模式的UML类图


根据类图可以得出如下一个抽象工厂模式的通用模式代码。

抽象产品类A ``` package com.guifa.abstractfactorydemo;

public abstract class AbstractProductA {
/**
* 每个具体的产品子类需要实现的方法
*/
public abstract void method();
}

<center>抽象产品类B

package com.guifa.abstractfactorydemo;

public abstract class AbstractProductB {
/**
* 每个具体的产品子类需要实现的方法
*/
public abstract void method();
}

<center>具体产品类A1

package com.guifa.abstractfactorydemo;

public class ConcreteProductA1 extends AbstractProductA {
@Override
public void method() {
System.out.println(“具体产品A1的方法”);
}
}

<center>具体产品类A2

package com.guifa.abstractfactorydemo;

public class ConcreteProductA2 extends AbstractProductA {
@Override
public void method() {
System.out.println(“具体产品A2的方法”);
}
}

<center>具体产品类B1

package com.guifa.abstractfactorydemo;

public class ConcreteProductB1 extends AbstractProductB {
@Override
public void method() {
System.out.println(“具体产品B1的方法”);
}
}

<center>具体产品类B2

package com.guifa.abstractfactorydemo;

public class ConcreteProductB2 extends AbstractProductB {
@Override
public void method() {
System.out.println(“具体产品B2的方法”);
}
}

<center>抽象工厂类

package com.guifa.abstractfactorydemo;

public abstract class AbstractFactory {
/**
* 创建产品A的方法
*
* @return 产品A对象
*/
public abstract AbstractProductA createProductA();

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

}

<center>具体工厂类1

package com.guifa.abstractfactorydemo;

public class ConcreteFactory1 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}

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

}

<center>具体工厂类2

package com.guifa.abstractfactorydemo;

public class ConcreteFactory2 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}

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

}

　　虽然抽象工厂方法模式的类繁多，但是主要还是分4类。
　　AbstractFactory：抽象工厂角色，它声明了一组用于创建一种产品的方法，每一个方法对应一种产品，如上述类图中的AbstractFactory中就定义了两个方法，分别创建产品A和产品B。
　　ConcreteFactory：具体工厂角色，它实现了在抽象工厂中定义的创建产品的方法，生成一组具体产品，这些产品构成了一个产品种类，每一个产品都位于某个产品等级结构中，如上述类图中的ConcreteFactory1和ConcreteFactory2。
　　AbstractProduct：抽象产品角色，它为每种产品声明接口，比如上述类图中的AbstractProductA和AbstractProductB。
　　ConcreteProduct：具体产品角色，它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法，如上述类图中的ConcreteProductA1、ConcreteProductA2、ConcreteProductB1和ConcreteProductB2。
　　
####抽象工厂模式的简单实现
　　举个例子，虽然Q3、Q5、Q7都是一个车系，但是三者之间的零部件差异还是很大，比如Q3发动机是国产的，Q7则是原装进口的；Q3轮胎是普通的轮胎，Q7则使用的是全尺寸越野轮胎；Q3使用的是普通的制动系统，Q7则使用的是性能极好的制动系统。Q3、Q7对应的是一系列车，而发动机、轮胎、制动系统则对应的是一系列零部件，两者是两种不同的产品类型，这时候就可以将抽象工厂模式应用到其中，首先，汽车工厂需要生成轮胎、发动机、制动系统这3种部件。
<center>抽象车厂类

package com.guifa.abstractfactorydemo;

public abstract class CarFactory {
/**
* 生产轮胎
*
* @return 轮胎
*/
public abstract ITire createTire();

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

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

}

　　这里我们为每一种零部件产品定义一个接口，并分别创建两个不同的实现类表示不同的零部件产品。
<center>轮胎相关类

package com.guifa.abstractfactorydemo;

public interface ITire {
/**
* 轮胎
*/
void tire();
}

package com.guifa.abstractfactorydemo;

public class NormalTire implements ITire{
@Override
public void tire() {
System.out.println(“普通轮胎”);
}
}

package com.guifa.abstractfactorydemo;

public class SUVTire implements ITire {
@Override
public void tire() {
System.out.println(“越野轮胎”);
}
}

<center>发动机相关类

package com.guifa.abstractfactorydemo;

public interface IEngine {
/**
* 发动机
*/
void engine();
}

package com.guifa.abstractfactorydemo;

public class DomesticEngine implements IEngine {
@Override
public void engine() {
System.out.println(“国产发动机”);
}
}

package com.guifa.abstractfactorydemo;

public class ImportEngine implements IEngine {
@Override
public void engine() {
System.out.println(“进口发动机”);
}
}

<center>制动系统相关类

package com.guifa.abstractfactorydemo;

public interface IBrake {
/**
* 制动系统
*/
void brake();
}

package com.guifa.abstractfactorydemo;

public class NormalBrake implements IBrake {
@Override
public void brake() {
System.out.println(“普通制动”);
}
}

package com.guifa.abstractfactorydemo;

public class SeniorBrake implements IBrake {
@Override
public void brake() {
System.out.println(“高级制动”);
}
}

　　对于生产Q3的工厂，其使用的零部件不同，而生产Q7的工厂呢，其零部件也不同。
<center>Q3工厂类

package com.guifa.abstractfactorydemo;

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();
}

}

<center>Q7工厂类

package com.guifa.abstractfactorydemo;

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客户类中模拟。
<center>客户类

package com.guifa.abstractfactorydemo;

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();
}

}

　　输出结果如下：
![这里写图片描述](https://img-blog.csdn.net/20180402175102065?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcXFfMTYyNDAzOTM=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
　　上面我们只是模拟了两个车系Q3和Q7的工厂，如果此时我们需要增加Q5的工厂呢？那么对应的轮胎、制动系统和发动机类又要增加，这里就可以看出抽象工厂方法模式的一个弊端，就是类的陡增，如果工厂类过多，势必导致类文件非常多，因此，在实际开发中一定要权衡慎用。
####总结
　　抽象工厂方法模式的优点：一个显著的优点是分离接口与实现，客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已，使其从具体的产品实现中解耦，同时基于接口与实现的分离，使抽象该工厂方法模式在切换产品类时，更加灵活、容易。
　　抽象工厂方法模式的缺点：一是类文件的爆炸性增加，二是不太容易扩展新的产品类，因为每当我们增加一个产品类就需要修改抽象工厂，那么所有的具体工厂类均会被修改。