【05】【抽象工厂模式】
Abstract Factory（抽象工厂模式）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
类型：创建型模式
类图：
使用方法：
抽象产品类A
public abstract class AbstractProductA {
/**
* 每个产品的公有方法
*/
public void shareMethod() {
// 业务逻辑
}
/**
* 每个产品相同的方法，不同的实现
*/
public abstract void doSomething();
}
产品A1的实现类
public class ProductA1 extends AbstractProductA {
@Override
public void doSomething() {
// 产品A1的实现方法
}
}
产品A2的实现类
public class ProductA2 extends AbstractProductA {
@Override
public void doSomething() {
// 产品A2的实现方法
}
}
抽象产品类B
public abstract class AbstractProductB {
/**
* 每个产品的公有方法
*/
public void shareMethod() {
// 业务逻辑
}
/**
* 每个产品相同的方法，不同的实现
*/
public abstract void doSomething();
}
产品B1的实现类
public class ProductB1 extends AbstractProductB {
@Override
public void doSomething() {
// 产品B1的实现方法
}
}
产品B2的实现类
public class ProductB2 extends AbstractProductB {
@Override
public void doSomething() {
// 产品B2的实现方法
}
}
抽象工厂类
public abstract class AbstractCreator {
/**
* 创建A产品家族
* @return A产品
*/
public abstract AbstractProductA createProductA();
/**
* 创建B产品家族
* @return B产品
*/
public abstract AbstractProductB createProductB();
}
产品等级1的实现类
public class CreateA extends AbstractCreator {
/**
* 只生产产品等级为A1的产品
*
* @return 产品等级为A1的产品
*/
@Override
public AbstractProductA createProductA() {
return new ProductA1();
}
/**
* 只生产产品等级为B1的产品
*
* @return 产品等级为B1的产品
*/
@Override
public AbstractProductB createProductB() {
return new ProductB1();
}
}
产品等级2的实现类
public class CreateB extends AbstractCreator {
/**
* 只生产产品等级为A2的产品
*
* @return 产品等级为A2的产品
*/
@Override
public AbstractProductA createProductA() {
return new ProductA2();
}
/**
* 只生产产品等级为B2的产品
*
* @return 产品等级为B2的产品
*/
@Override
public AbstractProductB createProductB() {
return new ProductB2();
}
}
场景类
public class Client {
public static void main(String[] args) {
// 定义两个工厂
AbstractCreator creatorA = new CreateA();
AbstractCreator creatorB = new CreateB();
// 生产A1对象
AbstractProductA a1 = creatorA.createProductA();
// 生产A1对象
AbstractProductA a2 = creatorB.createProductA();
// 生产B1对象
AbstractProductB b1 = creatorA.createProductB();
// 生产B2对象
AbstractProductB b2 = creatorB.createProductB();
// ......
}
}
优点：
1、封装性，每个产品的实现类不是高层模块要关心的。
2、产品族内的约束为非公开状态。
缺点：
1、产品族扩展非常困难。
使用场景：
一个对象族或是一组没有任何关系的对象都有相同的约束，则可以使用抽象工厂模式。
注意事项：
产品族扩展困难，产品等级非常容易扩展，也就是横向扩展容易，纵向扩展困难。
【首发】【http://my.oschina.net/u/245653/blog/385935】