抽象工厂模式

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类

抽象工厂模式（Abstract Factory）

MM身子都比较娇贵，不像我们那么能忍受的了寒冷的天气和炎热的天气，所以一到冬天和夏天就是怕热或怕冷。你为了体现你对她得关心，所以又得破费了，夏天的话就老老实实去买点凉饮料，或者请吃个冰激凌什么的，是脑子让门给挤了，或是出门药吃多了，结果大冬天的给MM买了个冰激凌吃，夏天给MM喝了杯热茶，呵呵，后果。。要是MM温柔点还好，最多就是不理你几天半个月的。要是不温柔的。。你这会可能在医院躺着呢（男人不打女人，没有反过来），为了避免这种情况，也就是季节和要买得东西有关联，结合到模式中，就是可能产品有某些关联的情况下，也就是需要创建一系列的相管得对象时，可以采用抽象工厂。下面我们看看代码： 

 

首先，我们有季节产品的接口，并实现了夏天和冬天两个产品：

java代码：

查看 复制到剪贴板 打印

1. package dp.abstractfactory;   
2.   
3. /**  
4.  * 季节产品接口  
5.  *  
6.  */  
7. public interface SeasonProduct {   
8.        
9.     /**  
10.      *<p>打印当前的季节</p>  
11.      */  
12.     public void season();   
13. }   
14.   
15.   
16.   
17. package dp.abstractfactory;   
18.   
19. /**  
20.  * 具体的产品  
21.  *  
22.  */  
23. public class Summer implements SeasonProduct{   
24.   
25.     @Override  
26.     public void season() {   
27.         System.out.println("夏天来了，酷热难耐!!!(<_>)!!!");   
28.     }   
29.        
30. }   
31.   
32.   
33.   
34. package dp.abstractfactory;   
35.   
36. public class Winter implements SeasonProduct{   
37.   
38.     @Override  
39.     public void season() {   
40.         System.out.println("冬天来了，寒风刺骨{{{(>_<)}}}");   
41.     }   
42.   
43. }  

package dp.abstractfactory;

/**
 * 季节产品接口
 *
 */
public interface SeasonProduct {
	
	/**
	 *<p>打印当前的季节</p>
	 */
	public void season();
}



package dp.abstractfactory;

/**
 * 具体的产品
 *
 */
public class Summer implements SeasonProduct{

	@Override
	public void season() {
		System.out.println("夏天来了，酷热难耐!!!(<_>)!!!");
	}
	
}



package dp.abstractfactory;

public class Winter implements SeasonProduct{

	@Override
	public void season() {
		System.out.println("冬天来了，寒风刺骨{{{(>_<)}}}");
	}

}

 

 

其次，我们有饮料产品的接口，并实现了热饮和冷饮两个产品：

java代码：

查看 复制到剪贴板 打印

1. package dp.abstractfactory;   
2.   
3. /**  
4.  * 喝冷饮还是热饮的接口  
5.  *  
6.  */  
7. public interface DrinkProduct {   
8.     /**  
9.      *<p>打印喝冷饮还是热饮</p>  
10.      */  
11.     public void drink();   
12. }   
13.   
14.   
15.   
16. package dp.abstractfactory;   
17.   
18. public class HotDrink implements DrinkProduct{   
19.   
20.     @Override  
21.     public void drink() {   
22.         System.out.println("给MM拿了一杯热咖啡~");   
23.     }   
24. }   
25.   
26.   
27.   
28. package dp.abstractfactory;   
29.   
30. public class ColdDrink implements DrinkProduct {   
31.   
32.     @Override  
33.     public void drink() {   
34.         System.out.println("给MM拿了一杯雪顶咖啡~");   
35.     }   
36.   
37. }  

package dp.abstractfactory;

/**
 * 喝冷饮还是热饮的接口
 *
 */
public interface DrinkProduct {
	/**
	 *<p>打印喝冷饮还是热饮</p>
	 */
	public void drink();
}



package dp.abstractfactory;

public class HotDrink implements DrinkProduct{

	@Override
	public void drink() {
		System.out.println("给MM拿了一杯热咖啡~");
	}
}



package dp.abstractfactory;

public class ColdDrink implements DrinkProduct {

	@Override
	public void drink() {
		System.out.println("给MM拿了一杯雪顶咖啡~");
	}

}

