概述
在软件系统中,经常面临着“一系列相互依赖的对象”的创建工作;同时由于需求的变化,往往存在着更多系列对象的创建工作。如何应对这种变化?如何绕过常规的对象的创建方法(new),提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合?这就是我们要说的抽象工厂模式。
意图
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
模型图
逻辑模型:
物理模型:
实现要点
- 抽象工厂将产品对象的创建延迟到它的具体工厂的子类。
- 如果没有应对“多系列对象创建”的需求变化,则没有必要使用抽象工厂模式,这时候使用简单的静态工厂完全可以。
- 系列对象指的是这些对象之间有相互依赖、或作用的关系,例如游戏开发场景中的“道路”与“房屋”的依赖,“道路”与“地道”的依赖。
- 抽象工厂模式经常和工厂方法模式共同组合来应对“对象创建”的需求变化。
- 通常在运行时刻创建一个具体工厂类的实例,这一具体工厂的创建具有特定实现的产品对象,为创建不同的产品对象,客户应使用不同的具体工厂。
- 把工厂作为单件,一个应用中一般每个产品系列只需一个具体工厂的实例,因此,工厂通常最好实现为一个单件模式。
- 创建产品,抽象工厂仅声明一个创建产品的接口,真正创建产品是由具体产品类创建的,最通常的一个办法是为每一个产品定义一个工厂方法,一个具体的工厂将为每个产品重定义该工厂方法以指定产品,虽然这样的实现很简单,但它确要求每个产品系列都要有一个新的具体工厂子类,即使这些产品系列的差别很小。
优点
- 分离了具体的类。抽象工厂模式帮助你控制一个应用创建的对象的类,因为一个工厂封装创建产品对象的责任和过程。它将客户和类的实现分离,客户通过他们的抽象接口操纵实例,产品的类名也在具体工厂的实现中被分离,它们不出现在客户代码中。
- 它使得易于交换产品系列。一个具体工厂类在一个应用中仅出现一次——即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置,这是因为一个抽象工厂创建了一个完整的产品系列,所以整个产品系列会立刻改变。
- 它有利于产品的一致性。当一个系列的产品对象被设计成一起工作时,一个应用一次只能使用同一个系列中的对象,这一点很重要,而抽象工厂很容易实现这一点。
缺点
- 难以支持新种类的产品。难以扩展抽象工厂以生产新种类的产品。这是因为抽象工厂几口确定了可以被创建的产品集合,支持新种类的产品就需要扩展该工厂接口,这将涉及抽象工厂类及其所有子类的改变。
适用性
在以下情况下应当考虑使用抽象工厂模式:
- 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有形态的工厂模式都是重要的。
- 这个系统有多于一个的产品族,而系统只消费其中某一产品族。
- 同属于同一个产品族的产品是在一起使用的,这一约束必须在系统的设计中体现出来。
- 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于实现。
应用场景
- 支持多种观感标准的用户界面工具箱(Kit)。
- 游戏开发中的多风格系列场景,比如道路,房屋,管道等。
- ……
代码如下:
抽象产品角色(我们定义了一个打印机)
- public abstract class Printer
- {
- public abstract void out();
- public abstract void getData(String msg);
- }
public abstract class Printer
{
public abstract void out();
public abstract void getData(String msg);
}
抽象工厂角色
- public interface PrinterFactory
- {
- public Printer getPrinter(String type);
- }
public interface PrinterFactory
{
public Printer getPrinter(String type);
}
具体工厂角色(我们定义4个具体工厂,一个是高速打印机工厂,一个是普通打印机工厂,一个是戴尔打印机工厂,一个是惠普打印机工厂)
- /*
- * a、生产高速打印机的工厂
- * b、可以是戴尔,也可以是惠普
- */
- public class BetterPrinterFactory implements PrinterFactory
- {
- public Printer getPrinter(String type)
- {
- if(type.equals("dell"))
- {
- return new DellBetterPrinter();
- }
- else if(type.equals("hp"))
- {
- return new HpBetterPrinter();
- }
- else
- {
- return null;
- }
- }
- }
- /*
- * a、生产普通打印机的工厂
- * b、可以是戴尔,也可以是惠普
- */
- public class CommonPrinterFactory implements PrinterFactory
- {
- public Printer getPrinter(String type)
- {
- if(type.equals("dell"))
- {
- return new DellCommonPrinter();
- }
- else if(type.equals("hp"))
- {
- return new HpCommonPrinter();
- }
- else
- {
- return null;
- }
- }
- }
- /*
- * a、生产戴尔打印机的工厂
- * b、可以是高速打印机,也可以是普通打印机
- */
- public class DellPrinterFactory implements PrinterFactory
- {
- public Printer getPrinter(String vendor)
- {
- if(vendor.equals("better"))
- {
- return new DellBetterPrinter();
- }
- else if(vendor.equals("common"))
- {
- return new DellCommonPrinter();
- }
- else
- {
- return null;
- }
- }
- }
- /*
- * a、生产惠普打印机的工厂
- * b、可以是高速打印机,也可以是普通打印机
- */
- public class HpPrinterFactory implements PrinterFactory
- {
- public Printer getPrinter(String vendor)
- {
- if(vendor.equals("better"))
- {
- return new HpBetterPrinter();
- }
- else if(vendor.equals("common"))
- {
- return new HpCommonPrinter();
- }
- else
- {
- return null;
- }
- }
- }
/*
* a、生产高速打印机的工厂
* b、可以是戴尔,也可以是惠普
*/
public class BetterPrinterFactory implements PrinterFactory
{
public Printer getPrinter(String type)
{
if(type.equals("dell"))
{
return new DellBetterPrinter();
}
else if(type.equals("hp"))
{
return new HpBetterPrinter();
}
else
{
return null;
}
}
}
/*
* a、生产普通打印机的工厂
* b、可以是戴尔,也可以是惠普
*/
public class CommonPrinterFactory implements PrinterFactory
{
public Printer getPrinter(String type)
{
if(type.equals("dell"))
{
return new DellCommonPrinter();
}
else if(type.equals("hp"))
{
return new HpCommonPrinter();
}
else
{
return null;
}
}
}
/*
* a、生产戴尔打印机的工厂
* b、可以是高速打印机,也可以是普通打印机
*/
public class DellPrinterFactory implements PrinterFactory
{
public Printer getPrinter(String vendor)
{
if(vendor.equals("better"))
{
return new DellBetterPrinter();
}
else if(vendor.equals("common"))
{
return new DellCommonPrinter();
}
else
{
return null;
}
}
}
/*
* a、生产惠普打印机的工厂
* b、可以是高速打印机,也可以是普通打印机
*/
public class HpPrinterFactory implements PrinterFactory
{
public Printer getPrinter(String vendor)
{
if(vendor.equals("better"))
{
return new HpBetterPrinter();
}
else if(vendor.equals("common"))
{
return new HpCommonPrinter();
}
else
{
return null;
}
}
}
具体产品角色(我们定义四个产品。戴尔高速打印机,戴尔普通打印机,惠普高速打印机,惠普普通打印机)
- /**
- * 戴尔高速打印机
- */
- public class DellBetterPrinter extends Printer
- {
- private final int MAX_CACHE_LINE = 10;
- private String[] printData = new String[MAX_CACHE_LINE * 2];
- private int dataNum = 0;
- @Override
- public void getData(String msg)
- {
- if(dataNum >= MAX_CACHE_LINE * 2)
- {
- System.out.println("输出队列已满,添加失败");
- }
- else
- {
- printData[dataNum++] = msg;
- }
- }
- @Override
- public void out()
- {
- while(dataNum>0)
- {
- System.out.println("戴尔高速打印机打印: "+printData[0]);
- System.arraycopy(printData,1,printData,0,--dataNum);
- }
- }
- }
- /**
- * 戴尔普通打印机
- */
- public class DellCommonPrinter extends Printer
- {
- private final int MAX_CACHE_LINE = 10;
- private String[] printData = new String[MAX_CACHE_LINE];
- private int dataNum = 0;
- @Override
- public void getData(String msg)
- {
- if(dataNum >= MAX_CACHE_LINE)
- {
- System.out.println("输出队列已满,添加失败");
- }
- else
- {
- printData[dataNum++] = msg;
- }
- }
- @Override
- public void out()
- {
- while(dataNum>0)
- {
- System.out.println("戴尔普通打印机打印: "+printData[0]);
- System.arraycopy(printData,1,printData,0,--dataNum);
- }
- }
- }
- /**
- * 惠普高速打印机
- */
- public class HpBetterPrinter extends Printer
- {
- private final int MAX_CACHE_LINE = 10;
- private String[] printData = new String[MAX_CACHE_LINE * 2];
- private int dataNum = 0;
- @Override
- public void getData(String msg)
- {
- if(dataNum >= MAX_CACHE_LINE * 2)
- {
- System.out.println("输出队列已满,添加失败");
- }
- else
- {
- printData[dataNum++] = msg;
- }
- }
- @Override
- public void out()
- {
- while(dataNum>0)
- {
- System.out.println("惠普高速打印机打印: "+printData[0]);
- System.arraycopy(printData,1,printData,0,--dataNum);
- }
- }
- }
- /**
- * 惠普普通打印机
- */
- public class HpCommonPrinter extends Printer
- {
- private final int MAX_CACHE_LINE = 10;
- private String[] printData = new String[MAX_CACHE_LINE];
- private int dataNum = 0;
- @Override
- public void getData(String msg)
- {
- if(dataNum >= MAX_CACHE_LINE)
- {
- System.out.println("输出队列已满,添加失败");
- }
- else
- {
- printData[dataNum++] = msg;
- }
- }
- @Override
- public void out()
- {
- while(dataNum>0)
- {
- System.out.println("惠普普通打印机打印: "+printData[0]);
- System.arraycopy(printData,1,printData,0,--dataNum);
- }
- }
- }
/**
* 戴尔高速打印机
*/
public class DellBetterPrinter extends Printer
{
private final int MAX_CACHE_LINE = 10;
private String[] printData = new String[MAX_CACHE_LINE * 2];
private int dataNum = 0;
@Override
public void getData(String msg)
{
if(dataNum >= MAX_CACHE_LINE * 2)
{
System.out.println("输出队列已满,添加失败");
}
else
{
printData[dataNum++] = msg;
}
}
@Override
public void out()
{
while(dataNum>0)
{
System.out.println("戴尔高速打印机打印: "+printData[0]);
System.arraycopy(printData,1,printData,0,--dataNum);
}
}
}
/**
* 戴尔普通打印机
*/
public class DellCommonPrinter extends Printer
{
private final int MAX_CACHE_LINE = 10;
private String[] printData = new String[MAX_CACHE_LINE];
private int dataNum = 0;
@Override
public void getData(String msg)
{
if(dataNum >= MAX_CACHE_LINE)
{
System.out.println("输出队列已满,添加失败");
}
else
{
printData[dataNum++] = msg;
}
}
@Override
public void out()
{
while(dataNum>0)
{
System.out.println("戴尔普通打印机打印: "+printData[0]);
System.arraycopy(printData,1,printData,0,--dataNum);
}
}
}
/**
* 惠普高速打印机
*/
public class HpBetterPrinter extends Printer
{
private final int MAX_CACHE_LINE = 10;
private String[] printData = new String[MAX_CACHE_LINE * 2];
private int dataNum = 0;
@Override
public void getData(String msg)
{
if(dataNum >= MAX_CACHE_LINE * 2)
{
System.out.println("输出队列已满,添加失败");
}
else
{
printData[dataNum++] = msg;
}
}
@Override
public void out()
{
while(dataNum>0)
{
System.out.println("惠普高速打印机打印: "+printData[0]);
System.arraycopy(printData,1,printData,0,--dataNum);
}
}
}
/**
* 惠普普通打印机
*/
public class HpCommonPrinter extends Printer
{
private final int MAX_CACHE_LINE = 10;
private String[] printData = new String[MAX_CACHE_LINE];
private int dataNum = 0;
@Override
public void getData(String msg)
{
if(dataNum >= MAX_CACHE_LINE)
{
System.out.println("输出队列已满,添加失败");
}
else
{
printData[dataNum++] = msg;
}
}
@Override
public void out()
{
while(dataNum>0)
{
System.out.println("惠普普通打印机打印: "+printData[0]);
System.arraycopy(printData,1,printData,0,--dataNum);
}
}
}
制造出一个想要的工厂,去生产相对应的打印机
- /*
- * 制造出一个想要的工厂,去生产相对应的打印机
- */
- public class PrinterFactoryFactory
- {
- public PrinterFactory getPrintFactory(String type)
- {
- if(type.equals("common"))//造出一个生产普通打印机的工厂
- {
- return new CommonPrinterFactory();
- }
- else if(type.equals("better"))//造出一个生产高速打印机的工厂
- {
- return new BetterPrinterFactory();
- }
- else if(type.equals("dell"))//造出一个生产戴尔打印机的工厂
- {
- return new DellPrinterFactory();//造出一个生产惠普打印机的工厂
- }
- else if(type.equals("hp"))
- {
- return new HpPrinterFactory();
- }
- else
- {
- return null;
- }
- }
- }
/*
* 制造出一个想要的工厂,去生产相对应的打印机
*/
public class PrinterFactoryFactory
{
public PrinterFactory getPrintFactory(String type)
{
if(type.equals("common"))//造出一个生产普通打印机的工厂
{
return new CommonPrinterFactory();
}
else if(type.equals("better"))//造出一个生产高速打印机的工厂
{
return new BetterPrinterFactory();
}
else if(type.equals("dell"))//造出一个生产戴尔打印机的工厂
{
return new DellPrinterFactory();//造出一个生产惠普打印机的工厂
}
else if(type.equals("hp"))
{
return new HpPrinterFactory();
}
else
{
return null;
}
}
}
最后是测试了,我们定义一台计算机,由它调用工厂去生产我们需要的打印机。
需要什么品牌什么类型的打印机,只需要获得生产对应类型的工厂,再由工厂生产具体的打印机。这里我们有四个类型的工厂,打个比方,1)惠普公司本部可以有个工厂,它能生产惠普品牌的普通或高速型打印机:2)戴尔公司本部也有个工厂,它能生产惠普品牌的普通或高速型打印机:3)然而也有些高低端的代工厂愿意给那些大公司生产打印机,有专门生产普通打印机的低端工厂,它可以生产惠普、戴尔型号的低端打印机;4)当然也有高端型的代工厂,给惠普、戴尔生产它们的高端型品牌。
在这里,无论我们需要什么品牌什么类型的打印机,我们要么在这个品牌的工厂拿到,要么在高端或低端代工厂拿到。
- public class Computer
- {
- private Printer out;
- public Computer(Printer out)
- {
- this.out = out;
- }
- public void keyIn(String msg)
- {
- out.getData(msg);
- }
- public void print()
- {
- out.out();
- }
- public static void main(String[] args)
- {
- PrinterFactoryFactory pff = new PrinterFactoryFactory();
- PrinterFactory of = pff.getPrintFactory("common");
- Computer c = new Computer(of.getPrinter("hp"));
- c.keyIn("hello");
- c.keyIn("world");
- c.print();
- PrinterFactoryFactory pff2 = new PrinterFactoryFactory();
- PrinterFactory of2 = pff2.getPrintFactory("hp");
- Computer c2 = new Computer(of2.getPrinter("common"));
- c2.keyIn("hello");
- c2.keyIn("world");
- c2.print();
- }
- }
public class Computer
{
private Printer out;
public Computer(Printer out)
{
this.out = out;
}
public void keyIn(String msg)
{
out.getData(msg);
}
public void print()
{
out.out();
}
public static void main(String[] args)
{
PrinterFactoryFactory pff = new PrinterFactoryFactory();
PrinterFactory of = pff.getPrintFactory("common");
Computer c = new Computer(of.getPrinter("hp"));
c.keyIn("hello");
c.keyIn("world");
c.print();
PrinterFactoryFactory pff2 = new PrinterFactoryFactory();
PrinterFactory of2 = pff2.getPrintFactory("hp");
Computer c2 = new Computer(of2.getPrinter("common"));
c2.keyIn("hello");
c2.keyIn("world");
c2.print();
}
}
输出结果:
惠普普通打印机打印: hello
惠普普通打印机打印: world
惠普普通打印机打印: world
惠普普通打印机打印: hello
惠普普通打印机打印: world
惠普普通打印机打印: world
总结
总之,抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口,运用抽象工厂模式的关键点在于应对“多系列对象创建”的需求变化。一句话,学会了抽象工厂模式,你将理解OOP的精华:面向接口编程