创建型模式--抽象工厂模式

 概述

    提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

 适用性

    1.一个系统要独立于它的产品的创建、组合和表示时。

    2.一个系统要由多个产品系列中的一个来配置时。

    3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。

    4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。
			

 参与者

    1.AbstractFactory
      声明一个创建抽象产品对象的操作接口。

    2.ConcreteFactory
      实现创建具体产品对象的操作。

    3.AbstractProduct
      为一类产品对象声明一个接口。

    4.ConcreteProduct
      定义一个将被相应的具体工厂创建的产品对象。
      实现AbstractProduct接口。

    5.Client
      仅使用由AbstractFactory和AbstractProduct类声明的接口

上面是一些很正统的解释，总结上面的概念，我可以认为抽象工厂模式是在以下情况适用：

举买车的例子：

买车的时候我们不会特意去关注车子的是如何组成的，以及车子组装的细节，因为这不是我们考虑的（也就是说一个

系统不依赖产品实例如何被创建、组合和表达 的细节）。

当然车的种类有很多种，因此我们有很多选项（系统的产品是多于一个族以上的，系统只消费其中一个）。

在消费时，如果我们选定了一种牌子的车型，那我们肯定是买下这整部车，而不是只消费一小部分；一种牌子的车

型，我们可以称它为一个产品族，因此同一个产品族的产品是在一起使用的。

                                           

                                 

代码描述：

发动机接口与具体实现：

/**
 * 发动机接口
 * @author Linhai Gu
 *
 */
public interface Motor {
	public void motor();
}

public class AoDiMotor implements Motor{
	private String name=null;
	public AoDiMotor(String name) {
		this.name=name;
	}
	@Override
	public void motor() {
		System.out.println(name+"的发动机");
	}

}

public class BaoMaMotor implements Motor{
	private String name=null;
	public BaoMaMotor(String name) {
		this.name=name;
	}
	@Override
	public void motor() {
		System.out.println(name+"的发动机");
	}
}

轮胎接口与具体实现：

/**
 * 轮胎接口
 * @author Linhai Gu
 *
 */
public interface Tyre {
	public void tyre();
}

public class AoDiTyre implements Tyre{

	private String name=null;
	public AoDiTyre(String name) {
		this.name=name;
	}
	@Override
	public void tyre() {
		System.out.println(name+"的轮胎");
	}

}

public class BaoMaTyre implements Tyre{
	private String name=null;
	public BaoMaTyre(String name) {
		this.name=name;
	}
	@Override
	public void tyre() {
		System.out.println(name+"的轮胎");
	}
}

方向盘接口与具体实现：

/**
 * 方向盘接口
 * @author Linhai Gu
 *
 */
public interface SteeringWhell {
	public void steeringWhell();
}

public class AoDiSteeringWhell implements SteeringWhell{
	
	private String name=null;
	public AoDiSteeringWhell(String name) {
		this.name=name;
	}
	@Override
	public void steeringWhell() {
		System.out.println(name+"的方向盘");
	}

}

public class BaoMaSteeringWhell implements SteeringWhell{
	private String name=null;
	public BaoMaSteeringWhell(String name) {
		this.name=name;
	}
	@Override
	public void steeringWhell() {
		System.out.println(name+"的方向盘");
	}
}

抽象工厂类：

public interface AbstractFactory {
	/*
	 * 创建Motor对象
	 */
	public Motor creatMotor();
	/*
	 * 创建Tyre对象
	 */
	public Tyre  creatTyre();
	/*
	 * 创建SteeringWhell对象
	 */
	public SteeringWhell creatSteeringWhell();

}

实现类：

public class AoDiFactory implements AbstractFactory{

	@Override
	public Motor creatMotor() {
		// TODO Auto-generated method stub
		return new AoDiMotor("奥迪");
	}

	@Override
	public Tyre creatTyre() {
		// TODO Auto-generated method stub
		return new AoDiTyre("奥迪");
	}

	@Override
	public SteeringWhell creatSteeringWhell() {
		// TODO Auto-generated method stub
		return new AoDiSteeringWhell("奥迪");
	}

}

public class BaoMaFactory implements AbstractFactory{

	@Override
	public Motor creatMotor() {
		// TODO Auto-generated method stub
		return new BaoMaMotor("宝马");
	}

	@Override
	public Tyre creatTyre() {
		// TODO Auto-generated method stub
		return new BaoMaTyre("宝马");
	}

	@Override
	public SteeringWhell creatSteeringWhell() {
		// TODO Auto-generated method stub
		return new BaoMaSteeringWhell("宝马");
	}

}

品牌厂家制造车类：

</pre><pre name="code" class="java">public class CarEngineer {
	//车需要的发动机
	private Motor motor=null;
	//车需要的轮胎
	private Tyre tyre=null;
	//车需要的方向盘
	private SteeringWhell steeringWhell=null;
	
	public void makeCar(AbstractFactory af){
		this.motor=af.creatMotor();
		this.tyre=af.creatTyre();
		this.steeringWhell=af.creatSteeringWhell();
		
		this.motor.motor();
		this.tyre.tyre();
		this.steeringWhell.steeringWhell();
	}

}

测试：

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//品牌厂家
		CarEngineer carEngineer=new CarEngineer();
		
		//客户1选的牌子
		AbstractFactory aoDi=new AoDiFactory();
		//客户2选的牌子
		AbstractFactory baoMa=new BaoMaFactory();
		//厂家推出
		System.out.println("客户1:");
		carEngineer.makeCar(aoDi);
		System.out.println("客户2:");
		carEngineer.makeCar(baoMa);
	}

}

运行结果：

                                                 

可能大家从上面看出，如果要给整个产品族添加一个新的产品，就得修改抽象工厂，也就意味着需要修改所有的工厂实现类，因此抽象工厂模式不太容易扩展新的产品

转载请注明出处： http://blog.csdn.net/hai_qing_xu_kong/article/details/42084395     情绪控_