浅学设计模式之简单工厂模式、工厂模式、抽象工厂模式

最新推荐文章于 2024-07-19 09:49:20 发布

HarbinZJU

最新推荐文章于 2024-07-19 09:49:20 发布

阅读量3.6k

点赞数

分类专栏： C++基础

C++基础专栏收录该内容

52 篇文章

订阅专栏

本文详细介绍了飞机制造设计模式中的简单工厂、工厂模式和抽象工厂模式，包括模式定义、角色、实现案例、优缺点及适用场景，并通过代码示例展示了具体应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、简单工厂

从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

其包括三个角色：

　工厂（Creator）角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
　抽象产品（Product）角色：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
　具体产品（Concrete Product）角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

其UML图如下所示：

看一下写的小例子：假如一家航空公司需要购买飞机：

先定义飞机接口：

[java]view plaincopy 
   
 public interface IPlane {  
     void name();  
 }  

在得到Product：

波音：

[java]view plaincopy 
   
 public class Boeing777 implements IPlane{  
     private String name = "Boeing777";  
     @Override  
     public void name() {  
         // TODO Auto-generated method stub  
         System.out.println("My name is:" + name);  
     }  
   
 }  

空客：

[java]view plaincopy 
   
 public class Boeing737 implements IPlane {  
     private String name = "Boeing737";  
     @Override  
     public void name() {  
         // TODO Auto-generated method stub  
         System.out.println("My name is :" + name);  
     }  
   
 }  

再看飞机工厂：

Create：

[java]view plaincopy 
   
 public class PlaneFactory {  
     public static IPlant getPlane(String name) throws Exception {  
         if (name.equalsIgnoreCase("boeing777")){  
             return new Boeing777();  
         } else if (name.equalsIgnoreCase("boeing737")){  
             return new Boeing737();  
         }else  
         {  
             throw new Exception("The type $type don't exists" );  
         }         
     }  
 }  

当我们在客户端想要得到飞机的时候：

[java]view plaincopy 
   
 public class PlaneTest {  
   
     /** 
      * @param args 
      * @throws Exception  
      */  
     public static void main(String[] args) throws Exception {  
         // TODO Auto-generated method stub  
         //获取波音飞机  
         IPlane boeing777 = PlaneFactory.getPlane("boeing777");  
         //获得名字  
         boeing777.name();  
         //获取空客飞机  
         IPlane boeing737= PlaneFactory.getPlane("airbus");  
         //获得名字  
         boeing737.name();  
     }  
   
 }  

运行结果：

My name is:Boeing777
My name is :Boeing737

优点：

　　工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点：

　　由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

　　当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

　　这些缺点在工厂方法模式中得到了一定的克服。

使用场景

　　工厂类负责创建的对象比较少；

　　客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；

　　由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。

说明：

以上文字概念部分，均来自百度百科。自己没有那么好的归纳能力。

二、工厂模式

5月23号修改工厂模式代码，把工厂类修改成抽象类：

[java]view plaincopy 
   
 public abstract class PlaneFactory {  
     public void letPlaneFly(String name){  
         IPlane iPlane = getPlane(name);  
         iPlane.fly();  
     }  
     abstract IPlane getPlane(String name) ;  
 }  

不但能获取飞机，而且能让它飞！

具体工厂类，有boeing工厂和airbus工厂。

[java]view plaincopy 
   
 public class AirbusFactory extends PlaneFactory {  
   
     @Override  
     IPlane getPlane(String name) {  
         // TODO Auto-generated method stub  
         if (name.equalsIgnoreCase("airbus320")){  
             return new Airbus320();  
         } else if (name.equalsIgnoreCase("airbus380")){  
             return new Airbus380();  
         }else {  
             return null;  
         }  
     }  
   
 }  

[java]view plaincopy 
   
 public class BoeingPlaneFactory extends PlaneFactory{  
   
     @Override  
     IPlane getPlane(String name) {  
         // TODO Auto-generated method stub  
         if (name.equalsIgnoreCase("boeing777")){  
             return new Boeing777();  
         } else if (name.equalsIgnoreCase("boeing737")){  
             return new Boeing737();  
         }else {  
             return null;  
         }         
     }  
   
       
 }  