然后有抽象工厂方法：

 

java代码：

查看 复制到剪贴板 打印

1. package dp.abstractfactory;   
2.   
3. /**  
4.  * 抽象工厂方法  
5.  *  
6.  */  
7. public interface AbstractFactory {   
8.     /**  
9.      *<p>获取季节产品</p>  
10.      * @return  
11.      */  
12.     public SeasonProduct seasonFactory();   
13.        
14.     /**  
15.      *<p>获取饮料产品</p>  
16.      * @return  
17.      */  
18.     public DrinkProduct drinkFactory();   
19. }  

package dp.abstractfactory;

/**
 * 抽象工厂方法
 *
 */
public interface AbstractFactory {
	/**
	 *<p>获取季节产品</p>
	 * @return
	 */
	public SeasonProduct seasonFactory();
	
	/**
	 *<p>获取饮料产品</p>
	 * @return
	 */
	public DrinkProduct drinkFactory();
}

针对抽象工厂方法的具体实现，注意是冬天和热饮，夏天和冷饮：

java代码：

查看 复制到剪贴板 打印

1. package dp.abstractfactory;   
2. /**  
3.  * 夏天  
4.  *  
5.  */  
6. public class SummerFactory implements AbstractFactory {   
7.   
8.     @Override  
9.     public DrinkProduct drinkFactory() {   
10.         return new ColdDrink();   
11.     }   
12.   
13.     @Override  
14.     public SeasonProduct seasonFactory() {   
15.         return new Summer();   
16.     }   
17.   
18. }   
19.   
20.   
21.   
22. package dp.abstractfactory;   
23. /**  
24.  * 冬天  
25.  *  
26.  */  
27. public class WinterFactory implements AbstractFactory {   
28.   
29.     @Override  
30.     public DrinkProduct drinkFactory() {   
31.         return new HotDrink();   
32.     }   
33.   
34.     @Override  
35.     public SeasonProduct seasonFactory() {   
36.         return new Winter();   
37.     }   
38.   
39. }  

package dp.abstractfactory;
/**
 * 夏天
 *
 */
public class SummerFactory implements AbstractFactory {

	@Override
	public DrinkProduct drinkFactory() {
		return new ColdDrink();
	}

	@Override
	public SeasonProduct seasonFactory() {
		return new Summer();
	}

}



package dp.abstractfactory;
/**
 * 冬天
 *
 */
public class WinterFactory implements AbstractFactory {

	@Override
	public DrinkProduct drinkFactory() {
		return new HotDrink();
	}

	@Override
	public SeasonProduct seasonFactory() {
		return new Winter();
	}

}

定义一个类，获取抽象工厂接口并调用方法

 

java代码：

查看 复制到剪贴板 打印

1. package dp.abstractfactory;   
2.   
3. public class Prepare {   
4.     /**  
5.      *<p>传入抽象工厂的对象，根据具体传入的实现决定调用</p>  
6.      * @param abstractFactory  
7.      */  
8.     public void prepare(AbstractFactory abstractFactory){   
9.         abstractFactory.seasonFactory().season();   
10.         abstractFactory.drinkFactory().drink();   
11.     }   
12. }  

package dp.abstractfactory;

public class Prepare {
	/**
	 *<p>传入抽象工厂的对象，根据具体传入的实现决定调用</p>
	 * @param abstractFactory
	 */
	public void prepare(AbstractFactory abstractFactory){
		abstractFactory.seasonFactory().season();
		abstractFactory.drinkFactory().drink();
	}
}

测试类：

java代码：

查看 复制到剪贴板 打印

1. package dp.abstractfactory;   
2.   
3. public class Client {   
4.     public static void main(String[] args) {   
5.         //现在是冬天   
6.         new Prepare().prepare(new WinterFactory());   
7.     }   
8. }  

package dp.abstractfactory;

public class Client {
	public static void main(String[] args) {
		//现在是冬天
		new Prepare().prepare(new WinterFactory());
	}
}

输出：

冬天来了，寒风刺骨{{{(>_<)}}}

给MM拿了一杯热咖啡~

是不是也特别简单哈                                                                                

看看工厂方法模式和抽象工厂模式的区别（参数化的工厂方法模式退化了就是一个简单工厂）

 工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。   

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

 

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

  

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