本文转载自微信公众号「我好困啊」,作者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.