产品抽象类：plane

[java]view plaincopy 
   
 public abstract class IPlane {  
     abstract void name();  
     public void fly() {  
         name();  
         System.out.println("i fly in the sky");  
     }  
 }  

分别继承，获得的四个飞机类：

[java]view plaincopy 
   
 public class Boeing777 extends IPlane {  
   
     @Override  
     public void name() {  
         // TODO Auto-generated method stub  
         System.out.println("i am boeing 777");  
     }  
   
 }  

[java]view plaincopy 
   
 public class Boeing737 extends IPlane {  
   
     @Override  
     public void name() {  
         // TODO Auto-generated method stub  
         System.out.println("i am boeing 737");  
     }  
   
 }  

[java]view plaincopy 
   
 public class Airbus320 extends IPlane {  
   
     @Override  
     public void name() {  
         // TODO Auto-generated method stub  
         System.out.println("i am airbus320");  
     }  
   
 }  

[java]view plaincopy 
   
 public class Airbus380 extends IPlane {  
   
     @Override  
     public void name() {  
         // TODO Auto-generated method stub  
         System.out.println("i am Airbus380");  
     }  
   
 }  

测试类：

[java]view plaincopy 
   
 public static void main(String[] args) throws Exception {  
         PlaneFactory airBus = new AirbusFactory();  
         //看空客飞机飞  
         airBus.letPlaneFly("airbus320");  
         airBus.letPlaneFly("airbus380");  
         PlaneFactory boeing = new BoeingPlaneFactory();  
         boeing.letPlaneFly("boeing777");  
         boeing.letPlaneFly("boeing737");  
           
     }  

测试结果：

i am airbus320
i fly in the sky
i am Airbus380
i fly in the sky
i am boeing 777
i fly in the sky
i am boeing 737
i fly in the sky

三、抽象工厂模式

当我们发现，我们不仅需要民航飞机，我们还需要战斗机，该如何办呢？大家都知道，波音不仅生产民用飞机，还有著名的B-52，而空客也有它的军用运输机A400M。

我们生产飞机时，就需要两个接口了，军用飞机一个接口，民用飞机一个接口。看下图：

军用飞机是一个产品等级，民用飞机又是一个产品等级，而波音和空客生产两个不同的产品族。

先看看民用飞机接口：

[java]view plaincopy 
   
 public interface ICivilaircraft {  
     String getName();  
     //运输旅客  
     void passengers();  
 }  

民用飞机：

[java]view plaincopy 
   
 public class Boeing777 implements ICivilaircraft{  
     private String name ="Boeing 777";  
     private String personNumber ="350";  
   
     @Override  
     public String getName() {  
         return name;  
         // TODO Auto-generated method stub  
           
     }  
   
     @Override  
     public void passengers() {  
         // TODO Auto-generated method stub  
         System.out.println(getName()+"can passengers "+personNumber+" person");  
     }  
 }  

空客的空客340

[java]view plaincopy 
   
 public class Airbus340 implements ICivilaircraft{  
     private String name ="Airbus340";  
     private String personNumber ="380";  
   
     @Override  
     public String getName() {  
         return name;  
         // TODO Auto-generated method stub  
           
     }  
   
     @Override  
     public void passengers() {  
         // TODO Auto-generated method stub  
         System.out.println(getName()+"can passengers "+personNumber+" person");  
     }  
 }  

军用飞机接口：

[java]view plaincopy 
   
 public interface IWarplane  {  
     String getName();  
     //运输武器  
     void Transportarms();  
 }  

军用飞机：

[java]view plaincopy 
   
 public class A400M implements IWarplane {  
     private String name ="A400M";  
     private String armweight="30吨";  
     @Override  
     public String getName() {  
         // TODO Auto-generated method stub  
         return name;  
     }  
   
     @Override  
     public void Transportarms() {  
         // TODO Auto-generated method stub  
         System.out.println(getName()+"can transport "+ armweight+" arms");  
     }  
   
 }  

