`

设计模式——工厂方法模式、抽象工厂模式

阅读更多

一、引子

       话说十年前,有一个暴发户,他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪,还雇了司机为他开车。不过,暴发户坐车时总是怪怪的:上Benz车后跟司机说开奔驰车!,坐上Bmw后他说开宝马车!,坐上Audi开奥迪车!。你一定说:这人有病!直接说开车不就行了?!

       而当把这个暴发户的行为放到我们程序设计中来时,会发现这是一个普遍存在的现象。幸运的是,这种有病的现象在OO(面向对象)语言中可以避免了。下面就以Java语言为基础来引入我们本文的主题:工厂模式。

二、分类

      工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。

工厂模式在《Java与模式》中分为三类:
       1,简单工厂模式(Simple Factory

2,工厂方法模式(Factory Method

3,抽象工厂模式(Abstract Factory
       这三种模式从上到下逐步抽象,并且更具一般性。
       GOF在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。将简单工厂模式(Simple Factory)看为工厂方法模式的一种特例,两者归为一类。

两者皆可,在本文使用《Java与模式》的分类方法。下面来看看这些工厂模式是怎么来治病的。

 

三、简单工厂模式

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的接口。

先来看看它的组成:

      1,工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

      2,抽象产品角色:它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

      3,具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

来用类图来清晰的表示下的它们之间的关系: 


那么简单工厂模式怎么来使用呢?我们就以简单工厂模式来改造暴发户坐车的方式——现在暴发户只需要坐在车里对司机说句:开车就可以了。

//抽象产品角色
public interface Car{
        public void drive(); 
}
 
//具体产品角色
public class Benz implements Car{
        public void drive()  {
                System.out.println("Driving Benz ");
        }
}
 
public class Bmw implements Car{
        public void drive()  {
                System.out.println("Driving Bmw ");
        }
}
 

 

。。。(奥迪我就不写了:P

//工厂类角色
public class Driver{
//工厂方法.注意 返回类型为抽象产品角色
       public static Car driverCar(String s)throws Exception    {
              //判断逻辑,返回具体的产品角色给Client
              if(s.equalsIgnoreCase("Benz"))  
                    return new Benz();
              else if(s.equalsIgnoreCase("Bmw"))
                     return new Bmw();
                    ......   
             else throw new Exception();
 
       。。。

//欢迎暴发户出场......
public class Magnate{
 
       public static void main(String[] args){
              try{ 
                     //告诉司机我今天坐奔驰              
                     Car car = Driver.driverCar("benz"); 
                     //下命令:开车                   
                     car.drive();
              。。。

 

      程序中各个类的关系表达如下:


 

这便是简单工厂模式了。怎么样,使用起来很简单吧?那么它带来了什么好处呢?
       首先,使用了简单工厂模式后,我们的程序不在有病,更加符合现实中的情况;而且客户端免除了直接创建产品对象的责任,而仅仅负责消费产品(正如暴发户所为)。 

       下面我们从开闭原则(对扩展开放;对修改封闭)上来分析下简单工厂模式。当暴发户增加了一辆车的时候,只要符合抽象产品制定的合同,那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说,它是符合开闭原则的;但是工厂部分好像不太理想,因为每增加一辆车,都要在工厂类中增加相应的业务逻辑或者判断逻辑,这显然是违背开闭原则的。可想而知对于新产品的加入,工厂类是很被动的。对于这样的工厂类(在我们的例子中是为司机师傅),我们称它为全能类或者上帝类。
       我们举的例子是最简单的情况,而在实际应用中,很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品,所以这可能会把我们的上帝累坏了,也累坏了我们这些程序员:(
       
于是工厂方法模式作为救世主出现了。 

四、工厂方法模式

       工厂方法模式去掉了简单工厂模式中工厂方法的静态属性,使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

 

你应该大致猜出了工厂方法模式的结构,来看下它的组成:

      1,抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

      2,具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

      3,抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

      4,具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

 

用类图来清晰的表示下的它们之间的关系:


工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的上帝类。正如上面所说,这样便分担了对象承受的压力;而且这样使得结构变得灵活起来——当有新的产品(即暴发户的汽车)产生时,只要按照抽象产品角色、抽象工厂角色提供的合同来生成,那么就可以被客户使用,而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的!

       我们还是老规矩,使用一个完整的例子来看看工厂模式各个角色之间是如何来协调的。话说暴发户生意越做越大,自己的爱车也越来越多。这可苦了那位司机师傅了,什么车它都要记得,维护,都要经过他来使用!于是暴发户同情他说:看你跟我这么多年的份上,以后你不用这么辛苦了,我给你分配几个人手,你只管管好他们就行了!于是,工厂方法模式的管理出现了。代码如下:

 

//抽象产品角色,具体产品角色与简单工厂模式类似,只是变得复杂了些,这里略。
//抽象工厂角色
public interface Driver{
    public Car driverCar();
}
public class BenzDriver implements Driver{
    public Car driverCar(){
        return new Benz();
    }
}
public class BmwDriver implements Driver{
    public Car driverCar()   {
        return new Bmw(); 
    }
}
 
//应该和具体产品形成对应关系...
//有请暴发户先生
 public class Magnate
{
    public static void main(String[] args)
    {
        try{ 
            Driver driver = new BenzDriver();
            Car car = driver.driverCar();
            car.drive();
        }
       ……
}
 

可以看出工厂方法的加入,使得对象的数量成倍增长。当产品种类非常多时,会出现大量的与之对应的工厂对象,这不是我们所希望的。因为如果不能避免这种情况,可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类:即对于产品树上类似的种类(一般是树的叶子中互为兄弟的)使用简单工厂模式来实现。

 

 小结

工厂方法模式仿佛已经很完美的对对象的创建进行了包装,使得客户程序中仅仅处理抽象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢?大可不必。也许在下面情况下你可以考虑使用工厂方法模式:

 

     1,当客户程序不需要知道要使用对象的创建过程。

     2,客户程序使用的对象存在变动的可能,或者根本就不知道使用哪一个具体的对象。 

 

简单工厂模式与工厂方法模式真正的避免了代码的改动了?没有。在简单工厂模式中,新产品的加入要修改工厂角色中的判断语句;而在工厂方法模式中,要么将判断逻辑留在抽象工厂角色中,要么在客户程序中将具体工厂角色写死(就象上面的例子一样)。而且产品对象创建条件的改变必然会引起工厂角色的修改。

 

       面对这种情况,Java的反射机制与配置文件的巧妙结合突破了限制——这在Spring中完美的体现了出来。

 

五、抽象工厂模式

      先来认识下什么是产品族: 位于不同产品等级结构中,功能相关联的产品组成的家族。还是让我们用一个例子来形象地说明一下吧。


 

图中的BmwCarBenzCar就是两个产品树(产品层次结构);而如图所示的BenzSportsCarBmwSportsCar就是一个产品族。他们都可以放到跑车家族中,因此功能有所关联。同理BmwBussinessCarBenzSportsCar也是一个产品族。

回到抽象工厂模式的话题上。

 

可以说,抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。

 

抽象工厂模式的用意为:给客户端提供一个接口,可以创建多个产品族中的产品对象

 

而且使用抽象工厂模式还要满足一下条件:

 

1)        系统中有多个产品族,而系统一次只可能消费其中一族产品。

2)        同属于同一个产品族的产品以其使用。

 

来看看抽象工厂模式的各个角色(和工厂方法的如出一辙):

 

      1,抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

      2,具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。

      3,抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

      4,具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

类图如下:

看过了前两个模式,对这个模式各个角色之间的协调情况应该心里有个数了,我就不举具体的例子了。只是一定要注意满足使用抽象工厂模式的条件哦。

 

抽象工厂示例:

 

// 产品 Plant接口      
public interface Plant { }//标志接口    
//具体产品PlantA,PlantB      
public class PlantA implements Plant {       
    public PlantA () {      
        System.out.println("create PlantA !");      
    }         
  public void doSomething() {      
   System.out.println(" PlantA do something ...");      
  }      
}      
public class PlantB implements Plant {      
  public PlantB () {      
   System.out.println("create PlantB !");      
  }      
    
  public void doSomething() {      
   System.out.println(" PlantB do something ...");      
  }      
}      
// 产品 Fruit接口      
public interface Fruit { }      
//具体产品FruitA,FruitB      
public class FruitA implements Fruit {      
  public FruitA() {      
   System.out.println("create FruitA !");      
  }      
  public void doSomething() {      
   System.out.println(" FruitA do something ...");      
  }      
}      
public class FruitB implements Fruit {      
  public FruitB() {      
   System.out.println("create FruitB !");      
  }      
  public void doSomething() {      
   System.out.println(" FruitB do something ...");      
  }      
}      
// 抽象工厂方法      
public interface AbstractFactory {      
  public Plant createPlant();      
  public Fruit createFruit();      
}      
//具体工厂方法      
public class FactoryA implements AbstractFactory {      
  public Plant createPlant() {      
   return new PlantA();      
  }      
  public Fruit createFruit() {      
   return new FruitA();      
  }      
}      
public class FactoryB implements AbstractFactory {      
  public Plant createPlant() {      
   return new PlantB();      
  }      
  public Fruit createFruit() {      
   return new FruitB();      
  }      
}

 

 

//调用工厂方法     
public Client {     
      public method1() {     
             AbstractFactory instance = new FactoryA();     
             instance.createPlant();     
       }     
}  
 

抽象工厂模式与工厂方法模式的区别 

可以这么说,工厂方法模式是一种极端情况的抽象工厂模式,而抽象工厂模式可以看成是工厂方法模式的一种推广。

(1)、其实工厂方法模式是用来创建一个产品的等级结构的,而抽象工厂模式是用来创建多个产品的等级结构的。工厂方法创建一般只有一个方法,创建一种产品。抽象工厂一般有多个方法,创建一系列产品。 

(2)、工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。 

简而言之

工厂方法模式:一个抽象产品类,可以派生出多个具体产品类。   
             
一个抽象工厂类,可以派生出多个具体工厂类。   
             
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式:多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。   
             
一个抽象工厂类,可以派生出多个具体工厂类。   
             
每个具体工厂类可以创建多个具体产品类的实例。 

 

  • 大小: 15.1 KB
  • 大小: 22.6 KB
  • 大小: 31.4 KB
  • 大小: 24.4 KB
  • 大小: 43.8 KB
分享到:
评论

相关推荐

    设计模式——工厂方法模式

    工厂方法模式是面向对象设计模式中的一种,它属于创建型模式,主要解决的是当系统需要创建的对象具有多种类型,而具体创建哪种类型的对象在运行时才能确定的问题。在这个压缩包中,`FactoryMethod`可能包含了Java...

    设计模式——抽象工厂模式

    抽象工厂模式是设计模式中的一种创建型模式,它提供了一种创建对象集合的接口,而无需指定具体类。这种模式的主要目的是为了隔离产品对象的创建和使用,使得系统对产品类的依赖降低到最低,同时也方便了产品的扩展和...

    软件设计模式——抽象工厂

    抽象工厂模式是一种重要的软件设计模式,它属于创建型模式,主要解决的是当系统需要创建一系列相关或相互依赖的对象时,而这些对象的类在运行时可能不确定的问题。在这个模式中,我们通过一个抽象工厂接口来定义创建...

    Android之大话设计模式——:抽象工厂模式借鉴.pdf

    Android之大话设计模式——:抽象工厂模式借鉴.pdf

    Android之大话设计模式——:抽象工厂模式参考.pdf

    Android之大话设计模式——:抽象工厂模式参考.pdf

    c#工厂模式——简单工厂,抽象工厂,单件模式实例

    抽象工厂模式则更进一步,它提供了一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类。在多线程或者跨平台的C#应用中,抽象工厂可以帮助我们隔离产品族,使得更换产品族变得容易。例如,我们可以有...

    抽象工厂模式+工厂方法模式+策略模式+类图实现手机加工厂

    本文将探讨三个重要的设计模式:抽象工厂模式、工厂方法模式以及策略模式,并结合一个实际的场景——手机加工厂,来具体阐述它们的应用。 首先,我们来看**抽象工厂模式**。这个模式主要用于创建相关或依赖对象的...

    设计模式实现——抽象工厂模式结构实现

    抽象工厂模式是设计模式中的一种创建型模式,它提供了一种创建对象集合的接口,而无需指定具体的类。这种模式允许客户端使用一个通用接口来创建一组相关或相互依赖的对象,而无需关心它们的具体实现。在Java或其他...

    设计模式——简单工厂模式

    **设计模式——简单工厂模式** 简单工厂模式是创建型设计模式的一种,它提供了一种创建对象的最佳方式。...在实际开发中,根据项目需求和规模,可能会选择更复杂的工厂模式,如工厂方法模式或抽象工厂模式。

    设计模式——简单工厂 VS 工厂方法

    工厂方法模式则更进一步,它属于抽象工厂模式的一种特殊形式。在这个模式中,我们定义一个创建对象的接口,但让子类决定实例化哪一个类。工厂方法将类的实例化推迟到子类。这样,工厂方法模式使得系统在不指定具体...

    c#工厂模式——简单工厂_抽象工厂实例

    根据应用场景的不同,工厂模式可以进一步分为简单工厂模式、工厂方法模式以及抽象工厂模式。 #### 二、简单工厂模式 简单工厂模式是最基础的工厂模式实现方式,它的主要特点是使用一个工厂类来负责创建所有产品...

    设计模式——GFour

    创建型模式主要关注对象的创建过程,包括单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式。它们旨在提供一种方式来封装对象的创建,使得系统对对象的实例化过程更加灵活,同时降低类间的耦合度。 结构型...

    格斗类游戏软件——抽象工厂模式

    抽象工厂模式是一种设计模式,属于创建型模式,它提供了一种创建对象集合的方式,这些对象来自相关联的产品家族,而且每个对象都属于不同的抽象产品类。在“格斗类游戏软件”的场景中,这个模式可以帮助我们根据玩家...

    设计模式——刘伟

    分为简单工厂、工厂方法和抽象工厂三种类型。 3. **观察者模式**:定义对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。在事件驱动编程中广泛使用,例如GUI组件...

    Java设计模式——工厂设计模式详解

    Java设计模式——工厂设计模式详解 在软件设计中,工厂设计模式是一种常用的设计模式,主要用于实例化有共同接口的类。Java设计模式——工厂设计模式是Java中的一种常用的设计模式,主要用于实例化有共同接口的类。...

    设计模式——基于C#的工程化实现及扩展

    创建型模式主要包括但不限于工厂方法模式、抽象工厂模式、单例模式等。通过这些模式的应用,可以实现更加灵活的实例化逻辑,从而减少代码间的耦合度。 #### 第三部分:结构型模式 结构型模式主要关注于如何通过...

    实验二 简单工厂模式.zip_31QS_C#_设计模式——简单工厂模式_设计模式实验

    简单工厂模式是软件设计模式中的一种基础模式,它属于创建型模式,主要解决对象的创建问题,降低了客户端代码与具体产品类之间的耦合度。在本实验中,我们将深入理解和应用C#语言实现简单工厂模式。 简单工厂模式的...

    设计模式——原版的设计模式

    抽象工厂模式提供了一组接口,用于创建相关或依赖对象的家族,而无需指定具体类;建造者模式将复杂对象的构建与其表示分离,使得同样的构建过程可以创建不同的表示;原型模式通过复制已有对象来创建新对象。 2. **...

    创建型——工厂模式(抽象工厂)

    抽象工厂模式提供了一个接口,用于创建相关或依赖对象的家族,而不必指定它们的具体类。 在抽象工厂模式中,有以下几个关键角色: 1. **抽象工厂(Abstract Factory)**:这是工厂模式的核心接口,定义了创建产品...

Global site tag (gtag.js) - Google Analytics