抽象工厂模式（Abstract Factory）
·
1.参考文献
参考文献1：http://blog.csdn.net/ipqxiang/archive/2007/12/20/1955677.aspx
参考文献2：http://baike.baidu.com/view/1580269.htm#sub1580269
参考3：http://en.wikipedia.org/wiki/Abstract_factory_pattern#Java
2.概念描述：
抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端(Client)提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象（只需要提供抽象工程实例）。
根据LSP原则，任何接受父类型的地方，都应当能够接受子类型（比如ConcreteFactory1和ConcreteFactory2都是AbstractFactory的子类型，因此父类型AbstractFactory的对象能够使用子类型进行实例化）。
因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例(要的是ProductA1，ProductA2等)，而不是这些抽象产品的实例(abstractFactoryA和abstractFactoryB)。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。
3.实例1：
运行结果：
4.实例1：java版本
//抽象工厂类，里面定义了创建AbstractProductA和AbstractProductB的方法
public interface AbstractFactory {
public AbstractProductA createProductA();
public AbstractProductB createProductB();
}
//抽象产品类，里面定义了这一类产品的一个方法paintA()
public interface AbstractProductA {
public void paintA();
}
//抽象产品类，里面定义了这一类产品的一个方法paintB()
public interface AbstractProductB {
public void paintB();
}
//用于创建产品A和B的具体工厂类，这个类实现了抽象工厂类
public class ConcreateFactoryA1B1 implements AbstractFactory {
/**
* 返回具体产品ProductA1
*/
@Override
public AbstractProductA createProductA() {
// TODO Auto-generated method stub
return new ProductA1();
}
/**
* 返回具体产品ProductB1
*/
@Override
public AbstractProductB createProductB() {
// TODO Auto-generated method stub
return new ProductB1();
}
}
public class ConcreateFactoryA1B2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
// TODO Auto-generated method stub
return new ProductA1();
}
@Override
public AbstractProductB createProductB() {
// TODO Auto-generated method stub
return new ProductB2();
}
}
public class ConcreateFactoryA2B1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
// TODO Auto-generated method stub
return new ProductA2();
}
@Override
public AbstractProductB createProductB() {
// TODO Auto-generated method stub
return new ProductB1();
}
}
public class ConcreateFactoryA2B2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
// TODO Auto-generated method stub
return new ProductA2();
}
@Override
public AbstractProductB createProductB() {
// TODO Auto-generated method stub
return new ProductB2();
}
}
/**
* 具体产品类，实现抽象产品类
*/
public class ProductA1 implements AbstractProductA {
//具体产品类重写了抽象产品类的paintA()方法
@Override
public void paintA() {
// TODO Auto-generated method stub
System.out.println("this is ProductA1");
}
}
public class ProductA2 implements AbstractProductA {
@Override
public void paintA() {
// TODO Auto-generated method stub
System.out.println("this is ProductA2");
}
}
public class ProductB1 implements AbstractProductB {
@Override
public void paintB() {
// TODO Auto-generated method stub
System.out.println("this is ProductB1");
}
}
public class ProductB2 implements AbstractProductB {
@Override
public void paintB() {
// TODO Auto-generated method stub
System.out.println("this is ProductB2");
}
}
/**
* 客户端类
* 使用抽象工厂创建抽象产品，具体创建哪一类产品在运行时定义
*/
public class Application {
public Application(AbstractFactory factory)
{
AbstractProductA productA=factory.createProductA();
productA.paintA();
AbstractProductB productB=factory.createProductB();
productB.paintB();
}
}
public class ApplicationRunner {
private static int FACTORY_TYPE=11;
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
AbstractFactory factory = null;
//在这个判断中定义需要使用哪一个具体工厂类来生产产品
switch (FACTORY_TYPE) {
case 11:
factory = new ConcreateFactoryA1B1();
break;
case 12:
factory = new ConcreateFactoryA1B2();
break;
case 21:
factory = new ConcreateFactoryA2B1();
break;
case 22:
factory = new ConcreateFactoryA2B2();
break;
}
new Application(factory);
}
}运行结果：
this is ProductA1
this is ProductB1
5.实例2：
运行结果：
6.抽象工厂的起源（PS:2011-11-2）
据说最早的应用是用来创建在不同操作系统的视窗环境下都能够运行的系统。比如在Windows与Unix系统下都有视窗环境的构件（如WinButton和LinuxButton），在每一个操作系统中，都有一个视窗构件组成的构件家族。我们可以通过一个抽象角色给出功能描述，而由具体子类给出不同操作系统下的具体实现，如图：
此模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候，可以从抽象工厂中选出相对系的系列来创建一个具体的工厂类别。
假设我们有一种产品接口 Button ，这种产品都支持多种系列，比如 Linux 系列和 Windows 系列。这样每个系列的产品分别是 LinuxButton, WinButton。为了可以在运行时刻创建一个系列的产品族，我们可以为每个系列的产品族建立一个工厂LinuxFactory 和 WinFactory 。每个工厂都有一个方法 CreateButton 并返回对应的产品，可以将这个方法抽象成一个接口 AbstractFactory 。这样在运行时刻我们可以选择创建需要的产品系列。
7.代码实例
7.1接口Button
public interface Button {
public void paint();
}7.2Linux系统下的Button：LinuxButton
public class LinuxButton implements Button {
@Override
public void paint() {
// TODO Auto-generated method stub
System.out.println("I'm a LinuxButton!");
}
}
7.3Windows系统下的Button：WinButton
public class WinButton implements Button {
@Override
public void paint() {
// TODO Auto-generated method stub
System.out.println("I'm a WinButton!");
}
}7.4视窗的抽象工厂类GUIFactory
public interface GUIFactory {
public Button createButton();
}7.5创建WinButton的工厂类：WinFactory
public class WinFactory implements GUIFactory {
@Override
public Button createButton() {
// TODO Auto-generated method stub
return new WinButton();//返回WinButton对象
}
}7.6创建LinuxButton的工厂类：LinuxFactory
public class LinuxFactory implements GUIFactory {
@Override
public Button createButton() {
// TODO Auto-generated method stub
return new LinuxButton();//返回LinuxButton对象
}
}
7.7创建Button的应用程序：Application
public class Application {
public Application(GUIFactory factory)
{
Button button=factory.createButton();//使用工程类来创建对象
button.paint();
}
}7.8主函数类：ApplicationRunner
public class ApplicationRunner {
private static int OS_TYPE=0;
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
new Application(createSpecOSFactory());
}
/**
* @param OS_TYPE
* 传入参数表示操作系统类型
* return 对应操作系统的工厂类
*/
public static GUIFactory createSpecOSFactory()
{
if(OS_TYPE==0)
return new WinFactory();
else
return new LinuxFactory();
}
}
北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台
更多推荐
0
0- 0
已为社区贡献4条内容
所有评论(0)