一篇学会抽象工厂模式-抽象工厂模式

[[409513]]

本文转载自微信公众号「我好困啊」，作者mengxin。转载本文请联系我好困啊公众号。

意图

定义一个超级工厂，用于创建其他对应产品工厂。该工厂又可看成其他各种工厂的工厂。

主要解决

解决接口选择问题

关键代码

在一个工厂内聚合多个同类型的产品，然后定义超级工厂创建对应工厂。

优点

当一个产品族中多个对象被设计成一起工作的时候，每次获取都能保证获取到同一类型的产品。

缺点

产品族扩展非常困难，要增加一个系列的某一产品，对象过多。

使用场景

需要生成不同类型的产品族时。如：白猫，黑猫等它们可组成同一产品"猫"。而大狗，小狗等它们可组成同一产品“狗”，那么我们每次获取都能保证获取到的是同一类型的产品。获取猫时，可获取里面的一整套的各种品种的猫。

具体实现

创建第一个产品族

1/** 
2* 第一个产品，dog 
3*/ 
4public interface Dog { 
5 
6   //设置dog公用跑的动作 
7   void run(); 
8} 
1.
2.
3.
4.
5.
6.
7.
8.

其对应的产品族对应下的产品

Dog第一个产品

1/** 
2* Dog 产品族-> BigDog 
3*/ 
4public class BigDog implements Dog{ 
5 
6   @Override 
7   public void run() { 
8       System.out.println("The big dog runs fast..."); 
9  } 
0} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

Dog第二个产品

1/** 
2* Dog 产品族-> SmallDog 
3*/ 
4public class SmallDog implements Dog{ 
5 
6   @Override 
7   public void run() { 
8       System.out.println("The small dog runs slow..."); 
9  } 
0} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

创建dog工厂用于生成dog产品

 1/** 
 2* 用于生成对应Dog的工厂 
 3*/ 
 4public class DogFactory extends AnimeFactory{ 
 5 
 6 
 7   @Override 
 8   public Dog getDog(String size) { 
 9       if ("BIG".equals(size.toUpperCase())){ 
10           return new BigDog(); 
11      }else if ("SMALL".equals(size.toUpperCase())){ 
12           return new SmallDog(); 
13      } 
14       return null; 
15  } 
16 
17 
18   @Override 
19   public Cat getCat(String color) { 
20       return null; 
21  } 
22} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

创建第二个产品族

1/** 
2* 第二个产品cat 
3*/ 
4public interface Cat { 
5 
6   //猫的公用动作 
7   void speak(); 
8} 
1.
2.
3.
4.
5.
6.
7.
8.

其产品族对应下的产品：

Cat第一个产品

1/** 
2* Cat 产品族-> BlackCat 
3*/ 
4public class BlackCat implements Cat{ 
5 
6   @Override 
7   public void speak() { 
8       System.out.println("Black cat speak miaomiaomiao"); 
9  } 
0} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

Cat第二个产品

1/** 
2* Cat 产品族-> WhiteCat 
3*/ 
4public class WhiteCat implements Cat{ 
5 
6   @Override 
7   public void speak() { 
8       System.out.println("White cat speak miaomiaomiao"); 
9  } 
0} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

创建Cat工厂，用于生成cat

 1/** 
 2* 用于生产对应Cat的工厂 
 3*/ 
 4public class CatFactory extends AnimeFactory{ 
 5 
 6   @Override 
 7   public Dog getDog(String size) { 
 8       return null; 
 9  } 
10 
11   @Override 
12   public Cat getCat(String color) { 
13       if ("WHITE".equals(color.toUpperCase())){ 
14           return new WhiteCat(); 
15      }else if ("BLACK".equals(color.toUpperCase())){ 
16           return new BlackCat(); 
17      } 
18       return null; 
19  } 
20} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

最后创建超级工厂，生成对应工厂

1/** 
2 * 超级抽象工厂，用于创建其他工厂 
3 */ 
4public abstract class AnimeFactory { 
5 
6    public abstract Dog getDog(String size); 
7 
8    public abstract Cat getCat(String color); 
9 
0} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

 1/** 
 2 * 用于生成对应工厂的工具类 
 3 */ 
 4public class FactoryProducer { 
 5 
 6    public static AnimeFactory getAnimeFactory(String type){ 
 7        if ("CAT".equals(type.toUpperCase())){ 
 8            //生成对应猫的工厂 
 9            return new CatFactory(); 
10        }else if ("DOG".equals(type.toUpperCase())){ 
11            //生成对应狗工厂 
12            return new DogFactory(); 
13        } 
14        return null; 
15    } 
16 
17} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

测试：

 1/** 
 2 * 测试类 
 3 */ 
 4public class Test { 
 5 
 6    public static void main(String[] args) { 
 7        //获取猫工厂 
 8        AnimeFactory factory = FactoryProducer.getAnimeFactory("cat"); 
 9        Cat cat = factory.getCat("Black"); 
10        cat.speak(); 
11 
12        //获取狗工厂 
13        factory = FactoryProducer.getAnimeFactory("dog"); 
14        Dog dog = factory.getDog("Big"); 
15        dog.run(); 
16    } 
17 
18} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.