首页 / 设计模式 / 设计模式——（一）工厂模式

设计模式——（一）工厂模式

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了设计模式——（一）工厂模式，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8251字，纯文字阅读大概需要12分钟。

内容图文

一.  什么是工厂模式？

工厂模式是 常用的实例化对象的模式 ，它替代了new操作。核心思想就是：如何实例化一个合适的对象。

 工厂模式分为三类：简单工厂、工厂模式、抽象工厂模式。

二.  三种工厂模式

2.1 简单工厂模式

2.1.1 定义

简单工厂模式（Simple Factory Pattern），又叫做静态工厂方法模式（Static FactoryMethod Pattern），是通过专门定义一个工厂类来创建其他类的实例，通常被创建的实例都具有共同的父亲。实现了算法和界面的分离，也就是将业务逻辑和界面逻辑分来了，降低了耦合度。但是违背了“开放—关闭”原则。

如何实现的？

 

通过一个工厂类，根据已有信息，使得实例对象的创建在子类进行。

 

好处：

 

  • 一个调用者想创建一个对象，只要知道其名称就可以了。
  • 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以
  • 屏蔽产品的具体实现，调用者只关心产品的接口。

 

主要解决的问题：主要解决接口选择的问题，根据信息创建不同的对象。

 

 

在实际的的使用中，抽闲产品和具体产品之间往往是多层次的产品结构，如下图所示

技术分享

2.1.2 简单工厂模式中包含了三种角色：

1. 工厂角色（Creator）：核心，由它负责创建所有类的内部逻辑，根据不同的信息调用子类创建所需要的对象，并且能够被外界调用

2. 抽象产品（Product）：简单工厂对象所创建的所有对象的父亲（可以使抽象类，也可以是接口），它是所有子类的公共接口。

3. 具体产品（Concrete Product）：简单工厂所创建的具体实例对象。

技术分享

 

 

2.1.3 应用场景：

  • 日志记录器：记录可能记录到本地磁盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方
  • 数据库访问：当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化的时候：

　　Java程序通过JDBC（数据库编程接口API）可以执行SQL语句，对获取的数据进行处理吗，并将变化的数据存到数据库中，JDBC是Java应用程序与各种关系数据库进行对话的一种机制：

技术分享

 

 

  • 设计一个连接服务器的框架，需要三个协议：“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口

2.1.4 具体实现

1. 创建一个接口——抽象产品（product）：

Shape.java

            1
            public
            interface
             Shape(){

            2
            void
             draw();

            3 }

2. 创建实现接口的实体类——Concrete Product具体产品

Rectangle.java

            1
            public
            class Rectangle implements Shape{
2    @Override
3publicvoid draw(){
4         System.out.println("Inside Rectangle::draw() method");
5    }
6 }

Circle.java

            public
            class Circle implements Shape{
    @Override
    publicvoid draw(){
        System.out.println("Inside Circle::draw() method");
    }
}

Square.java

            public
            class Square implements Shape{
    @Override
    publicvoid draw(){
        System.out.println("Inside Square::draw() method");
    }
}

3. 不同之处开始了！

如果没有使用工厂模式，我们在对特定的类产生实例时我们需要：

            1 Circle circle = new Circle();
2 Square square = new Square();
3 Rectangle rectangle = new Rectangle();

也就是说，我们如果要生成Shape的儿子，则要一个个去找那个特定的儿子然后实例化，但是如果我们用了工厂模式，我们可以明确地根据不同条件信息来创建不同的实例。也就是说，

  • 当一个调用者要创建一个对象时，只要知道了他的信息（比如名字）就可以了。
  • 屏蔽了这个对象具体创建的过程，只关心接口
  • 如果要增加一个类，扩展工厂就可以了。——同样导致了：每增加一个产品，就需要同时增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

具体实现如下：

创建一个工厂，生成基于信息的实体类对象 —— 工厂角色（Creator）

shapeFactory.java

             1
            public
            class
             ShapeFactory{

             2
             3
            //
            使用getShape()方法根据已有的信息，生成特定的对象
             4
            public
             Shape getShape(String shapeType){

             5
            if (shapeType == null)
 6returnnull;
 7if (shapeType.equalsIgnoreCase("CIRCLE")){
 8returnnew Circle();
 9        }
10elseif (shapeType.equalsIgnoreCase("RECTANFGLE")) {
11returnnew Rectangle();
12        }
13elseif (shapeType.equalsIgnoreCase("SQUARE")){
14returnnew Square();
15        }
16    }
17 }

