一篇学会抽象工厂模式

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

[[409513]]

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

意图

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

主要解决

解决接口选择问题

关键代码

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

优点

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

缺点

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

使用场景

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

具体实现

创建第一个产品族

1/** 
2* 第一个产品,dog 
3*/ 
4public interface Dog { 

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{ 

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{ 

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 { 

6   //猫的公用动作 
7   void speak(); 
8} 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.

其产品族对应下的产品:

Cat第一个产品

1/** 
2* Cat 产品族-> BlackCat 
3*/ 
4public class BlackCat implements Cat{ 

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{ 

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 { 

6    public abstract Dog getDog(String size); 

8    public abstract Cat getCat(String color); 

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.

 

责任编辑:武晓燕 来源: 我好困啊
相关推荐

2021-05-11 08:54:59

建造者模式设计

2023-05-05 06:39:52

Java工厂设计模式

2021-10-26 10:40:26

代理模式虚拟

2022-01-02 08:43:46

Python

2022-02-07 11:01:23

ZooKeeper

2021-03-06 22:50:58

设计模式抽象

2023-01-03 08:31:54

Spring读取器配置

2021-07-05 22:11:38

MySQL体系架构

2022-08-26 09:29:01

Kubernetes策略Master

2023-11-28 08:29:31

Rust内存布局

2021-07-02 09:45:29

MySQL InnoDB数据

2022-08-23 08:00:59

磁盘性能网络

2021-09-29 13:53:17

抽象工厂模式

2020-10-19 09:28:00

抽象工厂模式

2022-04-12 08:30:52

回调函数代码调试

2021-07-02 08:51:29

源码参数Thread

2023-11-01 09:07:01

Spring装配源码

2021-04-29 10:18:18

循环依赖数组

2023-03-13 21:38:08

TCP数据IP地址

2021-07-16 22:43:10

Go并发Golang
点赞
收藏

51CTO技术栈公众号