第11章 GoF设计模式(一)

目录

m11.1. 设计模式概述

Ø什么是设计模式

Ø设计模式的描述

Ø设计模式的编目

Ø设计模式怎样解决设计问题

Ø怎样使用模式

m11.2. 常用创建型模式

Ø单例模式

Ø工厂方法模式

Ø抽象工厂模式

Ø建造者模式

m11.3 创建型模式比较

11.1 设计模式概述

11.1.1 什么是设计模式

m设计模式（Design patterns）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结(成对的问题/解决方案)。

m使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性

设计模式四要素

11.1.2 设计模式的描述

Ø模式名和分类

Ø意图

Ø别名

Ø动机

Ø适用性

Ø结构

Ø参与者

Ø协作

Ø效果

Ø实现

Ø代码示例

Ø已知应用

Ø相关模式

11.1.3 设计模式的编目

11.1.4 设计模式怎样解决设计问题

Ø寻找合适的对象

Ø决定对象的粒度

Ø指定对象接口

Ø描述对象的实现

Ø运用复用机制

11.1.5 怎样使用设计模式

Ø大致浏览一遍模式

Ø回头研究结构部分、参与者部分和协作部分

Ø看代码示例部分

Ø选择模式参与者的名字，使其在应用上下文中有意义

Ø定义类

Ø定义模式中专用于应用的操作名称

Ø实现执行模式中责任和协作的操作

11.2 常用创建型模式

m创建型模式抽象了实例化过程。帮助一个系统独立于如何创建、组合和表示它的那些对象。一个类创建型模式使用继承改变被实例化的类，而一个对象创建型模式将实例化委托给另一个对象。

m这类模式的两个特点：

Ø将关于该系统使用哪些具体的类的信息封装起来

Ø隐藏了这些类的实例是如何被创建和放在一起的。

11.2.1 单例模式（Singleton）

m意图

    保证一个类仅有一个实例，并提供一个访问它的全局访问点

m动机

    某些场合只需要一个实例

m适用性

Ø当类只能有一个实例而且客户可以从一个众所周知的访问点访问它

Ø当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展实例时。

m结构

m参与者

ØSingleton

•定义一个Instance操作，允许客户访问它的唯一实例

•可能负责创建它自己的唯一实例。

m协作

Ø客户只能通过Singleton的Instance操作访问一个Singleton实例

m效果

Ø对唯一实例的受控访问

Ø缩小名字空间

Ø允许对操作和表示的精化

Ø允许可变数目的实例

Ø比类操作更灵活

m实现

public class Singleton{
    private static Singleton  singleton = null;
    private Singleton() {   }
    public static  Singleton  getSingleton(){
         if (singleton == null) {
             singleton = new Singleton();
          }
         return singleton;
     }
}

public class  Singleton {
    private static  final  Singleton  singleton
           = new Singleton();
    private Singleton()  {   }
    public  static Singleton getSingleton()
    {
          return  singleton;
    }
    public  static void doSomething(){   }
}

11.2.2 工厂方法（Factory Method）

m意图

    定义一个用于创建对象的接口，让子类决定实例化哪一个类。

m别名

    虚构造器（Virtual Constructor）

m动机

    框架使用抽象类定义和维护对象之间的关系

m适用性

Ø当一个类不知道它所必须创建的对象的类的时候

Ø当一个类希望由它的子类来指定它所创建的对象的时候

Ø当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化的时候

m结构

m参与者

m协作

Creator依赖于它的子类来定义工厂方法，所以它返回一个ConcreteProduct实例

m效果

Ø为子类提供挂钩（Hook）

Ø连接平行的类层次

m示例：女娲造人

11.2.3 抽象工厂模式（Abstract  Factory）

m意图

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

m别名

Kit

m动机

支持多种感观（Lookand Feel）标准的用户界面工具包

m适用性

Ø一个系统要独立于它的产品的创建、组合和表示时。

Ø一个系统要由多个产品系列中的一个配置时。

Ø当要强调一系列相关的产品对象的设计以便进行联合使用时。

Ø提供一个产品库，而只想显示他们的接口而不是实现时。

m结构

m参与者

ØAbstractFactory

ØConcreteFactory

ØAbstractProduct

ØConcreteProduct

ØClient

m协作

Ø运行时创建ConcreteFactory实例

Ø产品对象的创建延迟到ConcreteFactory子类

m效果

Ø分离了具体的类

Ø使得易于交换产品系列

Ø有利于产品的一致性

Ø难以支持新种类的产品

11.2.4 建造者模式（Builder）

m意图

    将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

m动机

     如：一个RTF文档格式的阅读器能将RTF转换为多种正文格式。

     又如：生产不同品牌汽车模型。

