精华内容
下载资源
问答
  • 抽象工厂模式详解

    2016-09-14 14:47:44
    抽象工厂模式详解  作者:zuoxiaolong8810(左潇龙),转载请注明出处,特别说明:本博文来自博主原博客,为保证新博客中博文的完整性,特复制到此留存,如需转载请注明新博客地址即可。  前两章我们已经...

    抽象工厂模式详解

                作者:zuoxiaolong8810(左潇龙),转载请注明出处,特别说明:本博文来自博主原博客,为保证新博客中博文的完整性,特复制到此留存,如需转载请注明新博客地址即可。

    •             前两章我们已经讨论了两种有关工厂的模式,今天我们来看最后一种与工厂相关的模式,抽象工厂模式。

                  抽象工厂模式算是工厂相关模式的终极形态,如果各位完全理解了上一章的工厂方法模式,那么抽象工厂模式就很好理解了。它与工厂方法唯一的区别就是工厂的接口里是一系列创造抽象产品的方法,而不再是一个,而相应的,抽象产品也不再是一个了,而是一系列相关的产品。这其实是工厂方法模式的一种扩展不是吗?

                  通常意义来我们谈到扩展,通常有两种方式可以扩展一个接口或者类,就是继承和组合。

                  通常情况下,我们推荐使用组合扩展一个现有的类或接口,但这并非绝对,如果你扩展的子类或子接口与现有的类或接口明显是“是一个(is a)”的关系,也就是继承的关系,那么使用继承可以获得更多的好处。

                  下面我们就首先来看一下抽象工厂模式的定义以及类图,全部引自百度百科。

                  定义:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。

                  定义中说了,我们是要创建一个接口, 而这个接口是干嘛的呢,前面说了,是为了创建一组相关或者相互依赖的对象,而且还有一点就是,我们创建的对象不是具体的类,也就是说我们创建的是一个接口或者一个抽象类。

                  下面我们来看看抽象工厂模式的类图。

                  我们对比下刚才的定义,LZ给各位分析下上面的类图,首先刚才说了,我们要创建一个接口,这个接口就是指的Creator,而一组相关或者相互依赖的对象,就是指的ProductA和ProductB以及它们具体的实现类,而上面又提到说不是返回的具体的类,所以我们返回的应该是接口或者抽象类,那么在上述类图当中,则是指的ProductA和ProductB接口。

                  下面LZ将上述类图诠释成容易理解的JAVA代码,供各位参考。

                  首先给出我们的产品族,也就是类图中右半部分。

      package net;
      
      interface ProductA {
      
          void methodA();
      }
      
      interface ProductB {
          
          void methodB();
      }
      
      class ProductA1 implements ProductA{
      
          public void methodA() {
              System.out.println("产品A系列中1型号产品的方法");
          }
          
      }
      
      class ProductA2 implements ProductA{
      
          public void methodA() {
              System.out.println("产品A系列中2型号产品的方法");
          }
          
      }
      
      class ProductB1 implements ProductB{
      
          public void methodB() {
              System.out.println("产品B系列中1型号产品的方法");
          }
          
      }
      
      class ProductB2 implements ProductB{
      
          public void methodB() {
              System.out.println("产品B系列中2型号产品的方法");
          }
          
      }

                  结构比较清晰,下面是类图中左半部分,首先给出工厂接口。

      package net;
      
      public interface Creator {
      
          ProductA createProductA();
          
          ProductB createProductB();
          
      }

                  下面是两个具体的工厂实现类。

      package net;
      
      public class ConcreteCreator1 implements Creator{
      
          public ProductA createProductA() {
              return new ProductA1();
          }
      
          public ProductB createProductB() {
              return new ProductB1();
          }
      
      }
      package net;
      
      public class ConcreteCreator2 implements Creator{
      
          public ProductA createProductA() {
              return new ProductA2();
          }
      
          public ProductB createProductB() {
              return new ProductB2();
          }
      
      }

                  这样我们的类图代码就实现完毕,下面我们写一个测试类,去调用一下,感受一下抽象工厂模式的客户端调用方式。

      package net;
      
      
      public class Client {
      
          public static void main(String[] args) throws Exception {
              Creator creator = new ConcreteCreator1();
              ProductA productA = creator.createProductA();
              ProductB productB = creator.createProductB();
              productA.methodA();
              productB.methodB();
              
              creator = new ConcreteCreator2();
              productA = creator.createProductA();
              productB = creator.createProductB();
              productA.methodA();
              productB.methodB();
          }
      }

                  在过程当中,我们切换过一次工厂实现类,而下面的代码是一模一样的,但是我们使用的就是另一套产品实现体系了,我们看运行结果。

                  上面的代码比较简单,结构很清晰但不太容易理解,因为它全部是抽象的表示,与实际联系不上,所以也会对各位的理解造成阻碍,下面我们就一起讨论一个现有的例子,去加深去抽象工厂模式的理解。

                  上一章我们介绍了iterable接口,它可以制作iterator,iterator方法是一个工厂方法,用于让子类制作一系列的iterator,不过java集合框架一般都将iterator的实现作为内部类出现,所以我们从未见过LZ上章提到的ListIterator和KeyIterator的实现类,但它们确实存在于JAVA的集合框架,并且它们的实现类被封装在相应的抽象类或者具体的容器实现类中。

                  oracle公司为何不让我们看到这些iterator的实现类呢?其实原因很简单,一是怕我们在写程序的时候依赖于这些iterator的实现类,二是这些迭代器的实现都要依赖于当前的容器实现,我们假设有一天JDK中的集合框架要升级,要替换掉某个iterator的实现,换做一种更快的迭代方式(假设存在这种方式),那么以前使用特定迭代器的程序可能就无法正常运行了。当然大部分的情况下,oracle不会将现有的类剔除,但是会加上@Deprecated注解,来标识这是一个过时的东西,不再推荐你使用。但就算是这样,还是有缺点,就是JDK升级以后,你享受不到JDK集合框架速度上的提升,除非你将所有你使用过具体的Iterator的地方全部手动替换掉。

                  上述大致描述了下集合框架设计时对iterator处理方式的初衷,从中可以看出抽象工厂模式就是为了解决抽象产品不再是一个的时候的问题。因为不管是简单工厂,还是工厂方法,都有一个缺陷,那就是整个模式当中只能有一个抽象产品,所以直观的,你在工厂方法模式中再添加一个创造抽象产品的方法就是抽象工厂模式了,相应的当然还有添加一个抽象产品,还有一系列具体的该抽象产品的实现。

                  在集合框架里,有一个不太明显的抽象工厂模式,就是List接口,它在iterable的基础上,扩展了一个创建产品的方法,本次以List接口为例,我们来看看List接口的源码。

      package java.util;
      
      public interface List<E> extends Collection<E> {
          
          Iterator<E> iterator();//一种产品
      
          Object[] toArray();
      
          <T> T[] toArray(T[] a);
      
          ListIterator<E> listIterator();//另外一种产品
      
          ListIterator<E> listIterator(int index);
      
      }

                     LZ去掉了List接口中的很多方法,一是为了节省版面,另外是为了更清晰,我们主要关注iterator和listIterator方法,LZ在上面加了标注。

                     其中ListIterator是Iterator的子接口,但归根到底,它其实属于另外一种产品,为什么这么说呢,ListIterator不是Iterator的子接口吗,怎么能算是另外一种产品呢?这是因为我们listIterator方法的返回类型是ListIterator,而不是Iterator,所以两者的功能是不同的,比如ListIterator还可以向前移动。

                     我们可以认为这两个方法产生的一个是只能向后移动的迭代器,一个是可以前后移动的迭代器,这算是两种产品,相当于上面的ProductA和ProductB。

                     这个设计可以看做是一个抽象工厂模式,List接口定义了两种生产不同产品的方法,这属于两个系列的产品,不过由于产品接口本身的继承关系,两者的实现类也会被做成继承的关系。下面给出上面提到的接口的UML图。


                       这个图看起来有点复杂,各位可以和上面标准的抽象工厂模式类图对比一下,下面LZ来解释一下在抽象工厂模式当中,上述几个类都代表的什么角色。

                       1.List,是抽象工厂的角色,它有两个制造产品的方法,iterator和listIterator,相当于Creator。

                       2.ListIterator和Iterator都是抽象产品,相当于ProductA和ProductB。其中ListIterator有两个实现类,分别是AbstractList.ListItr和LinkedList.ListItr,相当于ProductA1和ProductA2。Iterator的实现类为AbstractList.Itr,相当于ProductB1,但是没有B2。

                       3.LinkedList是其中一个具体的工厂类,相当于ConcreteCreator1,实现抽象工厂List,它制造的两个具体产品分别是LinkedList.ListItr和AbstractList.Itr。

                       4.同样的,ArrayList也是一个具体的工厂类,相当于ConcreteCreator2,实现抽象工厂List,它制造的两个具体产品分别是AbstractList.ListItr和AbstractList.Itr。

                      结合上一章工厂方法模式,我们来分析一下工厂方法模式和抽象工厂模式二者的关系。

                      Iterable接口是List的父接口,所以它只负责一个产品Iterator的制造,所以是工厂方法模式,而List接口扩展了Iterable接口,又添加了一个制造产品的方法,即又添加了一个系列的产品,所以就成为了抽象工厂模式。

                    LZ下面给出上述两个类图的对应关系,会让各位看的更加清晰:

                    1.Creator=List

                    2.ConcreteCreator1=ArrayList

                    3.ConcreteCreator2=LinkedList

                    4.ProductA=Iterator

                    5.ProductB=ListIterator

                    6.ProductA1=AbstractList.Itr

                    7.ProductA2=无(具体的A产品2在第一个类图中是没有的,但这并不影响整个体系)

                    8.ProductB1=AbstractList.ListItr

                    9.ProductB2=LinkedList.ListItr

                    ArrayList和LinkedList分别是List接口的两种实现,前者是基于数组操作,后者是基于链表。两者都可以产生Iterator和ListIterator,而Iterator的实现都是在AbstractList中实现的,是一样的处理方式,而对于ListIterator的实现却不相同,AbstractList.ListItr是基于数组的操作,LinkedList.ListItr是基于链表的操作方式。

                    所以抽象工厂模式一般是为了处理抽象产品多于一个的问题,而且这些产品多数情况下是有关系的,像上述JAVA集合框架的例子当中,Iterator和ListIterator就是继承的关系,大部分情况下,很少会使用抽象工厂模式去创造一批毫无关系的产品。

                    基于抽象工厂一旦定义,抽象产品的个数就已经固定,所以最好在抽象产品的个数不太会变化的情况下使用抽象工厂模式,当然,我们可以使用继承去弥补抽象工厂模式的这一不足,创造另外一个继承体系去扩展现有的框架。

                    下面LZ给出简单工厂模式,工厂方法模式一直到抽象工厂模式的演变过程,三者是由简到繁的关系。由于三者都已经详细的解释过,所以此处不再多做解释,留给各位读者自己思考它们的进化过程,首先LZ给出简单工厂的具体代码。

      //抽象产品
      interface Product{}
      
      //具体产品
      class ProductA implements Product{}
      class ProductB implements Product{}
      
      //产品工厂(下一步就是它的进化,就变成了工厂方法模式)
      public class ProductFactory {
      
          private ProductFactory(){}
          
          public static Product getProduct(String productName){
              if (productName.equals("A")) {
                  return new ProductA();
              }else if (productName.equals("B")) {
                  return new ProductB();
              }else {
                  return null;
              }
          }
      }

                     LZ在上面加了简单的注释,下面LZ给出工厂方法模式的代码,注意,前面有关产品的类和接口是不变的。

      //抽象产品
      interface Product{}
      
      //具体产品
      class ProductA implements Product{}
      class ProductB implements Product{}
      
      //将简单工厂中的工厂给抽象成接口
      interface Factory{
          Product getProduct();
      }
      //具体的工厂A,创造产品A
      class FactoryA implements Factory{
      
          public Product getProduct() {
              return new ProductA();
          }
          
      }
      //具体的工厂B,创造产品B
      class FactoryB implements Factory{
      
          public Product getProduct() {
              return new ProductB();
          }
          
      }

                        可以看到,产品部分并没有变化,只是将简单工厂中的工厂类抽象成接口,并给相应产品添加相应的工厂类,就进化成了工厂方法模式。下面我们再看工厂方法如何进化成抽象工厂模式。

      //抽象产品
      interface Product{}
      
      //具体产品
      class ProductA implements Product{}
      class ProductB implements Product{}
      
      //多了一个抽象产品1
      interface Product1{}
      
      //具体产品1
      class Product1A implements Product1{}
      class Product1B implements Product1{}
      
      //原有的工厂方法模式的工厂里添加一个方法
      interface Factory{
          Product getProduct();
          //添加另外一个产品族的创造方法
          Product1 getProduct1();
      }
      //具体的工厂A,创造产品A
      class FactoryA implements Factory{
      
          public Product getProduct() {
              return new ProductA();
          }
          //添加相应的实现
          public Product1 getProduct1() {
              return new Product1A();
          }
          
      }
      //具体的工厂B,创造产品B
      class FactoryB implements Factory{
      
          public Product getProduct() {
              return new ProductB();
          }
          //添加相应的实现
          public Product1 getProduct1() {
              return new Product1B();
          }
          
      }

                        与工厂方法对比下就发现,多了一个产品系列叫Product1,工厂接口里多了一个方法,叫getProduct1,所以抽象工厂模式就是工厂方法模式添加了抽象产品所演变而来的。
                        有关工厂的三个模式到这里就全部介绍完了,三者有着很大的关联和明显的关系,要想灵活运用这三种设计模式,还是要彻底理解它们所针对的问题以及三者的关系。下面罗列下这三种设计模式依次进化的原因。

                        1,首先从简单工厂进化到工厂方法,是因为工厂方法弥补了简单工厂对修改开放的弊端,即简单工厂违背了开闭原则。

                        2,从工厂方法进化到抽象工厂,是因为抽象工厂弥补了工厂方法只能创造一个系列的产品的弊端。

                        各位可以思考下,假设我们不使用抽象工厂模式,改用工厂方法去处理抽象工厂中多产品的问题,如何处理呢?其实很简单,就是有几个产品系列,我们就造几个工厂方法模式就可以了,只不过这样处理未免太不优雅,就像下面这样。

      //抽象产品
      interface Product{}
      
      //具体产品
      class ProductA implements Product{}
      class ProductB implements Product{}
      
      //工厂接口
      interface Factory{
          Product getProduct();
      }
      
      //具体的工厂A,创造产品A
      class FactoryA implements Factory{
      
          public Product getProduct() {
              return new ProductA();
          }
          
      }
      //具体的工厂B,创造产品B
      class FactoryB implements Factory{
      
          public Product getProduct() {
              return new ProductB();
          }
          
      }
      
      /*   以上是一个产品的工厂方法  */
      
      //抽象产品1
      interface Product1{}
      
      //具体产品1
      class Product1A implements Product1{}
      class Product1B implements Product1{}
      
      //工厂接口1
      interface Factory1{
          Product1 getProduct1();
      }
      
      //具体的工厂1A,创造产品1A
      class Factory1A implements Factory1{
      
          public Product1 getProduct1() {
              return new Product1A();
          }
          
      }
      //具体的工厂1B,创造产品1B
      class Factory1B implements Factory1{
      
          public Product1 getProduct1() {
              return new Product1B();
          }
          
      }

                      以上用两个工厂方法模式,代替了抽象工厂模式,那么可想而知,假设又多了一个产品Product2,那么我们还需要再建立一套工厂方法模式,这显然会大大增加系统的复杂性,而且也不易于客户端操作。

                      不过这也不一定就不可以,假设我们上面Product和Factory接口包括它们的一套实现是现有的,并且我们无法改变,比如是一个第三方的jar包提供的。那么为了扩展这个第三方的jar包,我们可以将jar包中的工厂方法模式扩展成为抽象工厂来达到我们扩展现有类功能的目的,就像下面这样。

      //抽象产品
      interface Product{}
      
      //具体产品
      class ProductA implements Product{}
      class ProductB implements Product{}
      
      //工厂接口
      interface Factory{
          Product getProduct();
      }
      
      //具体的工厂A,创造产品A
      class FactoryA implements Factory{
      
          public Product getProduct() {
              return new ProductA();
          }
          
      }
      //具体的工厂B,创造产品B
      class FactoryB implements Factory{
      
          public Product getProduct() {
              return new ProductB();
          }
          
      }
      
      /*   假设以上是一个第三方jar包中的工厂方法模式,我们无法改动源码   */
      
      //我们自己特有的产品
      interface MyProduct{}
      
      //我们自己特有的产品实现
      class MyProductA implements MyProduct{}
      class MyProductB implements MyProduct{}
      
      //扩展原有的工厂接口
      interface MyFactory extends Factory{
          MyProduct getMyProduct();
      }
      
      //我们自己特有的工厂A,扩展自原有的工厂A,并且实现获得我们自己特有产品的接口方法
      class MyFactoryA extends FactoryA implements MyFactory{
      
          public MyProduct getMyProduct() {
              return new MyProductA();
          }
          
      }
      //同A
      class MyFactoryB extends FactoryB implements MyFactory{
      
          public MyProduct getMyProduct() {
              return new MyProductB();
          }
          
      }

                        这样我们就可以得到我们自己特有的抽象工厂和使用我们自己特有的产品了,并且我们自己的抽象工厂还兼并了第三方jar包中的产品,例如,我们可以使用MyFactoryA获得jar包中的ProductA产品等。

                        上面的做法相当于我们从现有的体系当中,扩展出一套我们自己的继承体系,这样做的好处是我们可以完整的复用jar包中的各个类功能,缺点是继承会导致系统的复杂性增加,耦合度相对较高。

                        所以我们还可以有另外一种做法,就是创造我们自己的一套独有的工厂方法模式,这套体系与jar包中的类和接口毫无关系,我们再使用一个组合工厂将二者结合起来,就像下面这样。

      //抽象产品
      interface Product{}
      
      //具体产品
      class ProductA implements Product{}
      class ProductB implements Product{}
      
      //工厂接口
      interface Factory{
          Product getProduct();
      }
      
      //具体的工厂A,创造产品A
      class FactoryA implements Factory{
      
          public Product getProduct() {
              return new ProductA();
          }
          
      }
      //具体的工厂B,创造产品B
      class FactoryB implements Factory{
      
          public Product getProduct() {
              return new ProductB();
          }
          
      }
      
      /*   假设以上是一个第三方jar包中的工厂方法模式,我们无法改动源码   */
      
      //我们自己特有的产品
      interface MyProduct{}
      
      //我们自己特有的产品实现
      class MyProductA implements MyProduct{}
      class MyProductB implements MyProduct{}
      
      //我们自己的工厂接口
      interface MyFactory{
          MyProduct getMyProduct();
      }
      
      //我们自己特有的工厂A,产生产品A
      class MyFactoryA implements MyFactory{
          
          public MyProduct getMyProduct() {
              return new MyProductA();
          }
          
      }
      
      //我们自己特有的工厂B,产生产品B
      class MyFactoryB implements MyFactory{
          
          public MyProduct getMyProduct() {
              return new MyProductB();
          }
          
      }
      
      /*  到这里是我们自己的一套工厂方法模式,去创造我们自己的产品,以下我们将以上二者组合   */
      
      //我们使用组合的方式将我们的产品系列和jar包中的产品组合起来
      class AssortedFactory implements MyFactory,Factory{
          
          MyFactory myFactory;
          Factory factory;
          
          public AssortedFactory(MyFactory myFactory, Factory factory) {
              super();
              this.myFactory = myFactory;
              this.factory = factory;
          }
      
          public Product getProduct() {
              return factory.getProduct();
          }
      
          public MyProduct getMyProduct() {
              return myFactory.getMyProduct();
          }
          
      }

                          可以看到,组合的工厂AssortedFactory集成了我们自己的工厂和jar包中的工厂两者的功能。这样做则会非常灵活,因为我们的一套体系不再依赖于jar包中的类或接口而存在,哪怕是jar包中的类改变或者不在了,我们自己的这一套依旧可以独立存在。

                          从上面就可以看出,我们在处理很多问题的时候其实是有很多种方式的,而且每一种方式可能都有各自的好处和坏处,很难去判断说那一种方式是最好的,而且也根本就没有这个说法,所以我们能做的,就是根据实际的情况去掂量各个方式的利弊,从而选择出一种更适合当前情况的处理方式。

                          本期抽象工厂模式就到这里了,希望各位看到这里对三个与工厂相关的模式有一定自己的理解,并且可以灵活使用,达到无模式就是最好的模式的境界,甚至,我们可以把我们自己写的东西起个名字,冒充设计模式,比如最后一种我们叫它组合工厂模式。当然,LZ本人并未达到无模式的境界,正在与各位一起努力。

                          感谢各位的收看。

                          下期预告,目测是观察者模式。

                        

                           


      版权声明:本文版权归作者(左潇龙)所有,欢迎转载。但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。

      转自:http://www.zuoxiaolong.com/blog/article.ftl?id=120

    展开全文
  • 主要介绍了PHP实现设计模式中的抽象工厂模式详解,抽象工厂模式(Abstact Factory)是一种常见的软件设计模式,需要的朋友可以参考下
  • AbstractFactoryPattern抽象工厂模式模式细说抽象工厂模式定义UML抽象工厂模式场景场景一场景二上代码代码一代码二简单工厂模式,工厂方法模式,抽象工厂模式的区别 细说抽象工厂模式 提示: 博主:章飞 _906285288...

    细说抽象工厂模式

    提示:
    博主:章飞 _906285288的博客
    博客地址:http://blog.csdn.net/qq_29924041


    ## 细说抽象工厂模式

    定义

    在之前的博客中,写过简单工厂模式以及工厂方法模式,可以参考

    https://blog.csdn.net/qq_29924041/article/details/59118775
    https://blog.csdn.net/qq_29924041/article/details/60145361
    这两篇博客
    但是在工厂模式的大家族范畴内,还有一个比较难理解的抽象工厂模式,其实这种模式也是在实际生活中抽象出来,其实可以想想,在之前工厂模式中,简单工厂模式是一个工厂去生产不同产品,而在工厂方法模式中,是每一个单一的产品都对应了一个具体的工厂,但是在实际生活中,还有一种场景,就是一个工厂既可以去生产主要的产品,也可以去生产附加的其它产品,也就是从抽象工厂的角度来说,每一个实际的工厂都是可以去生产具体的产品信息,达到一种生产对象多对多的场景

    来自百科的具体定义

    抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品族中的产品对象。根据里氏替换原则,任何接受父类型的地方,都应当能够接受子类型。因此,实际上系统所需要的,仅仅是类型与这些抽象产品角色相同的一些实例,而不是这些抽象产品的实例。换言之,也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例

    UML

    在这里插入图片描述
    从图中可以看到,Creator这个抽象工厂类,实际是可以生产两种不同的产品,具体到的ConcreteCreator1,可以生产产品A,也可以生产产品B,从而达到一类工厂去生产某一类产品族的效果

    抽象工厂模式场景

    场景一

    来自设计模式之禅中的案例,女娲造人传说,世界上的人可以根据肤色分为黄种人,白种人,黑人,根据性别又可以分成男性,女性,所以自由搭配下,会有6中具体的人。工厂则可以定位,男性和女性工厂,男性工厂去生产所有是男性的不同人种,而女性工厂则去生产所有是女性的不同人种类型。 因此顶层抽象工厂生成的产品类型其实就是有差异的

    场景二

    在之前的工厂模式的博客中都是使用小米公司的产品来做案例的,小米有生成手机的工厂,同时也有生成电视的共产,生成手机的工厂可能不需要去生产电视,但是生产手机的工厂可能需要去生产手机的配件,或者手机礼品等等,而生产电视的共产也可能去生产电视的相关配件,电视礼品等等。这也就是一个工厂根据需要去生产不同的产品信息,这实际上都是一个工厂生成不同的产品

    上代码

    代码一

    定义一个抽象的人类

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public interface Human {
    
    	//首先定义什么是人类
    	//人是愉快的,会笑的,本来是想用smile表示,想了一下laugh更合适,好长时间没有大笑了;
    	public void laugh();
    	//人类还会哭,代表痛苦
    	public void cry();
    	//人类会说话
    	public void talk();
    	//定义性别
    	public void sex();
    
    }
    

    定义抽象黑人类型,黑人具体分为男性黑人和女性黑人

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public abstract class AbstractBlackHuman implements Human{
    	public void cry() {
    		System.out.println("黑色人种会哭");
    	}
    
    	public void laugh() {
    		System.out.println("黑色人种会大笑,幸福呀!");
    	}
    	
    	public void talk() {
    		System.out.println("黑色人种会说话,一般说的都是双字节");
    	}
    }
    

    定义抽象白人类型,白人具体分为男性白人和女性白人

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public abstract class AbstractWhiteHuman implements Human{
    
    	public void cry() {
    		System.out.println("白色人种会哭");
    	}
    
    	public void laugh() {
    		System.out.println("白色人种会大笑,幸福呀!");
    	}
    	
    	public void talk() {
    		System.out.println("白色人种会说话,一般说的都是双字节");
    	}
    }
    
    

    定义抽象黄种人类型,黄钟人具体分为男性黄种人和女性黄种人

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    /**
     * 为什么要修改成抽象类呢?要定义性别呀
     * @author zhangfei.zhou
     *
     */
    public abstract class AbstractYellowHuman implements Human{
    	
    		public void cry() {
    			System.out.println("黄色人种会哭");
    		}
    
    		public void laugh() {
    			System.out.println("黄色人种会大笑,幸福呀!");
    		}
    		
    		public void talk() {
    			System.out.println("黄色人种会说话,一般说的都是双字节");
    		}
    	
    
    }
    
    
    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class BlackFemaleHuman extends AbstractBlackHuman{
    
    	@Override
    	public void sex() {
    		// TODO Auto-generated method stub
    		System.out.println("该黑种人的性别为女...");
    	}
    
    }
    
    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class BlackMaleHuman extends AbstractBlackHuman{
    
    	@Override
    	public void sex() {
    		// TODO Auto-generated method stub
    		System.out.println("该黑种人的性别为男...");
    	}
    
    }
    
    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class WhiteFemaleHuman extends AbstractWhiteHuman{
    
    	@Override
    	public void sex() {
    		// TODO Auto-generated method stub
    		System.out.println("该白种人的性别为女...");
    	}
    
    }
    
    
    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class WhiteMaleHuman extends AbstractWhiteHuman{
    
    	@Override
    	public void sex() {
    		// TODO Auto-generated method stub
    		System.out.println("该白种人的性别为男...");
    	}
    
    }
    
    
    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class YellowFemaleHuman extends AbstractYellowHuman{
    
    	@Override
    	public void sex() {
    		// TODO Auto-generated method stub
    		System.out.println("该黄种人的性别为女...");
    	}
    
    }
    
    
    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class YellowMaleHuman extends AbstractYellowHuman{
    
    	@Override
    	public void sex() {
    		// TODO Auto-generated method stub
    		System.out.println("该黄种人的性别为男...");
    	}
    
    }
    
    

    定义顶层的工厂,用于去生产黄种人,白种人,黑人

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public interface HumanFactory {
    	//制造黄色人种
    	public Human createYellowHuman();
    	//制造一个白色人种
    	public Human createWhiteHuman();
    	//制造一个黑色人种
    	public Human createBlackHuman();
    }
    
    

    抽象工厂类型,主要是定义清楚创建方法

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    public abstract class AbstractHumanFactory implements HumanFactory{
    	protected Human createHuman(Class<? extends Human> humanEnumClass){
    		
    		try {
    			return humanEnumClass.newInstance();
    		} catch (InstantiationException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    		
    	}
    }
    
    

    生产女性的工厂

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class FemaleHumanFactory extends AbstractHumanFactory{
    
    	@Override
    	public Human createYellowHuman() {
    		// TODO Auto-generated method stub
    		return super.createHuman(YellowFemaleHuman.class);
    	}
    
    	@Override
    	public Human createWhiteHuman() {
    		// TODO Auto-generated method stub
    		return super.createHuman(WhiteFemaleHuman.class);
    	}
    
    	@Override
    	public Human createBlackHuman() {
    		// TODO Auto-generated method stub
    		return super.createHuman(BlackFemaleHuman.class);
    	}
    
    }
    
    

    生产男性的工厂

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class MaleHumanFactory extends AbstractHumanFactory{
    
    	@Override
    	public Human createYellowHuman() {
    		// TODO Auto-generated method stub
    		return super.createHuman(YellowMaleHuman.class);
    	}
    
    	@Override
    	public Human createWhiteHuman() {
    		// TODO Auto-generated method stub
    		return super.createHuman(WhiteFemaleHuman.class);
    	}
    
    	@Override
    	public Human createBlackHuman() {
    		// TODO Auto-generated method stub
    		return super.createHuman(BlackMaleHuman.class);
    	}
    
    }
    
    

    女娲开始使用工厂造人啦

    package src.com.zzf.designpattern.abstractfactorypattern.demo2;
    
    public class NvWa {
    	public static void main(String[] args) {
    		//第一条生产线,男性生产线
    		HumanFactory maleHumanFactory = new MaleHumanFactory();
    		
    		//第二条生产线,女性生产线
    		HumanFactory femaleHumanFactory = new FemaleHumanFactory();
    		
    		//生产线建立完毕,开始生产人了:
    		Human maleYellowHuman = maleHumanFactory.createYellowHuman();
    		
    		Human femaleYellowHuman = femaleHumanFactory.createYellowHuman();
    		
    		maleYellowHuman.cry();
    		maleYellowHuman.laugh();
    		maleYellowHuman.sex();
    		
    		femaleYellowHuman.cry();
    		femaleYellowHuman.laugh();
    		femaleYellowHuman.sex();
    	}
    }
    
    

    以上案例来自于设计模式之禅

    代码二

    定义一个顶层的产品

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    
    public interface IProduct {
    	public void show();
    }
    
    

    定义一个顶层的礼品类

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    public interface IGift {
    	void showGiftName();
    }
    
    

    定义清楚小米手机产品

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    
    public class XiaoMiShouji implements IProduct{
    
    	public void show() {
    		// TODO Auto-generated method stub
    		System.out.println("XiaoMiShouji show");
    	}
    
    }
    

    定义清楚小米电视产品

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    
    public class XiaomiTv implements IProduct{
    
    	public void show() {
    		// TODO Auto-generated method stub
    		System.out.println("XiaomiTv");
    	}
    
    }
    

    定义清楚小米电视的礼品

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    public class TvGuajianGift implements IGift{
    
    	@Override
    	public void showGiftName() {
    		// TODO Auto-generated method stub
    		System.out.println("电视机挂件礼物");
    	}
    
    }
    
    

    定义清楚小米手机挂件礼品

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    public class ShouJiGuajianGift implements IGift{
    
    	@Override
    	public void showGiftName() {
    		// TODO Auto-generated method stub
    		System.out.println("手机挂件");
    	}
    }
    
    

    定义清楚小米顶层的工厂类型

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    
    public interface IFactory {
    	public IProduct createProduct();
    	
    	public IGift createGift();
    }
    
    

    小米手机工厂

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    
    public class XiaomiShoujiFactory implements IFactory{
    
    	public IProduct createProduct() {
    		// TODO Auto-generated method stub
    		return new XiaoMiShouji();
    	}
    
    	@Override
    	public IGift createGift() {
    		// TODO Auto-generated method stub
    		return new ShouJiGuajianGift();
    	}
    }
    
    

    小米电视工厂

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    
    public class XiaomiTvFactory implements IFactory{
    
    	public IProduct createProduct() {
    		// TODO Auto-generated method stub
    		return new XiaomiTv();
    	}
    
    	@Override
    	public IGift createGift() {
    		// TODO Auto-generated method stub
    		return new TvGuajianGift();
    	}
    
    }
    
    

    测试代码

    package src.com.zzf.designpattern.abstractfactorypattern.demo1;
    
    
    /**
     * 抽象工厂模式,工厂可以生产不同的产品类型
     * @author Administrator
     *
     */
    public class FactoryMethodPatternTest {
    	public static void main(String[] args) {
    		//抽象工厂模式生产了手机
    		IFactory mFactory = new XiaomiShoujiFactory();
    		mFactory.createProduct().show();
    		mFactory.createGift().showGiftName();
    		
    		mFactory = new XiaomiTvFactory();
    		mFactory.createProduct().show();
    		mFactory.createGift().showGiftName();
    	}
    }
    
    

    以上两段代码都是抽象工厂模式下一种简单应用。

    简单工厂模式,工厂方法模式,抽象工厂模式的区别

    在这里总结一下:
    1:简单工厂模式:一个工厂去生产不同的产品

    2:工厂方法模式:每一个具体的产品都需要对应一个具体的工厂去生产

    3:抽象工厂模式:每一个工厂可以生产不同的具体的产品。工厂是抽象的,产品族也是抽象的,抽象工厂模式较好的实现了“开放-封闭”原则,是三个模式中较为抽象,并具一般性的模式


    抽象工厂模式相对其它两个工厂模式来说稍微复杂一点点,但是结合现实生活场景中也有很多场景案例。也可以很好的理解。

    欢迎继续访问,我的博客
    展开全文
  • 本文实例讲述了Android编程设计模式之抽象工厂模式。分享给大家供大家参考,具体如下: 一、介绍 抽象工厂模式(Abstract Factory Pattern),也是创建型设计模式之一。前一节我们已经了解了工厂方法模式,那么这个...
  • 抽象工厂模式比工厂模式更为复杂,就像上面提到的缺点一样,工厂模式和简单工厂模式要求产品子类必须要是同一类型的,拥有共同的方法,这就限制了产品子类的扩展。于是为了更加方便的扩展,抽象工厂模式就将同一类的...

    工厂模式的核心思想

    核心思想就是降低耦合

    工厂模式是为了使得程序统一,降低各个模块之间的耦合,达到结构清晰的目的。

    降低耦合指的是:降低各个模块、各个类之间的联系,为了修改的时候可以方便,以免引起修改了一处,其他各处全需要修改,也为了将来复用代码。

    举个例子,比如给一个字符串,为了统计小写、大写、数字的个数,将来还要扩展统计其他汉字、韩文等个数,首先他们有个共同的特性,就是统计个数,这就需要工厂模式了。

    抽象工厂模式

    提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。

    抽象工厂模式比工厂模式更为复杂,就像上面提到的缺点一样,工厂模式和简单工厂模式要求产品子类必须要是同一类型的,拥有共同的方法,这就限制了产品子类的扩展。于是为了更加方便的扩展,抽象工厂模式就将同一类的产品子类归为一类,让他们继承同一个抽象子类,我们可以把他们一起视作一组,然后好几组产品构成一族。

    代码实现示例:分别为小米和华为制造手机和电视,小米和华为有不同的手机和电视,即就是多个工厂,一个工厂可以产生多个产品。

    //抽象工厂设计模式.cpp : 定义控制台应用程序的入口点。
    
    #include<iostream>
    using namespace std;
    
    class CPHONE	//抽象手机类
    {
    public:
    	virtual void show() = 0;
    };
    
    class Cxiaomiphone :public CPHONE	//具体产品小米手机类
    {
    public:
    	void show()
    	{
    		cout << "xiaomi phone produce!" << endl;
    	}
    };
    
    class Chuaweiphone :public CPHONE	//具体产品华为手机类
    {
    public:
    	void show()
    	{
    		cout << "huawei phone produce!" << endl;
    	}
    };
    
    class CTV	//抽象电视类
    {
    public:
    	virtual void show() = 0;
    };
    
    class Cxiaomitv :public CTV	//具体产品小米电视类
    {
    public:
    	void show()
    	{
    		cout << "xiaomi TV produce!" << endl;
    	}
    };
    
    class Chuaweitv :public CTV	//具体产品华为电视类
    {
    public:
    	void show()
    	{
    		cout << "huawei TV produce!" << endl;
    	}
    };
    
    class Factory	//抽象工厂类
    {
    public:
    	virtual CPHONE* CREATEPHONE() = 0;
    	virtual CTV* CREATETV() = 0;
    };
    
    class Factory_XIAOMI :public Factory	//具体小米工厂类
    {
    public:
    	CPHONE* CREATEPHONE()
    	{
    		return new Cxiaomiphone();
    	}
    	CTV* CREATETV()
    	{
    		return  new Cxiaomitv();
    	}
    };
    
    class Factory_HUAWEI :public Factory	//具体华为工厂类
    {
    public:
    	CPHONE* CREATEPHONE()
    	{
    		return new Chuaweiphone();
    	}
    	CTV* CREATETV()
    	{
    		return  new Chuaweitv();
    	}
    };
    
    int main()
    {
    	//小米
    	Factory* factory = new Factory_XIAOMI();
    	CPHONE* phone = factory->CREATEPHONE();
    	CTV* tv = factory->CREATETV();
    	phone->show();
    	tv->show();
    
    	//华为
    	factory = new Factory_HUAWEI();
    	phone = factory->CREATEPHONE();
    	tv = factory->CREATETV();
    	phone->show();
    	tv->show();
    
    	delete factory;
    	delete phone;
    	delete tv;
    	return 0;
    }
    
    

    在这里插入图片描述

    抽象工厂的优点

    需求改变时改动最小;具体的创建实例的过程与客户端分离,客户端通过抽象接口工厂类进行操作实例,产品的具体类名也被具体工厂的实现分离,不出现在客户端代码中(客户端只知道有一个抽象工厂,一个抽象的手机类和一个抽象的电视类)。

    抽象工厂的缺点

    新增功能时,比如小米和华为都有电脑,那就要增加3个类(抽象电脑类,具体小米电脑类,具体华为电脑类),还要修改2个具体的工厂类(小米工厂类,华为工厂类)。

    展开全文
  • 为了解决上述的问题,我们又使用了一种新的设计模式:抽象工厂模式。 UML类图 抽象工厂模式中存在四种角色,分别是抽象工厂角色,具体工厂角色,抽象产品角色,具体产品角色。 抽象工厂角色:担任这个角色的是工厂...

    前言

    在上文提到的最易懂的设计模式系列解析:工厂方法模式,发现工厂方法模式存在一个严重的问题:一个具体工厂只能创建一类产品而在实际过程中,一个工厂往往需要生产多类产品。

    为了解决上述的问题,我们又使用了一种新的设计模式:抽象工厂模式。

    UML类图

    在这里插入图片描述

    1. 抽象工厂模式中存在四种角色,分别是抽象工厂角色,具体工厂角色,抽象产品角色,具体产品角色。
    2. 抽象工厂角色:担任这个角色的是工厂方法模式的核心,它是与应用系统商业逻辑无关的。
    3. 具体工厂角色:这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑,而这个逻辑是与应用系统的商业逻辑紧密相关的。
    4. 抽象产品角色:担任这个角色的类是工厂方法模式所创建的对象的父类,或它们共同拥有的接口。
    5. 具体产品角色:抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西,其内部一定充满了应用系统的商业逻辑。
    定义

    抽象工厂模式,即Abstract Factory Pattern,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类;具体的工厂负责实现具体的产品实例。

    抽象工厂模式与工厂方法模式最大的区别:抽象工厂中每个工厂可以创建多种类的产品,而工厂方法每个工厂只能创建一类

    主要作用

    允许使用抽象的接口来创建一组相关产品,而不需要知道或关心实际生产出的具体产品是什么,这样就可以从具体产品中被解耦。

    解决的问题

    每个工厂只能创建一类产品。

    案例

    完成步骤

    1、 创建抽象工厂类,定义具体工厂的公共接口;
    2、 创建抽象产品族类 ,定义抽象产品的公共接口;
    3、创建抽象产品类 (继承抽象产品族类),定义具体产品的公共接口;
    4、创建具体产品类(继承抽象产品类) & 定义生产的具体产品;
    5、创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;
    6、客户端通过实例化具体的工厂类,并调用其创建不同目标产品的方法创建不同具体产品类的实例。

    实例概况

    背景:小成有两间塑料加工厂(A厂仅生产容器类产品;B厂仅生产模具类产品);随着客户需求的变化,A厂所在地的客户需要也模具类产品,B厂所在地的客户也需要容器类产品;
    痛点:没有资源(资金+租位)在当地分别开设多一家注塑分厂
    解决方案:在原有的两家塑料厂里增设生产需求的功能,即A厂能生产容器+模具产品;B厂间能生产模具+容器产品。

    代码展示

    步骤1: 创建抽象工厂类,定义具体工厂的公共接口:

    abstract class Factory{
       public abstract Product ManufactureContainer();
        public abstract Product ManufactureMould();
    }
    

    步骤2: 创建抽象产品族类 ,定义具体产品的公共接口:

    abstract class AbstractProduct{
        public abstract void Show();
    }
    

    步骤3: 创建抽象产品类 ,定义具体产品的公共接口:

    //容器产品抽象类
    abstract class ContainerProduct extends AbstractProduct{
        @Override
        public abstract void Show();
    }
    
    //模具产品抽象类
    abstract class MouldProduct extends AbstractProduct{
        @Override
        public abstract void Show();
    }
    

    步骤4: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;

    //容器产品A类
    class ContainerProductA extends ContainerProduct{
        @Override
        public void Show() {
            System.out.println("生产出了容器产品A");
        }
    }
    
    //容器产品B类
    class ContainerProductB extends ContainerProduct{
        @Override
        public void Show() {
            System.out.println("生产出了容器产品B");
        }
    }
    
    //模具产品A类
    class MouldProductA extends MouldProduct{
    
        @Override
        public void Show() {
            System.out.println("生产出了模具产品A");
        }
    }
    
    //模具产品B类
    class MouldProductB extends MouldProduct{
    
        @Override
        public void Show() {
            System.out.println("生产出了模具产品B");
        }
    }
    

    步骤5:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法:

    //A厂 - 生产模具+容器产品
    class FactoryA extends Factory{
    
        @Override
        public Product ManufactureContainer() {
            return new ContainerProductA();
        }
    
        @Override
        public Product ManufactureMould() {
            return new MouldProductA();
        }
    }
    
    //B厂 - 生产模具+容器产品
    class FactoryB extends Factory{
    
        @Override
        public Product ManufactureContainer() {
            return new ContainerProductB();
        }
    
        @Override
        public Product ManufactureMould() {
            return new MouldProductB();
        }
    }
    

    步骤6:客户端通过实例化具体的工厂类,并调用其创建不同目标产品的方法创建不同具体产品类的实例:

    //生产工作流程
    public class AbstractFactoryPattern {
        public static void main(String[] args){
            FactoryA mFactoryA = new FactoryA();
            FactoryB mFactoryB = new FactoryB();
            //A厂当地客户需要容器产品A
            mFactoryA.ManufactureContainer().Show();
            //A厂当地客户需要模具产品A
            mFactoryA.ManufactureMould().Show();
    
            //B厂当地客户需要容器产品B
            mFactoryB.ManufactureContainer().Show();
            //B厂当地客户需要模具产品B
            mFactoryB.ManufactureMould().Show();
    
        }
    }
    

    结果

    生产出了容器产品A
    生产出了容器产品B
    生产出了模具产品A
    生产出了模具产品B
    

    优点

    1、降低耦合:抽象工厂模式将具体产品的创建延迟到具体工厂的子类中,这样将对象的创建封装起来,可以减少客户端与具体产品类之间的依赖,从而使系统耦合度低,这样更有利于后期的维护和扩展;

    2、更符合开-闭原则:新增一种产品类时,只需要增加相应的具体产品类和相应的工厂子类即可,简单工厂模式需要修改工厂类的判断逻辑;

    3、符合单一职责原则:每个具体工厂类只负责创建对应的产品,简单工厂中的工厂类存在复杂的switch逻辑判断;

    4、不使用静态工厂方法,可以形成基于继承的等级结构,简单工厂模式的工厂类使用静态工厂方法。

    缺点

    抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合,如果需要添加新产品,此时就必须去修改抽象工厂的接口,这样就涉及到抽象工厂类的以及所有子类的改变,这样也就违背了“开发——封闭”原则。

    对于新的产品族符合开-闭原则;对于新的产品种类不符合开-闭原则,这一特性称为开-闭原则的倾斜性。

    应用场景

    在了解了优缺点后,我总结了工厂方法模式的应用场景:

    1、一个系统不要求依赖产品类实例如何被创建、组合和表达的表达,这点也是所有工厂模式应用的前提;
    2、这个系统有多个系列产品,而系统中只消费其中某一系列产品;
    3、系统要求提供一个产品类的库,所有产品以同样的接口出现,客户端不需要依赖具体实现。

    展开全文
  • (五)抽象工厂模式详解  作者:zuoxiaolong8810(左潇龙),转载请注明出处,特别说明:本博文来自博主原博客,为保证新博客中博文的完整性,特复制到此留存,如需转载请注明新博客地址即可。  前两章我们已经...
  • Java抽象工厂模式详解

    2019-07-11 16:54:21
    工厂方法模式有一个缺点,他的一个工厂只能生产一种产品,那么要解决工厂类爆炸,我们就引入的产品族的概念,...抽象工厂模式角色分析: 1. 抽象的各种产品族(产品接口) 2. 集成各种产品族的具体实现类(具体...
  • 抽象工厂模式详解(四)

    千次阅读 2018-05-27 11:38:45
     简单的说,抽象工厂模式是工厂方法模式的升级版本,当存在多个产品族时,产品族之间是存在相关或者依赖关系,可以使用抽象工厂来创建产品。二、实例分析 网上已经有很多关于宝马的抽象工厂的例子了,这里我们不在...
  • 工厂模式,工厂方法模式,抽象工厂模式 详解

    万次阅读 多人点赞 2017-03-09 10:02:25
    1. 工厂模式 1.1 定义 简单工厂模式是由一个工厂对象根据收到的消息决定要创建哪一个类的对象实例。 1.2 使用场景 工厂类负责创建的对象比较少,客户只需要传入工厂类参数,对于如何创建对象(逻辑)不关心。简单...
  • 设计模式——抽象工厂模式详解

    万次阅读 多人点赞 2016-08-21 17:05:41
    建议先看博文前半部分的理论介绍,再看后半部分的实例分析,最后再返回来复习一遍理论介绍,这时候你就会发现我在重点处标红的用心,对于帮助你理解设计模式有奇效哦~无论是工厂方法模式,还是抽象工厂模式,都属于...
  • package java_231_GOF23设计模式_抽象工厂模式详解_练习; /** Engine发动机接口 */ public interface Engine { void run();//run运转 void start();//start启动 } //实现类1;LuxuryEngine高端发动机 class ...
  • 上一篇讲到的工厂模式,类的创建依赖工厂类,比如我新添加一种铅笔的对象类,那么就必须在工厂类里面
  • 走穿java23种设计模式-3工厂方法模式详解工厂模式可以分为:简单工厂模式,工厂方法模式,抽象工厂模式。简单工厂模式就没什么好说的了,无非是所有的东西都写在一个类里面,要什么就调用什么,如果要添加新的方法也...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,617
精华内容 4,646
关键字:

抽象工厂模式详解