4. 使用该工厂，通过传递类型信息来获取实体类的对象

FactoryPatternDemo.java

             1
            public
            class
             FactoryPatternDemo{

             2
            public
            static
            void
             main(String[] args){

             3         ShapeFactory shapeFactory = new ShapeFactory();
 4 5// 获取Circle类的对象，并调用它的draw()方法 6         shape shape1 = shapeFactory.getShape("CIRCLE");
 7        shape1.draw();
 8 9//获取Rectangle的对象，并调用它的draw()方法10         Shape shape2 = shapeFactory.getShape("Rectangle");
11        shape2.draw();
1213//获取Square对象，并调用它的draw()方法14         Shape shape3 = shapeFactory.getShape("Square");
15        shape3.draw();
16     }

5. 验证输出：

最后建立测试客户端，结果如下：

            Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

 

2.1.5 优缺点

优点：工厂类包含必要的判断逻辑，更够根据外界给定的信息，决定创建哪一个实例对象，而无需了解对象具体的创建、组织过程，有利于整个软件体系结构的优化。

缺点：

1. 由于工厂类集中所有实例的创建逻辑，导致一旦这个工厂类出现问题，所有客户端都会收到牵连

2. 因为所有的产品都基于一个公共的抽象类或者接口，一旦产品的种类增加，工厂类不仅需要判断这个产品所属的具体产品，还需要判断他属于哪个抽象产品，违背了单一职责，导致系统丧失灵活性和可维护性。

3. 当增加一个产品的时候，不仅需要添加具体产品类，还需要修改工厂类，违反了开闭原则。

开闭原则：

（1）模块的行为可以扩展。这意味着模块的行为是可以扩展的。（2）对于修改是关闭的（Closed for modification）。对模块行为进行扩展时，不必改动模块的源代码或者二进制代码。

也就是说：作为系统设计的抽象层，要预见所有可能的扩展，从而使得在任何扩展情况下，系统的抽象底层不需修改；同时，由于可以从抽象底层导出一个或多个新的具体实现，可以改变系统的行为，因此系统设计对扩展是开放的。

在简单工厂模式中：如果增加了一个新的产品类别，我们需要修改产品类，还需要修改工厂类。

 

2.2 工厂方法模式

2.2.1 定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。  遵循了开放—封闭原则。具体而言，核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂的角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

技术分享

2.2.2 四个角色：

1. 抽象工厂：核心，与应用程序无关，任何在模式中创建的对象的工厂类都必须要实现这个接口

2. 具体工厂：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。

3. 抽象对象：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

4. 具体对象：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

2.2.3 应用场景：

1. 是对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况。
2. 只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程这对于使用者来说是透明的。
 
2.2.4 工厂模式 VS 简单工厂模式

共同优点：都集中封装了对象的创建，使得要更换对象时，不需要做很大的改动就可以实现，降低了客户端程序与产品对象的耦合

 
  角色 实现原理 优点 缺点
简单工厂模式

3个角色：

抽象类，具体类，工厂类

过一个工厂类，根据已有信息，

使得实例对象的创建在子类进行。

工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，

对于客户端来说，去除了与具体产品的依赖。

没有遵守开放—封闭原则。

如果增加了一个新的产品类别，我们需要修改产品类，还需要修改工厂类。
工厂模式

4个角色：

抽象类、具体类、抽象工厂、具体工厂类

其中具体工厂类与具体类一一对应

定义一个抽象工厂接口，

让其子类决定实例化哪一个类

在简单工厂模式上进一步抽象，

遵循了“开放-关闭”原则

把简单工厂的内部逻辑判断转移到了客户端代码来执行；

每增加一产品就要增加一个产品工厂的类，增加了额外的开发量。

 

2.3 抽象工厂模式

2.3.1 原理：

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

主要解决的问题：接口选择问题。当系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

使用场景：

  • QQ换皮肤，一整套一起换
  • 生成不同操作系统的程序

2.3.2 优缺点：

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

2.3.3 实现：

我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。

AbstractFactoryPatternDemo，我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。

技术分享

1. 为形状创建一个接口

Shape.java

                                    public
                                    interface
                                     Shape{
    
                                    void
                                     draw();          
}

2. 创建实现形状接口的实体类：Rectangle、Circle、Square

Rectangle.java

                                    public
                                    class Rectangle implements Shape{
    @override
    publicvoid draw(){
        System.out.println("Inside Rectangle :: draw() method.")    
    }    
}

Circle.java

                                    public
                                    class Circle implements Shape{
    @override
    publicvoid draw(){
        System.out.println("Inside Circle :: draw() method.")    
    }    
}

Square.java

                                    public
                                    class Square implements Shape{
    @override
    publicvoid draw(){
        System.out.println("Inside Square :: draw() method.")    
    }    
}

3. 为颜色创建一个接口

Color.java

                                    public
                                    interface
                                     Color{
    
                                    void
                                     fill();
}

4. 创建实现颜色接口的实体类：Red、Green、Blue

Red.java

                                    public
                                    class Red implements Color{
    @override
    public voif fill(){
        System.out.println("Inside Red :: fill() method.")
    }    
}

Green.java

                                    public
                                    class Green implements Color{
    @override
    public voif fill(){
        System.out.println("Inside Green :: fill() method.")
    }    
}

Blue.java

                                    public
                                    class Blue implements Color{
    @override
    public voif fill(){
        System.out.println("Inside Blue :: fill() method.")
    }    
}

 

5. 为Color、Shape对象创建抽象类来获取工厂

AbstractFactory

                                    public
                                    abstract
                                     AbstractFactory{
    
                                    abstract
                                     Color getColor(String Color);
    
                                    abstract
                                     Shape getShape(String Shape);
}

6. 创建扩展AbstractFactory的工厂类，基于给定信息生成实体类的对象：ShapeFactory、ColorFactory

ShapeFactory.java

                                    public
                                    class ShapeFactory extends AbstractFactory{
    @override
    public getShape(String shapeType){
        if(shapeType == null){
            returnnull;        
        }  
         if(shapeType.equalsIgnoreCase("CIRCLE")){
             returnnew Circle();
          } elseif(shapeType.equalsIgnoreCase("RECTANGLE")){
                 returnnew Rectangle();
          } elseif(shapeType.equalsIgnoreCase("SQUARE")){
                 returnnew Square();
          }
          returnnull;
       }
   
   @Override
   Color getColor(String color) {
        returnnull;
   }
}

 

ColorFactory.java

                                    public
                                    class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      returnnull;
   }
   
   @Override
   Color getColor(String color) {
      if(color == null){
         returnnull;
      }        
      if(color.equalsIgnoreCase("RED")){
         returnnew Red();
      } elseif(color.equalsIgnoreCase("GREEN")){
         returnnew Green();
      } elseif(color.equalsIgnoreCase("BLUE")){
         returnnew Blue();
      }
      returnnull;
   }
}

