【java设计模式】之 抽象工厂（Abstract Factory）模式

1. 女娲的失误

上一节学习了工厂模式，女娲运用了该模式成功创建了三个人种，可是问题来了，她发现没有性别……这失误也忒大了点吧……竟然没有性别，那岂不是……无奈，只好抹掉重来了，于是所有人都被消灭掉了，重新造人。

女娲开始分析了，既然要区别男女，那么生产人种的工厂（八卦炉）要重新改造了，因为一个设备要么全男性，要么全女性。所以只能将八卦炉拆开了，把原先的一个变两个，并且略加修改，变成女性八卦炉和男性八卦炉，这样就可以了。于是女娲开始准备生产了，她先画了个示意图如下：

这个图虽然有点大，但是不复杂，她将HumanFactory接口用两个新的接口继承，分别带有男性和女性特征；将原来具体的Human类也改成了抽象类，用两个具体的Human类去继承。下面我们看看女娲的实现：

先看Human接口和它的几个抽象类：

//定义抽象人类接口
public interface Human {
	public void getColor();
	public void talk();
	public void getSex(); //多了个性别
}

//定义抽象黄种人类
public abstract class AbstractYellowHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("Yellow color");
    }
    @Override
    public void talk() {
        System.out.println("Yellow people");
    }
}
//抽象黑种人和白种人就不写了，跟抽象黄种人道理一样
//略

//黄种人男性类
public class MaleYellowHuman extends AbstractYellowHuman {
    @Override
    public void getSex() {
        System.out.println("Yellow man!");
    }
}
//黄种人女性类略

以上省略了类似的代码，实现方式都一样，很简单，就不啰嗦了，到此为止，女娲把人种都定义好了，下面就是去定义八卦炉了：

//抽象工厂接口的定义
public interface HumanFactory {
	public Human createYellowHuman();
	public Human createBlackHuman();
	public Human createWhiteHuman();
}

//生产女性的八卦炉
public class FemaleFactory implements HumanFactory {
    @Override
    public Human createYellowHuman() {
        return new FemaleBlackHuman();
    }
    @Override
    public Human createBlackHuman() {
        return new FemaleBlackHuman();
    }
    @Override
    public Human createWhiteHuman() {
        return new FemaleWhiteHuman();
    }
}

//生产男性的八卦炉
public class MaleFactory implements HumanFactory {
    @Override
    public Human createYellowHuman() {
        return new MaleYellowHuman();
    }
    @Override
    public Human createBlackHuman() {
        return new MaleBlackHuman();
    }
    @Override
    public Human createWhiteHuman() {
        return new MaleWhiteHuman();
    }
}

好了，现在人种有了，八卦炉也有了，女娲终于可以再次造人了！

public class NvWa {
	public static void main(String[] args) {
		HumanFactory maleHumanFactory = new MaleFactory(); //第一条生产线：男性生产线
		HumanFactory femaleHumanFactory = new FemaleFactory(); //第二条生产线：女性生产线

                //生产线建立完毕，开始造人
		Human maleYellowHuman = maleHumanFactory.createYellowHuman(); //造黄色男性
		Human femaleYellowHuman = femaleHumanFactory.createYellowHuman(); //造黄色女性

		System.out.println("--生产一个黄色女性--");
		femaleYellowHuman.getColor();
		femaleYellowHuman.talk();
		femaleYellowHuman.getSex();

		System.out.println("--生产一个黄色男性--");
		maleYellowHuman.getColor();
		maleYellowHuman.talk();
		maleYellowHuman.getSex();
		/*
		 * ……
		 */
	}
}

到这里，抽象工厂模式的思路算是理清了，下面看看抽象工厂模式的定义。

2. 抽象工厂模式的定义

抽象工厂模式（Abstract Factory Pattern）是一种比较常用的模式，其定义如下：

Provide an interface for creating families of related or dependent objects without specifying their concrete classes. 即为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。它的通用类图如下：

抽象工厂模式是工厂模式的升级版，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。我们来看看抽象工厂欧式的通用源代码，首先有两个互相影响的产品线（也叫产品族），例如汽车的左门和右门，这两个数量应该是相等的——两个对象之间的约束，每个型号的车门都是不一样的，这是产品等级结构约束的，我们先看看两个产品族的类图：

注意类图上的圈圈、框框相对应，两个抽象的产品类可以有关系，例如共同继承或实现一个抽象类或接口，其源代码如下：

