1 抽象工厂模式介绍
抽象工厂模式(Abstract Factory Pattern)也是创建型设计模式之一，抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
2 抽象工厂模式定义
抽象工厂模式：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类。
3 抽象工厂模式UML类图
抽象工厂模式UML类图如下：
抽象工厂模式-UML类图.jpg
抽象工厂模式的通用模式代码如下：
抽象产品类 A
public abstract class AbstractProductA {
/**
* 每个具体的产品子类需要实现的方法
*/
public abstract void method();
}
抽象产品类 B
public abstract class AbstractProductB {
/**
* 每个具体的产品子类需要实现的方法
*/
public abstract void method();
}
具体产品类 A1
public class ConcreteProdectA1 extends AbstractProductA{
@Override
public void method() {
System.out.println("具体产品 A1 的方法");
}
}
具体产品类 A2
public class ConcreteProdectA2 extends AbstractProductA{
@Override
public void method() {
System.out.println("具体产品 A2 的方法");
}
}
具体产品类 B1
public class ConcreteProdectB1 extends AbstractProductB{
@Override
public void method() {
System.out.println("具体产品 B1 的方法");
}
}
具体产品类 B2
public class ConcreteProdectB2 extends AbstractProductB{
@Override
public void method() {
System.out.println("具体产品 B2 的方法");
}
}
抽象工厂类
public abstract class AbstractFactory {
/**
* 创建产品A的方法
* @return 产品A对象
*/
public abstract AbstractProductA createProductA();
/**
* 创建产品B的方法
* @return 产品B对象
*/
public abstract AbstractProductB createProductB();
}
抽象工厂类 1
public class ConcreteFactory1 extends AbstractFactory{
@Override
public AbstractProductA createProductA() {
//生产具体产品 A1
return new ConcreteProdectA1();
}
@Override
public AbstractProductB createProductB() {
//生产具体产品 B1
return new ConcreteProdectB1();
}
}
抽象工厂类 2
public class ConcreteFactory2 extends AbstractFactory{
@Override
public AbstractProductA createProductA() {
//生产具体产品 A2
return new ConcreteProdectA2();
}
@Override
public AbstractProductB createProductB() {
//生产具体产品 B2
return new ConcreteProdectB2();
}
}
客户端类
public class Client {
public static void main(String[] args){
AbstractFactory abstractFactory1 = new ConcreteFactory1();
AbstractProductA productA1 = abstractFactory1.createProductA();
productA1.method();
AbstractProductB productB1 = abstractFactory1.createProductB();
productB1.method();
AbstractFactory abstractFactory2 = new ConcreteFactory2();
AbstractProductA productA2 = abstractFactory2.createProductA();
productA2.method();
AbstractProductB productB2 = abstractFactory2.createProductB();
productB2.method();
}
}
//输出结果：
//具体产品 A1 的方法
//具体产品 B1 的方法
//具体产品 A2 的方法
//具体产品 B2 的方法
从上面的代码可以看出 虽然抽象工厂方法模式的类繁多，但是可以分为四类：
-
AbstractFactory：抽象工厂角色，声明一组用于创建一种产品的方法，每一个方法对应一种产品，如创建产品A和产品B。 -
ConcreteFactory：具体工厂角色，它实现了在抽象工厂中定义的创建产品的方法，生成一组具体产品，这些产品构成了一个产品种类，每一个产品都位于某个产品等级结构中，如ConcreteFactory1和ConcreteFactory2。 -
AbstractProduct：抽象产品角色，他为每种产品声明接口，如AbstractProductA和AbstractProductB。 -
ConcreteProdectB：具体产品角色，他定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法，如ConcreteProdectA1、ConcreteProdectA2、ConcreteProdectB1和ConcreteProdectB2。
4 抽象工厂模式使用示例
华为和小米都有生产平板和手机两个产品线，现在我们通过抽象工厂模式来解决增加产品线的问题。
手机和平板的抽象工厂模式-UML类图.jpg
我们结合UML类图看下具体的代码：
抽象产品
首先我们定义两个抽象的产品平板和手机
//平板
public abstract class Ipad {
public abstract void method();
}
//手机
public abstract class Phone {
public abstract void method();
}
具体产品
具体产品为华为和小米的平板和手机
public class HwIpad extends Ipad {
@Override
public void method() {
System.out.println("生产华为iPad");
}
}
public class HwPhone extends Phone{
@Override
public void method() {
System.out.println("生产华为手机");
}
}
public class XmIpad extends Ipad {
@Override
public void method() {
System.out.println("生产小米ipad");
}
}
public class XmPhone extends Phone {
@Override
public void method() {
System.out.println("生产小米手机");
}
}
抽象工厂
创建一个生产手机和平板的抽象工厂
public abstract class AbstractFactory {
/**
* 创建平板
* @return 平板对象
*/
public abstract Ipad createIpad();
/**
* 创建手机
* @return 手机对象
*/
public abstract Phone createPhone();
}
具体工厂
具体工厂来生产手机和平板
//华为工厂
public class HwFactory extends AbstractFactory {
@Override
public Ipad createIpad() {
return new HwIpad();
}
@Override
public Phone createPhone() {
return new HwPhone();
}
}
//小米工厂
public class XmFactory extends AbstractFactory {
@Override
public Ipad createIpad() {
return new XmIpad();
}
@Override
public Phone createPhone() {
return new XmPhone();
}
}
客户端
public class Client {
public static void main(String[] args) {
AbstractFactory hwFactory = new HwFactory();
hwFactory.createIpad().method();
hwFactory.createPhone().method();
System.out.println("-----------------");
AbstractFactory xmFactory = new XmFactory();
xmFactory.createIpad().method();
xmFactory.createPhone().method();
}
}
//生产华为iPad
//生产华为手机
//-----------------
//生产小米ipad
//生产小米手机
5 抽象工厂模式的使用场景
一个对象族(或是一组没有任何关系的对象)都有相同的约束，则可以使用抽象工厂模式。
6 总结
抽象工厂方法模式的优点：
- 分离接口与实现，具体类的创建实例过程与客户端分离，客户端通过工厂的抽象接口操纵实例，客户端只需要知道工厂类是谁就可以创建一个需要的对象。
- 产品族内的约束为非公开性，具体的产品族内的约束是在工厂内的。
抽象工厂方法模式的缺点：
- 类文件的爆炸性增加；
- 不太容易扩展新的产品类，如果增加新的产品族则也需要修改抽象工厂和所有的具体工厂。