B52：

[java]view plaincopy 
   
 public class B52 implements IWarplane {  
     private String name ="B52";  
     private String armweight="27吨";  
     @Override  
     public String getName() {  
         // TODO Auto-generated method stub  
         return name;  
     }  
   
     @Override  
     public void Transportarms() {  
         // TODO Auto-generated method stub  
         System.out.println(getName()+"can transport "+ armweight+" arms");  
     }  
   
 }  

在看看飞机工厂，波音公司和空客公司，先看他们的父类：

[java]view plaincopy 
   
 public abstract class AbstractFactory {  
     abstract ICivilaircraft getCivilair();  
     abstract IWarplane getWarplane();  
 }  

波音：

[java]view plaincopy 
   
 public class BoeingFactory extends AbstractFactory{  
   
     @Override  
     ICivilaircraft getCivilair() {  
         // TODO Auto-generated method stub  
         return new Boeing777();  
     }  
   
     @Override  
     IWarplane getWarplane() {  
         // TODO Auto-generated method stub  
         return new B52();  
     }  
       
   
 }  

空客：

[java]view plaincopy 
   
 public class AirBus extends AbstractFactory {  
   
     @Override  
     ICivilaircraft getCivilair() {  
         // TODO Auto-generated method stub  
         return new Airbus340();  
     }  
   
     @Override  
     IWarplane getWarplane() {  
         // TODO Auto-generated method stub  
         return new A400M();  
     }  
   
 }  

测试类：

[java]view plaincopy 
   
 public static void main(String[] args) {  
         // TODO Auto-generated method stub  
         AbstractFactory boeing = new BoeingFactory();  
         AbstractFactory airbus = new AirBus();  
         //查看波音的民用飞机  
         boeing.getCivilair().passengers();  
         //查看波音的军用飞机  
         boeing.getWarplane().Transportarms();  
         //查看空客的民用飞机  
         airbus.getCivilair().passengers();  
         //查看空客的军用飞机  
         airbus.getWarplane().Transportarms();  
     }  

测试结果：

Boeing 777 can passengers 350 person
B52 can transport 27吨 arms
Airbus340 can passengers 380 person
A400M can transport 30吨 arms

区别和联系：

抽象工厂和工厂模式有什么区别呢？他们俩又在具体什么情况下使用呢？请看下面从网上找到的不错的回答：

其实这两者的区别，GOF的书上说得很清楚。工厂方法采用的是类继承机制（生成一个子类，重写该工厂方法，在该方法中生产一个对象）。而抽象工厂采用的是对象组合机制，专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。

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

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。   
    
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。工厂方法：说白了就是一个方法，这个方法是创建具体的产品的，它要求所有的工厂都具有同一个签名的方法，必要时重写该方法；抽象工厂：不能直接创建产品，只能创建工厂，即抽象工厂创建的产品是工厂。虽然它也定义了创建产品的方法，但需要创建出来的具体的工厂实现，即：抽象工厂创建出的工厂创建产品。工厂方法采用的是类继承机制（生成一个子类，重写该工厂方法，在该方法中生产一个对象）；而抽象工厂采用的是对象组合机制，专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。

可以这么去理解，“抽象工厂模式”这个称呼中的“抽象”是一个动词，即对工厂方法模式进行了抽象，就变成了抽象工厂模式，这么理解后，就不难看出它们的区别：工厂方法模式：每个抽象产品派生多个具体产品类，每个抽象工厂类派生多个具体工厂类，每个具体工厂类负责一个具体产品的实例创建；抽象工厂模式：每个抽象产品派生多个具体产品类，每个抽象工厂派生多个具体工厂类，每个具体工厂负责多个（一系列）具体产品的实例创建。

原文地址：http://blog.youkuaiyun.com/lilu_leo/article/details/7592678