public abstract class AbstractProductA {
    //每个产品共有的方法
    public void shareMethod() {

    }
    //每个产品相同的方法，不同的实现
    public abstract void doSomething();
}

两个具体的产品实现类的代码如下：

public class productA1 extends AbstractProductA {
    public abstract void doSomething(){
        System.out.println("产品A1的实现方法");
    }
} 

public class productA2 extends AbstractProductA {
    public abstract void doSomething(){
        System.out.println("产品A2的实现方法");
    }
} 


产品B与此类似，不再赘述。抽象工厂类AbstractCreator的职责是定义每个工厂要实现的功能，在通用代码中，抽象工厂类定义了两个产品族的产品创建，如下：


public abstract class AbstractCreator {
    //创建A产品家族
    public abstract AbstracProductA createProductA();
    //创建B产品家族
    public abstract AbstracProductB createProductB();
    //如果有N个产品族，这里就应该有N个创建方法
} 


如何创建一个产品呢？这是由具体的实现类来完成的，Creator1和Creator2代码如下：


public class Creator1 extends AbstractCreator {
    //只生产产品等级为1的A产品
    public AbstracProductA createProductA(){
        return new ProductA1();
    }
    //只生产产品等级为1的B产品
    public AbstracProductB createProductB() {
        return new ProductB1();
    }
} 

public class Creator2 extends AbstractCreator {
    //只生产产品等级为1的A产品
    public AbstracProductA createProductA(){
        return new ProductA2();
    }
    //只生产产品等级为1的B产品
    public AbstracProductB createProductB() {
        return new ProductB2();
    }
} 




注：有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品族的生产任务。


在具体的业务中就可以生产一个与实现无关的对象了，如：


public class AbstractFactoryTest {
    public static void main(String[] args) {
        AbstractCreator creator1 = new Creator1();
        AbstractCreator creator2 = new Creator2();
        AbstractProductA a1 = creator1.createProductA();
        AbstractProductA a2 = creator2.createProductA();

        AbstractProductB b1 = creator1.createProductB();
        AbstractProductB b2 = creator2.createProductB();

        //……
    }
}








3. 抽象工厂模式的优缺点


3.1 优点


1）封装性。每个产品的实现类不是高层模块要关心的，它要关心的是接口，是抽象，它不关心对象是如何创建出来的，这都由工厂类负责的，只要知道工厂类是谁，我就能创建一个需要的对象，省时省力。


2）产品族内的约束为非公开状态。例如生产男女比例的问题上，猜想女娲娘娘肯定有自己的打算，那么在抽象工厂模式中，这些约束都在工厂内里面实现的。


3.2 缺点


抽象工厂模式最大的缺点就是产品族扩展非常困难。如果我们要增加一个产品C，也就是说产品族由原来的A和B增加到3个，那么我们首先要在抽象类AbstractCreator中增加createProductC()方法，然后两个实现类都要修改……说到这里，已经知道了扩展的弊端了……


注意这里是产品族扩展比较困难，而不是产品等级扩展困难。产品等级扩展还是非常容易的，增加一个产品等级，只要增加一个工厂类负责新增加出来的产品生产任务即可。也就是说横向扩展容易，纵向扩展难。


抽象工厂模式就介绍这么多，如有错误之处，欢迎留言指正~


_____________________________________________________________________________________________________________________________________________________


-----乐于分享，共同进步！