m结构

m参与者

ØBuilder：为创建一个Product对象的各个部件指定抽象接口

ØConcreteBuiler：

•实现Builder接口以构造和装配该产品的各个部件；

•定义并明确它所创建的表示；

•提供一个检索产品的接口

ØDirector：使用Builder接口的对象

ØProduct：

•表示被构造的复杂对象

•包含定义组成部件的类

m协作

m效果

Ø可以改变一个产品的内部表示

Ø将构造代码和表示代码分开

Ø可对构造过程进行更精细的控制

m应用示例

Ø某公司受委托加工一批宝马和奔驰的汽车模型玩具，委托方提出不同车模有不同的特性需求。

public  abstract class CarModel{
    private ArrayList<String> seq=
                new ArrayList<String>();
    protected abstract void start();
    ……
    public final void run(){
         for (int i=0;i<seq.size();i++{
             String actionName=seq.get(i);
              if(actionName.equalsIgnoreCase(“start”){
                   this.start();
             }

publicabstract class CarBuilder{

     public abstract void setSequnece

           (ArrayList<String>seq);

     public abstract  CarModelgetCarModel();

}

publicclass BenzBuilder extends CarBuilder{

     private BenzModelbenz=new BenzModel();

     public CarModelgetCarModel(){return benz;}

     public void setSequence(ArrayList<String> seq)

     { benz.setSequence(seq);}

}
 

publicclass Client{

  public static void main(String[ ] args){

     ArrayList<String>seq=new ArrayList<String>();

     seq.add(“engineboom”);

     seq.add(“start”);

     seq.add(“stop”);

     BenzBuilder  benb=new BenzBuilder;

     benb.setSequence(seq);

     BenzModel

 benz=(BenzModel)benb.getCarModel();

      benz.run();

11.3 创建型模式比较

m工厂方法vs建造者模式

Ø意图不同

•工厂方法关注的是一个产品的整体，无须关心产品的各部分是如何创建出来的

•建造者模式中，具体产品的产生是依赖各个部件的产生以及装配顺序，关注的是由零件一步一步组装出产品的对象

Ø产品复杂度不同

•工厂方法模式创建的产品一般都是单一性质产品

•建造者模式创建的是一个复合产品

public class SuperManFactory{
    public static ISuperMan createSuperMan(String 
         type){
         if(type.equalsIgnoreCase(“adult”) {
             return new AdultSuperMan();
         }
         ……
}
public class Client{
    public static void main(String [ ] args){
         ISuperMan  adultSuperMan=
           SuperManFactory.createSuperMan(“adult”);
         adultSuperMan.specialTelent();
}

public class Director{
    private static Builder ad=
         new AdultSuperManBuilder();
    private static Builder cd=
         new ChildSuperManBuilder();
    public static SuperMan getAdultSuperMan(){
          return ad.getSuperMan();
    }
    ……
}

public class Client{
    public static  void  main(String[] args){
        SuperMan  ad =Director.getAdultSuperMan();
        ad.getSpecialTalent();
    }
}

m抽象工厂模式 vs建造者模式

Ø抽象工厂模式实现对产品家族的创建，不需要关心构建过程，只关心产品由什么工厂生产。

Ø建造者模式则是按要求指定的蓝图建造产品，主要目的是通过组装零配件而产生一个新产品。

public class BenzFactory implements CarFactory{
    public ICar  crateSuv(){
        return  new BenzSuv();
    }
    public ICar  caretVan(){
       return new BenzVan();
    }
}

public class Client{
    public static void main(String[] args){
        System.out.println(“make benz suv”);
        System.out.println(“find benz factory”);
        CarFactory  carFac=new BenzFactory();
        System.out.println(“start”);
        ICar  benzSuv= carFac.createSuv();
        System.out.println(“finish.”);
        System.out.println(benzSuv.getBand());
        System.out.println(benzSuv.getModel());
     }
}

public class Director{
    private CarBuilder  benz=new BenzBuilder();
    private CarBuilder bmw=new BMWBuilder();

     public ICar createBenzSuv(){
         return createCar(benz,”benz engin”,”benz wheel”);
      }
      ……

    private ICar  createCar(CarBuilder  cb,String  engine,String  wheel){
        Blueprint  bp=new Blueprint();
        bp.setEngin(engine);
        bp.setWheel(wheel);
        cb.receiveBlueprint(bp);
        return cb.buildCar();
     }
}

public  class Client{
    public static void main(String[] args){
        Director  dir=new Director();
        ICar  benzSuv=dir.createBenzSuv();
        ICar   bmwVan=dir.createBMWVan();
    }
}