【23种设计模式】-抽象工厂模式

偏执的太偏执、 2023-07-16 03:55 127阅读 0赞

什么是抽象工厂模式？

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端

提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

举个例子，现在有两个品牌厂商，小米和华为，小米生产手机和路由器，华为也生产手机和路由器，但是小米生产的产品都是在小米的工厂生产的，华为的产品都是在华为的工厂生产的，但是这两个工厂要符合同一个工厂标准，也就是抽象工厂。另外两个厂商都生产手机，这个生产的手机要否和手机产品的标准，生产的路由器也要符合路由产品的标准。综上所述每个厂商都会生产不同的产品也就是产品簇。所以抽象工厂是针对整个产品簇的。

具体实现代码如下：

手机产品接口：

  1. package abf;
  3. /**
  4.  * 手机产品接口
  5.  */
  6. interface IPhoneProduct {
  7.     void call(); //打电话功能
  8.     void sendSMS(); //发短信功能
  9.     void open();//开机功能
  10.     void close();//关机功能
  11. }

小米手机产品类：

  1. package abf;
  3. /**
  4.  * 小米手机产品
  5.  */
  6. public class XiaoMiPhone implements IPhoneProduct {
  7.     public void call() {
  8.         System.out.println("小米手机 call");
  9.     }
  11.     public void sendSMS() {
  12.         System.out.println("小米手机 sendSMS");
  13.     }
  15.     public void open() {
  16.         System.out.println("小米手机 open");
  17.     }
  19.     public void close() {
  20.         System.out.println("小米手机 close");
  21.     }
  22. }

华为手机产品类：

  1. package abf;
  3. /**
  4.  * 华为手机产品
  5.  */
  6. public class HuaWeiPhone implements IPhoneProduct {
  8.     public void call() {
  9.         System.out.println("华为手机 call");
  10.     }
  12.     public void sendSMS() {
  13.         System.out.println("华为手机 sendSMS");
  14.     }
  16.     public void open() {
  17.         System.out.println("华为手机 open");
  18.     }
  20.     public void close() {
  21.         System.out.println("华为手机 close");
  22.     }
  23. }

路由器产品接口：

  1. package abf;
  3. /**
  4.  * 路由产品接口
  5.  */
  6. interface IRouterProduct {
  7.     void open();  //开机功能
  8.     void close(); //关机功能
  9.     void wifi();  //wifi功能
  10. }

小米路由器产品类：

  1. package abf;
  3. /**
  4.  *小米路由器产品
  5.  */
  6. public class XiaoMiRouter implements IRouterProduct {
  7.     public void open() {
  8.         System.out.println("小米路由器 open");
  9.     }
  11.     public void close() {
  12.         System.out.println("小米路由器 close");
  13.     }
  15.     public void wifi() {
  16.         System.out.println("小米路由器 wifi");
  17.     }
  18. }

华为路由器产品接口：

  1. package abf;
  3. /**
  4.  * 华为路由器产品
  5.  */
  6. public class HuaWeiRouter implements IRouterProduct {
  7.     public void open() {
  8.         System.out.println("华为路由器 open");
  9.     }
  11.     public void close() {
  12.         System.out.println("华为路由器 close");
  13.     }
  15.     public void wifi() {
  16.         System.out.println("华为路由器 wifi");
  17.     }
  18. }

抽象工厂

  1. package abf;
  3. /**
  4.  * 抽象工厂
  5.  */
  6. public interface AbstractFactory {
  7.     //生产手机
  8.     IPhoneProduct iphoneProduct();
  10.     //生产路由器
  11.     IRouterProduct irouterProduct();
  12. }

小米工厂：

  1. package abf;
  3. /**
  4.  * 生产小米产品的工厂
  5.  */
  6. public class XiaoMiFactory implements AbstractFactory {
  7.     public IPhoneProduct iphoneProduct() {
  8.         return new XiaoMiPhone();
  9.     }
  11.     public IRouterProduct irouterProduct() {
  12.         return new XiaoMiRouter();
  13.     }
  14. }

华为工厂：

  1. package abf;
  3. /**
  4.  * 生产华为产品的工厂
  5.  */
  6. public class HuaWeiFactory implements  AbstractFactory{
  7.     public IPhoneProduct iphoneProduct() {
  8.         return new HuaWeiPhone();
  9.     }
  11.     public IRouterProduct irouterProduct() {
  12.         return new HuaWeiRouter();
  13.     }
  14. }

创建产品的测试类：

  1. package abf;
  3. public class Consumer {
  4.     public static void main(String[] args) {
  5.         //创建小米工厂
  6.         XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
  7.         //小米工厂生产手机
  8.         IPhoneProduct iPhoneProduct = xiaoMiFactory.iphoneProduct();
  9.         iPhoneProduct.call();
  10.         iPhoneProduct.sendSMS();
  11.         //小米工厂生产路由器
  12.         IRouterProduct iRouterProduct = xiaoMiFactory.irouterProduct();
  13.         iRouterProduct.open();
  14.         iRouterProduct.wifi();
  15.         iRouterProduct.close();
  16.         //创建华为工厂
  17.         HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
  18.         //华为工厂生产手机
  19.         IPhoneProduct iPhoneProduct1 = huaWeiFactory.iphoneProduct();
  20.         iPhoneProduct1.sendSMS();
  21.         iPhoneProduct1.call();
  22.         //华为工厂生产路由器
  23.         IRouterProduct iRouterProduct1 = huaWeiFactory.irouterProduct();
  24.         iRouterProduct1.open();
  25.         iRouterProduct1.wifi();
  26.         iRouterProduct1.close();
  28.     }
  29. }

输出结果如下：

  1. 小米手机 call
  2. 小米手机 sendSMS
  3. 小米路由器 open
  4. 小米路由器 wifi
  5. 小米路由器 close
  6. 华为手机 sendSMS
  7. 华为手机 call
  8. 华为路由器 open
  9. 华为路由器 wifi
  10. 华为路由器 close

总结：

什么场景下使用抽象工厂？

当一系列的相关对象（产品簇）稳定的情况下可以使用抽象工厂，如果抽象工厂对象频繁发生变化时则不适用，比如上面的例子我需要增加笔记本电脑的生产，那么抽象工厂、具体实现的工厂都要发生变化，这就违反了设计模式的开闭原则，这样是不推荐的。

发表评论

表情：
评论列表 （有 0 条评论，127人围观）

还没有评论，来说两句吧...

相关阅读