-----更多文章请看：http://blog.csdn.net/eson_15
				


				
时间： 2024-11-08 19:15:35 

		


		


	

	
	

		


		
【java设计模式】之 抽象工厂（Abstract Factory）模式的相关文章


						

		

			

                面向对象设计——抽象工厂(Abstract Factory)模式
			

		

		

									

				定义 提供一个创建一系列相关或者相互依赖对象的接口,而无需指定它们具体的类.抽象工厂允许客户使用抽象的接口来创建一组相关的产品,而不需要知道或关心实际产出的具体产品是什么.这样一来,客户就能从具体的产品中被解耦. 适用场景 在以下情况可以使用Abstract Factory模式 一个系统要独立于它的产品的创建.组合和表示时 一个系统要由多个产品系列中的一个来配置时 当你要强调一系列相关的产品对象的设计以便进行联合使用时 当你提供一个产品类库,而只想显示它们的接口而不是实现时 UML图 抽象工厂模			

		

	

				

		

			

                【设计模式】——抽象工厂Abstract Factory
			

		

		

									

				模式意图 提供对象的使用接口,隐藏对象的创建过程. 模式结构 AbstractFactory 提供创建对象的接口. ConcreteFactory 提供真正创建对象的实现类,用于组合并创建不同的对象,实现一个产品族. AbstractProduct 提供对象的使用接口. ConcreteProduct 提供真正的适用对象,隐藏该对象的创建过程,是工厂创建的对象. Client 使用者,通过抽象工厂接口,使用不同的具体工厂方法创建对象组合,从而直接使用对象,无需关注对象的创建过程. 适合场景 1			

		

	

				

		

			

                【设计模式】创建型模式之抽象工厂Abstract Factory
			

		

		

									

				抽象工厂Abstract Factory是一种创建型设计模式,目的在于提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类.抽象工厂的类图如下,客户仅与抽象类定义的定义的接口交互,而不使用特定的具体类的接口.一个系统包含多种产品时,AbstractFactory声明创建各种抽象产品对象的操作接口,这些接口是直接暴露给Client的,而具体产品对象的创建则延迟到子类ConcreteFactory,Client面对的产品类是AbstractProduct,无需关系具体产品类是什么.在运			

		

	

				

		

			

                Java设计模式之抽象工厂(02)
			

		

		

									

				对工厂方法进行抽象.当增加新的产品时,不用改动工厂类.而是集成已有的工厂接口或者抽象工厂,创建新的工厂.这就是对扩展开发,对修改封闭. 1 package Pak; 2 3 public abstract class Automobile { 4 public abstract void Run(); 5 } package Pak; public class Bus extends Automobile { @Override public void Run() { System.out.pr			

		

	

				

		

			

                设计模式（一） 抽象工厂(Abstract Factory)
			

		

		

									

				1.定义 抽象工厂是一种常用的对象创建型设计模式.抽象工厂模式提供了一种方式,可以将一组具有统一主题的单独工厂封装起来,它提供一个创建一系列相关或相互依赖对象的接口,而无需制定它们具体的类. 2.结构 抽象工厂的结构图如下所示: AbstractFactory : 声明一个创建抽象产品对象的操作接口 ConcreteFactory : 实现创建具体产品对象的操作 AbstractProduct : 为一个类产品对象声明一个接口 ConcreteProduct : 定义一个将被相应的具体工厂创建产			

		

	

				

		

			

                Java 设计模式之抽象工厂模式
			

		

		

									

				抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂.该超级工厂又称为其他工厂的工厂.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类.每个生成的工厂都能按照工厂模式提供对象. 介绍 意图 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 主要解决 主要解决接口选择的问题. 何时使用 系统的产品有多于一个的产品族,而系统只消费其中某一族的产品			

		

	

				

		

			

                【java设计模式】之 工厂（Factory）模式
			

		

		

									

				1.工厂模式的定义 工厂模式使用的频率非常高,我们在开发中总能见到它们的身影.其定义为:Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.即定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类			

		

	

				

		

			

                JAVA设计模式之抽象工厂模式 （转）
			

		

		

									

				前面已经介绍过简单工厂模式和工厂方法模式,这里继续介绍第三种工厂模式-抽象工厂模式,还是以汽车的制造为例. 例子背景: 随着客户的要求越来越高,宝马车需要不同配置的空调和发动机等配件.于是这个工厂开始生产空调和发动机,用来组装汽车.这时候工厂有两个系列的产品:空调和发动机.宝马320系列配置A型号空调和A型号发动机,宝马230系列配置B型号空调和B型号发动机. 概念: 抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象.比如宝马320系列使用空调型号A和发动机型号A,而宝			

		

	

				

		

			

                工厂模式[3] 抽象工厂 Abstract Factory
			

		

		

									

				简介 1.简单工厂,或静态工厂,产品接口 定义:专门定义一个类来负责创建其他类的实例,被创建的实例通常具有共同的父类或实现同一接口 优点:客户端可以直接消费产品,而不必关心具体产品的实现(不关心对象的构造方法是怎么new的),消除了客户端直接创建产品对象的责任,实现了对责任的分割. 缺点:工厂类记录了所有产品的创建逻辑,一旦不能正常工作,整个系统都会受到影响:而且当产品种类多.结构复杂的时候,把所有创建工作放进一个工厂中来,会使后期程序的扩展较为困难. 2.工厂方法,工厂接口+产品接口 定义:在			

		

	

				

		

			

                浅谈JAVA设计模式之——抽象工厂模式(AbstractFactoty)
			

		

		

									

				转载请注明出处:http://blog.csdn.net/l1028386804/article/details/45440309 一.概述: 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 二.为何使用     工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见. 为什么工厂模式是如此常用?因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也