抽象工厂

转载请注明出处！！！http://blog.csdn.net/zhonghuan1992

         所有配套代码均在github上：https://github.com/ZHONGHuanGit/DesignPattern

 

跟着ZHONGHuan学习设计模式

抽象工厂

简介：

         当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产[1] 品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

         每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。(摘自百度百科)

         话语说得太抽象，程序员最好的表示方式是code，当然，我们先用uml类图来直观认识。

 

UML类图：

         从上面的类图中，能够看到，有两个产品族，分别是抽象产品1和抽象产品2这两个产品族，每个具体工厂可以生产多个产品族的产品，比如具体产品1既生产具体产品11，也生产具体产品21。

 

产品族：是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如在上图中，具体产品11和具体产品12组成一个产品族。

 

代码剖析：

//产品族1
interface AbstractProduct1{}
 
class Product11 implements AbstractProduct1{
         public Product11(){
                   System.out.println("生产了产品11");
         }
}
class Product12 implements AbstractProduct1{
         public Product12(){
                   System.out.println("生产了产品12");
         }
}
//产品族2
interface AbstractProduct2{}
 
class Product21 implements AbstractProduct2{
         public Product21(){
                   System.out.println("生产了产品21");
         }
}
class Product22 implements AbstractProduct2{
         public Product22(){
                   System.out.println("生产了产品22");
         }
}
 
interface AbstractFactory{
         AbstractProduct1 createP1();//生产产品族1的产品
         AbstractProduct2 createP2();//生产产品族2的产品
}
//具体工厂1，由具体工厂1自己决定生产每个产品族的哪一个产品
class Factory1 implements AbstractFactory{
         public AbstractProduct1 createP1(){
                   return new Product11();
         }
         public AbstractProduct2 createP2(){
                   return new Product21();
         }
}
//具体工厂2，由具体工厂2自己决定生产每个产品族的哪一个产品
class Factory2 implements AbstractFactory{
         public AbstractProduct1 createP1(){
                   return new Product12();
         }
         public AbstractProduct2 createP2(){
                   return new Product22();
         }
}

 

抽象工厂和具体工厂的区别：

工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类可以创建多个具体产品类的实例。

区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

 

什么情况下使用抽象工厂模式：

         1一个系统不应当依赖于产品类实例如何被创建，组合和表达的细节，这对于所有形态的工厂模式都是重要的。

         2这个系统的产品多于一个产品族，而系统只消费了其中某一族的产品。（这一条叫做抽象工厂模式的原使用意）

         3同属于一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。

         4系统提供一个产品类的库，所有产品一同样的接口实现，从而是客户端不依赖于具体实现。

 

更加符合开闭原则：

         开闭原则要求一个软件系统可以在不修改原有代码的情况下，通过扩展达到增强其功能的目的。

         而抽象工厂模式对于增加一个新的产品族更加支持。

 

实例引导：

       假设富士康公司给两个品牌作代工产品：苹果和三星。这两个品牌都有手机和平板产品，由于生产工艺的不同，富士康开设了两条生产线，一条线只生产手机，另一条线只生产平板电脑。苹果公司有新产品发布，向富士康订购生产iPad, 富士康负责人到生产平板的工厂，要求生产苹果的pad，很快iPad生产出来了。苹果公司又有新款iphone要生产了，向富士康订购，富士康负责人又转身到生产手机的工厂，要求生产iphone，很快iPhone造好了。

 

样例类图：

样例代码：

//苹果产品族
interface Apple{}
class Iphone implements Apple{//苹果手机
	public Iphone(){
		System.out.println("生产了iphone");
	}
}
class Ipad implements Apple{//苹果pad
	public Ipad(){
		System.out.println("生产了ipad");
	}
}

//三星产品族
interface SamSung{}
class SanSungPhone implements SamSung{//三星手机
	public SanSungPhone(){
		System.out.println("生产了三星手机");
	}
}
class SamSungPad implements SamSung{//三星平板
	public SamSungPad(){
		System.out.println("生产了三星平板电脑");
	}
}
//富士康工厂抽象接口
interface FuShiKang{
	Apple createApple();//生产苹果产品族的产品
	SamSung createSamSung();//生产三星产品族的产品
}
//富士康专门生产手机的工厂
class PhoneFactory implements FuShiKang{
	public Apple createApple(){//生产苹果手机
		return new Iphone();
	}
	public SamSung createSamSung(){//生产三星手机
		return new SanSungPhone();
	}
}
//富士康专门生产平板电脑的工厂
class PadFactory implements FuShiKang{
	public Apple createApple(){//生产苹果的ipad
		return new Ipad();
	}
	public SamSung createSamSung(){//生产三星的平板
		return new SamSungPad();
	}
}

public class Main{
	public static void main(String[] args){
       //订购商来到富士康，要订购一台iphone,所以负责人告诉生产手机的工厂加工生产
		FuShiKang factory=new PhoneFactory();
		Apple iphone= factory.createApple();
		
		//然后要一些三星平板电脑，所以负责人告诉生产平板电脑的工厂加工生产
		factory=new PadFactory();
		SamSung samsungPad= factory.createSamSung();
	}	
}

 

结果：