抽象工厂模式学习案例代码

转载请注明出处：http://blog.csdn.net/droyon/article/details/8684435

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指明具体类。

抽象工厂模式允许客户使用抽象的接口来创建一组相关的产品，而不需要知道实际产出的具体产品是什么。这样客户就从具体产品中解耦了。

案例代码下载

总结：抽象工程模式可以看成创建一组对象的工厂方法模式的集合。

抽象工厂模式可用于对相同方案的替换。比如数据库整体方案的替换，数据库拥有一系列的操作，比如创建数据库，删除数据库，更新数据库，插入数据库等操作，在access，或者SqlServer架构下，针对每一个操作，可能实现都不一样。我们可以使用抽象工厂方法，实现两套工厂，没一套工厂完成上述操作的实现，那么我们就可以很方便的替换他们，而不会对数据库的操作接口产生任何影响。

生产一组产品的接口

public interface CongeeAttachmentInterface {
	Zhibei createZhibei();
	Xiguan createXiguan();
	String createAdword();
}

具体实现：

public class AbstractFactoryA implements CongeeAttachmentInterface{

	@Override
	public Zhibei createZhibei() {
		// TODO Auto-generated method stub
		return new AZhibei();
	}

	@Override
	public Xiguan createXiguan() {
		// TODO Auto-generated method stub
		return new SmallXiguan();
	}

	@Override
	public String createAdword() {
		// TODO Auto-generated method stub
		return "好粥好营养";
	}

}

public class AbstractFactoryB implements CongeeAttachmentInterface{

	@Override
	public Zhibei createZhibei() {
		// TODO Auto-generated method stub
		return new BZhibei();
	}

	@Override
	public Xiguan createXiguan() {
		// TODO Auto-generated method stub
		return new BigXiguan();
	}

	@Override
	public String createAdword() {
		// TODO Auto-generated method stub
		return "您的健康，我们一直在努力";
	}

}

粥类：

public abstract class Congee {
	private String name;
	protected Zhibei zhibei;
	protected Xiguan xiguan;
	protected String adWord;
	protected CongeeAttachmentInterface attachment;
	
	public Congee(String name,CongeeAttachmentInterface atta){
		this.name = name;
		attachment = atta;
		init();
	}
	
	abstract void init();
	
	public void takeCup(){
		System.out.println("拿出一个"+zhibei+",纸杯上的广告语："+adWord);
		System.out.println("吸管型号："+xiguan);
	}
	public void fillCongee(){
		System.out.println("装入"+name);
	}
	public void sell(){
		System.out.println("卖出这杯粥,价格："+getPrice(name)+"元");
	}
	
	private double getPrice(String name){
		if(name.equals("大米粥")){return 2;}
		if(name.equals("小米粥")){return 2;}
		if(name.startsWith("八宝粥")){return 2.5;}
		if(name.equals("黑米粥")){return 2.5;}
		return 0;
	}
}

具体的粥类，只有一个八宝粥

public class Babaozhou extends Congee{

	public Babaozhou(CongeeAttachmentInterface attach) {
		super("八宝粥	",attach);
	}

	@Override
	void init() {
		zhibei = attachment.createZhibei();
		xiguan = attachment.createXiguan();
		adWord = attachment.createAdword();
	}

}

纸杯类

public abstract class Zhibei {
	@Override
	public abstract String toString();
}

具体的纸杯类，厂家A，厂家B生产的

public class AZhibei extends Zhibei{

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "厂家A生产的纸杯";
	}

}

public class BZhibei extends Zhibei{

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "厂家B生产的纸杯";
	}

}

吸管，大口径，小口径

public abstract class Xiguan {

	@Override
	public abstract String toString();
	
}

public class BigXiguan extends Xiguan{

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "大口径吸管";
	}

}

public class SmallXiguan extends Xiguan{

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "小口径吸管";
	}

}

粥店：

public abstract class CongeeStoreBase {
	public CongeeStoreBase(){
	}
	
	public void buyCongee(String name){
		System.out.println("来一份："+name);
		sellCongee(name);
	}
	
	private void sellCongee(String name){
		Congee congee = getCongee(name);
		congee.takeCup();
		congee.fillCongee();
		congee.sell();
	}
	
	protected abstract Congee getCongee(String name);
}

public class CongeeStore extends CongeeStoreBase{
	private CongeeAttachmentInterface atta;
	public CongeeStore(CongeeAttachmentInterface atta){
		this.atta = atta;
	}
	
	public void setAtta(CongeeAttachmentInterface attachment){
		atta = attachment;
	}
	@Override
	protected Congee getCongee(String name) {
		/*if(name.equals("大米粥")){
			return new Damizhou();
		}else if(name.equals("小米粥")){
			return new Xiaomizhou();
		}else*/ if(name.equals("八宝粥")){
			return new Babaozhou(atta);
		}/*else {
			return new Congee("null");
		}*/
		return null;
	}

}

Test.java

public class Test {
	public static void main(String args[]){
		//初始化两种方案
		CongeeAttachmentInterface atta1 = new AbstractFactoryA();
		CongeeAttachmentInterface atta2 = new AbstractFactoryB();
		//初始化一个粥店
		CongeeStore congeeStore = new CongeeStore(atta1);
		
		//买粥行为
		congeeStore.buyCongee("八宝粥");
		//厂家A生产的纸杯不好，并且吸管想换成大口径的，广告语用了很久了，也想换掉
		congeeStore.setAtta(atta2);
		System.out.println("---------------------------------");
		//买粥行为
		congeeStore.buyCongee("八宝粥");
	}
}

测试结果：

来一份：八宝粥
拿出一个厂家A生产的纸杯,纸杯上的广告语：好粥好营养
吸管型号：小口径吸管
装入八宝粥	
卖出这杯粥,价格：2.5元
---------------------------------
来一份：八宝粥
拿出一个厂家B生产的纸杯,纸杯上的广告语：您的健康，我们一直在努力
吸管型号：大口径吸管
装入八宝粥	
卖出这杯粥,价格：2.5元

总结：

简单工厂虽然不是真正的设计模式，但不失为一个简单的方法。

工厂方法使用继承，把对象的创建委托给子类，子类实现工厂方法类创建对象。

抽象工厂使用对象的组合，对象的创建被实现在工厂接口所暴露的方法中。

所有的工厂模式都通过减少应用程序与具体类之间的依赖来促进松耦合。