抽象工厂模式

1.提供一个抽象工厂接口，提供所有产品创建的方法

2.客户端只提供工厂接口以及抽象产品接口

3.如果增加一个产品，除了扩展抽象产品等，还需更改抽象工厂

4.可以考虑将简单工厂来优化抽象工厂，具体是在简单工厂中分别返回各产品实例，

这样，有新的产品增加时，只需扩展新的产品，再修改统一工厂类，工作量相比抽象工厂要小很多

 

interface ProductA
	{
		public void Method1_ProductA();
		public void Method2_ProductA();
	}

	interface ProductB
	{
		public void Method1_ProductB();
		public void Method2_ProductB();
	}

	interface IProductFactory
	{
		public ProductA CreateProductA();
		public ProductB CreateProductB();


	}
   

   // ProductA 第一中实现
	class ProductAimp implements ProductA
	{
		public void Method1_ProductA()
		{
			System.out.println("Method1_ProductA Create");
		}

		public void Method2_ProductA()
		{
          System.out.println("Method2_ProductA Create");
		}
	}
     

	 // ProductA 第二种实现
	class ProductAimp1 implements ProductA
	{
		public void Method1_ProductA()
		{
			System.out.println("ProductAimp1_Method1_ProductA Create");
		}

		public void Method2_ProductA()
		{
          System.out.println("ProductAimp1_Method2_ProductA Create");
		}
	}

       // ProductB 第一种实现
	class ProductBimp implements ProductB
	{
		public void Method1_ProductB()
		{
			System.out.println("Method1_ProductB Create");
		}

		public void Method2_ProductB()
		{
          System.out.println("Method2_ProductB Create");
		}
	}

     // ProductB 第二种实现
	class ProductBimp1 implements ProductB
	{
		public void Method1_ProductB()
		{
			System.out.println("ProductBimp1_Method1_ProductB Create");
		}

		public void Method2_ProductB()
		{
          System.out.println("ProductBimp1_Method2_ProductB Create");
		}
	}
     

	 // 2种实现分别构建2个工厂
	class ProductAimp_fact implements IProductFactory
	{
		public ProductA CreateProductA()
		{
			return new ProductAimp();
		}
		public ProductB CreateProductB()
		{
			return new ProductBimp();
		}
	}

	class ProductBimp_fact implements IProductFactory
	{
		public ProductA CreateProductA()
		{
			return new ProductAimp1();
		}
		public ProductB CreateProductB()
		{
			return new ProductBimp1();
		}
	}
     // 用简单工厂来实现

	 class design_mode_Abstract_Factory_Client_simple
	 {
		 private  String ProName = "PRODUCTA";

		 public design_mode_Abstract_Factory_Client_simple()
		 {}

		 public design_mode_Abstract_Factory_Client_simple(String ProName)
		 {
			 this.ProName = ProName;
		 }

		 public  ProductA Return_ProductAimp()
		 {
			 if (ProName == "PRODUCTA" )
			 {
				 return new ProductAimp();
			 }
			 else
                  return new ProductAimp1();
		 }

		  public  ProductB Return_ProductBimp()
		 {
			 if (ProName == "PRODUCTA" )
			 {
				 return new ProductBimp();
			 }
			 else
                  return new ProductBimp1();
		 }
	 }
	class design_mode_Abstract_Factory_Client
	{
		public void design_mode_Abstract_Factory_Client_Test()
		{
			IProductFactory fact1 = new ProductBimp_fact();

			ProductA proa = fact1.CreateProductA();

			proa.Method1_ProductA();
			proa.Method2_ProductA();


			//=====================

			design_mode_Abstract_Factory_Client_simple cle = new design_mode_Abstract_Factory_Client_simple("txt");
            
			 ProductA proa1 = cle.Return_ProductAimp();
			 proa1.Method1_ProductA();
			 proa1.Method2_ProductA();

		}
	}