磊哥学设计模式（三）抽象工厂模式

抽象工厂

什么是抽象工厂

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

为什么使用抽象工厂

主要解决接口选择的问题，系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

代码演示

同样，拿游戏来举例，现在，有两个铁匠铺，一个生产武器，一个生产装备，那么就像上一节一样，用两个接口就好了：
武器：

public interface weapon {
	void Produceweapon();
}

武器工厂里面生产两种武器，一个剑一个刀：

public class Sword implements weapon {

	@Override
	public void Produceweapon() {
		// TODO Auto-generated method stub
		System.out.println("Produce a sword!");
	}

}

public class knife implements weapon {

	@Override
	public void Produceweapon() {
		// TODO Auto-generated method stub
		System.out.println("Produce a knife!");
	}

}

装备：

public interface Armor {
	void ProduceArmor();
}

装备里面也产两种装备，一个头盔，一个胸甲：

public class breastplate implements Armor {

	@Override
	public void ProduceArmor() {
		// TODO Auto-generated method stub
		System.out.println("Produce a breastplate!");
	}

}

public class helmet implements Armor {

	@Override
	public void ProduceArmor() {
		// TODO Auto-generated method stub
		System.out.println("Produce a helmet!");
	}

}

好，这时候，游戏要统一管理，出来一个装备工厂，这两个工厂边成他的子厂，那么这个管理的工厂怎么写呢？
用一个抽象类就可以了：

public abstract class forge {
	public abstract weapon getWeapon(String type);
	public abstract Armor getArmor(String type);
}

然后对抽象类实现，选择用哪个工厂的装备：

public class ForgeFactory {
	public static forge getfactory(String type){
		if(type.equalsIgnoreCase("armor")){
			return new ArmorFactory();
		}else if(type.equalsIgnoreCase("weapon")){
			return new WeaponFactory();
		}
		
		return null;
		
	}
}

public class ArmorFactory extends forge {

	@Override
	public weapon getWeapon(String type) {
		// TODO Auto-generated method stub
		
		return null;
	}

	@Override
	public Armor getArmor(String type) {
		// TODO Auto-generated method stub
		if(type.equalsIgnoreCase("breastplate")){
			return new breastplate();
		}else if(type.equalsIgnoreCase("helmet")){
			return new helmet();
		}
		return null;
	}

}

public class WeaponFactory extends forge {

	@Override
	public weapon getWeapon(String type) {
		// TODO Auto-generated method stub
		if(type.equalsIgnoreCase("sword")){
			return new Sword();
		}else if(type.equalsIgnoreCase("knife")){
			return new knife();
		}
		return null;
	}

	@Override
	public Armor getArmor(String type) {
		// TODO Auto-generated method stub
	
		return null;
	}

}

到这里，我们的抽象工厂就完成了，以后要用哪个装备，通过抽象工厂，直接选用就可以了：

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		forge armorfactory = ForgeFactory.getfactory("armor");
		Armor a= armorfactory.getArmor("breastplate");
		a.ProduceArmor();
		
		Armor b=armorfactory.getArmor("helmet");
		b.ProduceArmor();
		
		forge weaponfactory = ForgeFactory.getfactory("weapon");
		weapon c=weaponfactory.getWeapon("sword");
		c.Produceweapon();
		
		weapon d= weaponfactory.getWeapon("knife");
		d.Produceweapon();
		
	}

}

通过代码，可以更直观的理解，抽象工厂是生产其他工厂的工厂这句话。