设计模式（三）---抽象工厂模式

定义：为创建一组相关或相互依赖的对象提供一个接口，并且无须指定他们的详细类。

  我的理解:抽象工厂模式是工厂模式的升级，它针对多个业务品种，业务分类时通过抽象工厂模式来解决。

  就好比工厂中的流水线工作一样。

 一个样例：
  还是继续女娲造人的故事。女娲在制造出白人、黑人、黄种人之后，又想创造出男人和女人。那么怎样来解决这个需求呢？

解决方式:
  1、定义一个接口Human，提供getSkin()，talk(),getSex()方法。

  2、使用抽象类继承自Human,分别实现不同肤色人的共同拥有方法。

  3、各种肤色的人拥有男性和女性类。
  4、定义一个创建工厂接口。创建男性和女性工厂的类来实现不同种类的男性和女性的创建
  工厂模式仅仅要你知道创建工厂的类及方法。就能创造出一个与之无关的其它类。而不必去管它详细是怎么创建出来的。

public class HumanTest {
	public static void main(String[] args) {
		System.out.println("--------女性工厂-------------------");
		FemaleYellowHuman femaleYellow = (FemaleYellowHuman) new FemaleFactory().createYellowHuman();
		femaleYellow.getSex();
		femaleYellow.getSkin();
		femaleYellow.talk();
		System.out.println("--------男性工厂---------------");
		MaleYellowHuman maleYellow = (MaleYellowHuman) new MaleFactory().createYellowHuman();
		maleYellow.getSex();
		maleYellow.getSkin();
		maleYellow.talk();
	}
}
interface Human{
	//获取肤色
	void getSkin();
	//说话语言
	void talk();
	//性别
	void getSex();
}
abstract class AbstractBlack implements Human{
	public void getSkin(){
		System.out.println("我是黑人,拥有黑色的皮肤...");
	}
	@Override
	public void talk() {
		System.out.println("我是黑人,说的是非洲语...");
	}
}
abstract class AbstractYellow implements Human{
	public void getSkin(){
		System.out.println("我是黄种人,拥有黄色的皮肤...");
	}
	@Override
	public void talk() {
		System.out.println("我是黄种人,说的是汉语...");
	}
}
abstract class AbstractWhite implements Human{
	public void getSkin(){
		System.out.println("我是白种人,拥有白色的皮肤...");
	}
	@Override
	public void talk() {
		System.out.println("我是白种人,说的是英语...");
	}
}
class FemaleBlackHuman extends AbstractBlack{

	@Override
	public void getSex() {
		System.out.println("我是非洲女人...");
	}
}
class MaleBlackHuman extends AbstractBlack{

	@Override
	public void getSex() {
		System.out.println("我是非洲男人...");
	}
}
class FemaleYellowHuman extends AbstractYellow{
	@Override
	public void getSex() {
		System.out.println("我是中国女人...");
	}
}
class MaleYellowHuman extends AbstractYellow{
	@Override
	public void getSex() {
		System.out.println("我是中国男人...");
	}
}
class FemaleWhiteHuman extends AbstractWhite{
	@Override
	public void getSex() {
		System.out.println("我是美国女人...");
	}
}
class MaleWhiteHuman extends AbstractWhite{
	@Override
	public void getSex() {
		System.out.println("我是美国男人...");
	}
}
interface HumanFactory{
	//创建黑人
	Human createBlackHuman();
	//创建黄种人
	Human createYellowHuman();
	//创建白人
	Human createWhiteHuman();
}
class FemaleFactory implements HumanFactory{

	@Override
	public Human createBlackHuman() {
		// TODO Auto-generated method stub
		return new FemaleBlackHuman();
	}

	@Override
	public Human createYellowHuman() {
		// TODO Auto-generated method stub
		return new FemaleYellowHuman();
	}

	@Override
	public Human createWhiteHuman() {
		// TODO Auto-generated method stub
		return new FemaleWhiteHuman();
	}
}
class MaleFactory implements HumanFactory{

	@Override
	public Human createBlackHuman() {
		// TODO Auto-generated method stub
		return new MaleBlackHuman();
	}

	@Override
	public Human createYellowHuman() {
		// TODO Auto-generated method stub
		return new MaleYellowHuman();
	}

	@Override
	public Human createWhiteHuman() {
		// TODO Auto-generated method stub
		return new MaleWhiteHuman();
	}
}

抽象类的通用模式;
  UML类图:

  说明：抽象工厂模式具有非常好的封装性，它的一般模式是:一个接口。多个抽象类，N个实现类。
  他的产品族扩展比較困难，可是产品的等级易扩展。

public class AbstractFactoryTest {
	 public static void main(String[] args) {
		System.out.println("---------等级1，的A,B两个产品-------------");
		IProduct c1 = new Creator1();
		ProductA1 pa1 = (ProductA1) c1.createA();
		ProductB1 pb1 = (ProductB1) c1.createB();
		pa1.Method();
		pb1.Method();
		System.out.println("---------等级2，的A,B两个产品-------------");
		IProduct c2 = new Creator2();
		ProductA2 pa2 = (ProductA2) c2.createA();
		ProductB2 pb2 = (ProductB2) c2.createB();
		pa2.Method();
		pb2.Method();
	 }
}
interface IProduct{
	AbstractProductA createA();
	AbstractProductB createB();
}
abstract class AbstractProductA{
	public void shareMethod(){
		System.out.println("生产产品所共同拥有的方法....");
	}
	//生产产品不同的方法
	public abstract void Method();
}
abstract class AbstractProductB{
	public void shareMethod(){
		System.out.println("生产产品所共同拥有的方法....");
	}
	//生产产品不同的方法
	public abstract void Method();
}
class ProductA1 extends AbstractProductA{

	@Override
	public void Method() {
		System.out.println("生产产品---A1---的方法 ....");
	}
	
}
class ProductB1 extends AbstractProductB{
	@Override
	public void Method() {
		System.out.println("生产产品---B1---的方法 ....");
	}
}
class ProductA2 extends AbstractProductA{

	@Override
	public void Method() {
		System.out.println("生产产品---A2---的方法 ....");
	}
	
}
class ProductB2 extends AbstractProductB{
	@Override
	public void Method() {
		System.out.println("生产产品---B2---的方法 ....");
	}
}
class Creator1 implements IProduct{
	//生产等级1产品A
	@Override
	public AbstractProductA createA() {
		// TODO Auto-generated method stub
		return new ProductA1();
	}
	//生产等级1产品B
	@Override
	public AbstractProductB createB() {
		// TODO Auto-generated method stub
		return new ProductB1();
	}
	
}
class Creator2 implements IProduct{
	//生产等级1产品A
	@Override
	public AbstractProductA createA() {
		// TODO Auto-generated method stub
		return new ProductA2();
	}
	//生产等级1产品B
	@Override
	public AbstractProductB createB() {
		// TODO Auto-generated method stub
		return new ProductB2();
	}
	
}