7. 创建一个工厂生成器类，通过传递形状或颜色信息来获取工厂。

FactoryProducer.java

                                    public
                                    class
                                     FactoryProducer{
    
                                    public
                                    static
                                     AbstractFactory getFactory(String choice){
        
                                    if (choice.equalsIgnoreCase("Shape"))
            returnnew ShapeFactory();
        elseif (choice.equalsIgnoreCase("Colore"))
            returnnew ColorFactory;
        returnnull;
    }

8. 创建一个客户端测试类，使用FactoryProducer来创建工厂，通过传递类信息来获取实体类的对象

                                    public
                                    class
                                     AbstractFactoryDemo{
    
                                    public
                                    static
                                    void
                                     main(String[] args){
        
                                    //
                                    使用FactoryProducer创建ShapeFactory
        AbstractFactory shapeFactory = FactoryProducer.getFactory("Shape");
        //使用ShapeFactory来获取形状为Circle对象
        Shape shapeCircle = shapeFactory.getShape("Circle");
        //调用Circle对象的draw()方法        shapeCircle.draw();
        
        //使用FactoryProducer创建ColorFactory
        AbstractFactory ColorFactory = FactoryProducer.getFactory("Color");
        //使用ColorFactory创建Red实例对象
        Color colorRed = ColorFactory.getColor("red");
        //调用Red实例对象的fill()方法        colorRed.fill();
                
    }
}

最后的运行结果：

                                    Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.

 

原文：http://www.cnblogs.com/lesleysbw/p/6262774.html

内容总结

以上是互联网集市为您收集整理的设计模式——（一）工厂模式全部内容，希望文章能够帮你解决设计模式——（一）工厂模式所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1277078.html

来源：【匿名】