文章首页 Web开发 Windows开发 编程语言 数据库技术 移动平台 系统服务 微信 设计 布布扣 其他

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

时间：2017-01-08 22:28:34   收藏：0   阅读：235

一.  什么是工厂模式？

工厂模式是常用的实例化对象的模式，它替代了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应用程序与各种关系数据库进行对话的一种机制：

技术分享

 

 

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
3     public void draw(){
4         System.out.println("Inside Rectangle::draw() method");
5     }
6 }

Circle.java

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

Square.java

public class Square implements Shape{
    @Override
    public void 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)
 6             return null;
 7         if (shapeType.equalsIgnoreCase("CIRCLE")){
 8             return new Circle();
 9         }
10         else if (shapeType.equalsIgnoreCase("RECTANFGLE")) {
11             return new Rectangle();
12         }
13         else if (shapeType.equalsIgnoreCase("SQUARE")){
14             return new 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();
12         
13         //获取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
    public void draw(){
        System.out.println("Inside Rectangle :: draw() method.")    
    }    
}

Circle.java

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

Square.java

public class Square implements Shape{
    @override
    public void 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){
            return null;        
        }  
         if(shapeType.equalsIgnoreCase("CIRCLE")){
             return new Circle();
          } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
                 return new Rectangle();
          } else if(shapeType.equalsIgnoreCase("SQUARE")){
                 return new Square();
          }
          return null;
       }
   
   @Override
   Color getColor(String color) {
        return null;
   }
}

 

ColorFactory.java

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

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

FactoryProducer.java

public class FactoryProducer{
    public static AbstractFactory getFactory(String choice){
        if (choice.equalsIgnoreCase("Shape"))
            return new ShapeFactory();
        else if (choice.equalsIgnoreCase("Colore"))
            return new ColorFactory;
        return null;
    }

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

评论（0）
© 2014 bubuko.com 版权所有 - 联系我们:wmxa8@hotmail.com
打开技术之扣，分享程序人生！