一、介绍，定义
抽象工厂模式也是创建型模式之一，抽象工厂模式起源于对不同操作系统的图形化解决方案，如不同操作系统的按钮和文本框控件及其实现。
为创建一组相关或者相互依赖的对象提供接口，而不需要具体指定他们的具体类。
二、使用场景
一个对象族有相同的约束时可以使用抽象工厂模式。(比如Android、IOS、Windows Phone下都有短信和拨号软件)
三、UML类图
8.png
AbstractFactory：抽象工厂角色，声明了一组用于创建一种产品的方法，每个方法对应生产一种产品，上面生成产品A和B。
ConcreteFactory：具体工厂角色，实现了抽象工厂中定义的创建产品的方法，生成一组具体的产品，每一个产品又位于某个产品等级中。
AbstractProduct：抽象产品角色，定义了每种产品应有的方法
ConcreteProduct：具体的产品角色，定义了具体工厂生产的具体产品对象，实现抽象产品中声明的方法。
四、通用模式代码
抽象的产品A和B
public abstract class AbstractProductA {
public abstract void method();
}
public abstract class AbstractProductB {
public abstract void method();
}
具体的产品A1，A2，B1，B2
public class ConcreteProductA1 extends AbstractProductA {
@Override
public void method() {
System.out.println("产品A1的方法");
}
}
public class ConcreteProductA2 extends AbstractProductA {
@Override
public void method() {
System.out.println("产品A2的方法");
}
}
public class ConcreteProductB1 extends AbstractProductB {
@Override
public void method() {
System.out.println("产品B1的方法");
}
}
public class ConcreteProductB2 extends AbstractProductB {
@Override
public void method() {
System.out.println("产品B2的方法");
}
}
抽象工厂：
public abstract class AbstractFactory {
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
具体的工厂1和2
public class ConcreteFactory1 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
public class ConcreteFactory2 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
五、简单实现
上一篇讲到，小民开了个Audi车组装工厂。随着小民生意越做越大，发现Q3，Q5，Q7使用的零件各不相同，他们的零件又有差别，Q3的发动机是国产的，轮胎是铁的。Q7的发动机是外国的，轮胎是塑料的。不同的轮胎，不同的发动机，都也是一种产品类型，这时候就能用抽象产品模式：
首先 汽车工厂需要生产轮胎、发动机、制动系统这三种部件：
public abstract class CarFactory {
//轮胎
public abstract ITire createTire();
//发动机
public abstract IEngine createEngine();
//制动系统
public abstract IBrake createBrake(); //返回 制动系统 对象
}
这里我们为每一个零件定义一个接口，并分别创建两个不同的实现类表示不同的零部件产品
public interface ITire {
//轮胎接口
void tire();
}
public class NormalTire implements ITire {
@Override
public void tire() {
System.out.println("普通轮胎");
}
}
public class SUVTire implements ITire {
@Override
public void tire() {
System.out.println("越野轮胎");
}
}
public interface IEngin {
//发动机
void engine();
}
public class DomesticEngin implements IEngin {
@Override
public void engine() {
System.out.println("国产发动机");
}
}
public class ImportEngin implements IEngin {
@Override
public void engine() {
System.out.println("进口发动机");
}
}
public interface IBrake {
//制动系统
void brake();
}
public class NormalBrake implements IBrake {
@Override
public void brake() {
System.out.println("普通制动");
}
}
public class SeniorBrake implements IBrake {
@Override
public void brake() {
System.out.println("高级制动");
}
}
具体的 不同的生产 车厂 Q3 生产厂
public class Q3Factory extends CarFactory {
@Override
public ITire createTire() {
return new NormalTire(); //返回普通的轮胎类
}
@Override
public IEngin createEngine() {
return new DomesticEngin(); //返回国产发动机
}
@Override
public IBrake createBrake() {
return new NormalBrake(); //返回一般制动
}
}
具体的 不同的生产 车厂 Q7 生产厂
public class Q7Factory extends CarFactory {
@Override
public ITire createTire() {
return new SUVTire(); //返回SUV 车胎
}
@Override
public IEngin createEngine() {
return new ImportEngin(); //返回进口轮胎
}
@Override
public IBrake createBrake() {
return new SeniorBrake(); //返回高级制动
}
}
客户类 具体的实例化调用 生产
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//构造一个生产Q3 的工厂
CarFactory factoryQ3 = new Q3Factory();
factoryQ3.createTire().tire();
factoryQ3.createEngine().engine();
factoryQ3.createBrake().brake();
//构造一个 生产Q7 的 工厂
CarFactory factoryQ7 = new Q7Factory();
factoryQ7.createTire().tire();
factoryQ7.createEngine().engine();
factoryQ7.createBrake().brake();
}
}
结果如下
9.png
可见当需要添加Q5时，对应的零件类又要增加，这是此模式一个弊端，就是类的徒增，如果工厂类过多，势必导致文件非常多，开发中一定要权衡。
五、模式的优缺点:
优点：
分离接口与实现，客户端使用抽象工厂来创建需要的对象，二客户端根本不知道具体实现的是谁，客户端只是面向产品的接口编程而已，使其从具体的产品实现中解耦，同时基于接口与实现的分离，使抽象工厂方法模式在切换产品类时更加灵活，容易。
缺点：
一是文件的爆炸性增加，而是不太容易扩展新的产品类，因为每当我们增加一个产品类就需要修改抽象工厂，那么所以的具体工厂均会被修改。
