一篇学会抽象工厂模式

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

[[409513]]

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

意图

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

主要解决

解决接口选择问题

关键代码

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

优点

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

缺点

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

使用场景

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

具体实现

创建第一个产品族

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

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

Dog第一个产品

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

Dog第二个产品

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

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

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

创建第二个产品族

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

其产品族对应下的产品:

Cat第一个产品

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

Cat第二个产品

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

创建Cat工厂,用于生成cat

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

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

  1. 1/** 
  2. 2 * 超级抽象工厂,用于创建其他工厂 
  3. 3 */ 
  4. 4public abstract class AnimeFactory { 
  5. 6    public abstract Dog getDog(String size); 
  6. 8    public abstract Cat getCat(String color); 
  7. 0} 
  1.  1/** 
  2.  2 * 用于生成对应工厂的工具类 
  3.  3 */ 
  4.  4public class FactoryProducer { 
  5.  5 
  6.  6    public static AnimeFactory getAnimeFactory(String type){ 
  7.  7        if ("CAT".equals(type.toUpperCase())){ 
  8.  8            //生成对应猫的工厂 
  9.  9            return new CatFactory(); 
  10. 10        }else if ("DOG".equals(type.toUpperCase())){ 
  11. 11            //生成对应狗工厂 
  12. 12            return new DogFactory(); 
  13. 13        } 
  14. 14        return null
  15. 15    } 
  16. 16 
  17. 17} 

测试:

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

2021-03-06 22:50:58

设计模式抽象

2021-09-29 13:53:17

抽象工厂模式

2020-10-19 09:28:00

抽象工厂模式

2022-02-07 11:01:23

ZooKeeper

2024-03-06 13:19:19

工厂模式Python函数

2021-07-02 09:45:29

MySQL InnoDB数据

2023-01-03 08:31:54

Spring读取器配置

2021-07-05 22:11:38

MySQL体系架构

2023-11-28 08:29:31

Rust内存布局

2022-08-26 09:29:01

Kubernetes策略Master

2022-08-23 08:00:59

磁盘性能网络

2021-10-27 09:59:35

存储

2021-07-02 08:51:29

源码参数Thread

2022-04-12 08:30:52

回调函数代码调试

2023-03-13 21:38:08

TCP数据IP地址

2023-11-01 09:07:01

Spring装配源码
点赞
收藏

51CTO技术栈公众号