1 定义:
1.1 定义:抽象工厂模式(AbstractFactory Pattern)Provide an interface ofr creating families of related or dependentobjects without specifying their concrete class.(为创建一组相关或相互依赖的对象提供一个接口,而且无需指定它们的具体类。)
1.2 通用类图:
1.3 通用代码:
抽象工厂模式是工厂方法模式的升级版本,在有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。我们来看看抽象工厂的通用源代码,首先有两个互相影响的产品线(也叫做产品族,产品种类),例如汽车的左侧门和右侧门,这两个应该是数量相等的——两个对象之间的约束,每个型号的车门都是不一样的,这是产品等级结构约束的。
类图如下:
public abstract class AbstractProductA {
//每个产品共有的方法
publicvoid shareMethod(){
}
//每个产品相同方法,不同实现
publicabstract void doSomething();
}
public abstract class AbstractProductB {
//每个产品共有的方法
publicvoid shareMethod(){
}
//每个产品相同方法,不同实现
publicabstract void doSomething();
}
public class ProductA_Level_1 extendsAbstractProductA {
@Override
publicvoid doSomething() {
System.out.println("产品A等级1的实现方法");
}
}
public class ProductA_Level_2 extendsAbstractProductA {
@Override
publicvoid doSomething() {
System.out.println("产品A等级2的实现方法");
}
}
public class ProductB_Level_1 extendsAbstractProductB {
@Override
publicvoid doSomething() {
System.out.println("产品B等级1的实现方法");
}
}
public class ProductB_Level_2 extendsAbstractProductB {
@Override
publicvoid doSomething() {
System.out.println("产品B等级2的实现方法");
}
}
public abstract class AbstractCreator {
//创建A产品家族
publicabstract AbstractProductA createProductA();
//创建B产品家族
publicabstract AbstractProductB createProductB();
}
public class Creator_Level_1 extendsAbstractCreator {
//只生产产品等级为1的A产品
publicAbstractProductA createProductA() {
returnnew ProductA_Level_1();
}
//只生产铲平等级为1的B产品
publicAbstractProductB createProductB() {
returnnew ProductB_Level_1();
}
}
public class Creator_Level_2 extendsAbstractCreator {
//只生产产品等级为2的A产品
publicAbstractProductA createProductA() {
returnnew ProductA_Level_2();
}
//只生产铲平等级为2的B产品
publicAbstractProductB createProductB() {
returnnew ProductB_Level_2();
}
}
2 优点
2.1 封装性,每个产品的实现类不是高层模块要关心的,它要关心的是:接口,抽象,它不关心对象是如何创建出来的,这是由工厂类创建的,只要知道工厂类是谁,我就能创建出一个需要的对象,省时省力。
2.2 产品族内的约束为非公开状态。在抽象工厂模式中应该有这样一个约束:约束不同等级产品的生产比例。而这样的生产过程对调用工厂类的高层模式来说是透明的,它不需要知道这个约束,它就是要一个这样的产品,具体的产品族内的约束是在工厂内实现的。
3 缺点
最大缺点:产品族扩展非常困难。例如:如果要增加一个产品C,也就是产品家族由原来的2个增加到3个,我们的程序将会大大改动:抽象类AbstractorCreator要增加一个方法createProductC(),然后两个实现类都要修改,这严重违反了开闭原则,而且我们一直说明抽象类和接口是一个契约。而这段代码却显然是“有毒代码”。
4 应用场景
使用场景定义非常简单:一个对象簇(或是一组没有任何关系的对象)都有相同的约束,则可以使用抽象工厂模式。例如:一个文本编辑器和一个图片处理器,都是软件实体,但是在*nix下的文件编辑器和windows下的文本编辑器虽然功能和界面都相同,但代码实现是不同的,图片处理器也有类似情况。也就是有了共同的约束条件:操作系统类型。(或分类标准)
5 注意事项
在上述缺点论述中,提到抽象工厂模式的产品族扩展比较困难,但是要清楚是产品族扩展困难,而不是产品等级。在该模式下,产品等级是非常容易扩展的,增加一个产品等级,只要增加一个工厂类负责新增加出来的产品生产任务即可。也就是说横向扩展容易,纵向扩展困难。从横向扩展上来讲,抽象工厂模式还是符合开闭原则的。
6 扩展
暂无
7 范例
(高低等级、功能机智能机)
类图如下:
package _03_AbstractFactory;
public interface Phone {
//获取手机类别
public void getKind();
//获取手机功能特性
public void getFunctions();
//获取手机等级
public void getLevel();
}
public abstract class AbstractFeaturePhone implements Phone{
public void getKind() {
System.out.println("我是功能机! ");
}
public void getFunctions() {
System.out.println("我只有有限的功能!");
}
}
public class FPhone_Level_High extends AbstractFeaturePhone{
@Override
public void getLevel() {
System.out.println("高端机");
}
}
public class FPhone_Level_Low extends AbstractFeaturePhone{
@Override
public void getLevel() {
System.out.println("低端机");
}
}
public abstract class AbstractSmartPhone implements Phone{
public void getKind() {
System.out.println("我是智能机! ");
}
public void getFunctions() {
System.out.println("我有无限多的功能!");
}
}
public class SPhone_Level_High extends AbstractSmartPhone{
@Override
public void getLevel() {
System.out.println("高端机");
}
}
public class SPhone_Level_Low extends AbstractSmartPhone{
@Override
public void getLevel() {
System.out.println("低端机");
}
}
public abstract class PhoneFactory {
public abstract Phone createFeaturePhone();
public abstract Phone createSmartPhone();
}
public class Creator_Level_High extends PhoneFactory{
public Phone createFeaturePhone(){
return new FPhone_Level_High();
}
public Phone createSmartPhone() {
return new SPhone_Level_High();
}
}
public class Creator_Level_Low extends PhoneFactory{
public Phone createFeaturePhone(){
return new FPhone_Level_Low();
}
public Phone createSmartPhone() {
return new SPhone_Level_Low();
}
}
public class Client {
public static void main(String[] args) {
//第一条产线,产高端机
PhoneFactory pfh = new Creator_Level_High();
//第二条产线,产高端机
PhoneFactory pfl = new Creator_Level_Low();
Phone sh = pfh.createSmartPhone();
sh.getLevel();
sh.getKind();
sh.getFunctions();
Phone fl = pfl.createFeaturePhone();
fl.getLevel();
fl.getKind();
fl.getFunctions();
}
}
结果:
高端机
我是智能机!
我有无限多的功能!
低端机
我是功能机!
我只有有限的功能!