浅谈Java设计模式

 

浅谈设计模式（Design Pattern）

                              

 

 

序言：

与很多软件工程技术一样，模式起源于建筑领域，软件工程只有短短的几十年，与已经拥有几千年底蕴的建筑工程相比，后者有太多值得学习和借鉴的地方。1995年GOF（Gang Of Four四人组，Erich Gamma、Richard Helm,Ralph Johnson和John Vlissides）收集整理了23种设计模式出版了《设计模式：可复用面向对象软件的基础》一书。（GOF缺少了一个较为常用的设计模式，简单工厂方法模式，也叫静态工厂方法 Static Factory Method。对这种模式，笔者是这样理解的，简单工厂方法也是一种经常被广泛使用的设计模式，GOF提出的经典的23种设计模式中没有提及到这种设计模式。）

 

　“虽然设计模式描述的是面向对象编程语言，而不是过程是语言（Pascal、C、Ada）或更具动态特性的面向对象语言（CLOS、Dylan、Self）。我们从实用角度出发选择了Smalltalk和C++，因为在这些语言的使用上，我们积累了许多　况且它们也变得越来越流行”。　　　　　　　　　　　　　　　　——引言：《设计模式：可复用面向对象软件的基础》 

 

软件设计模式本来就是一种设计上的思想，在GOF编撰的最经典的《设计模式》一书中，主要是用C++语言来描述的，书中也结合Smalltalk示例代码对设计模式进行介绍和描述。因此多数OOL(Object-Oriented Language)都可以描述和实现设计模式，关键是思想。在本篇博客当中笔者只和大家在Java语言环境下介绍和讨论Java设计模式。在下文当中，设计模式和Java设计模式是同等概念的词语。

  

前言：

Java设计模式是什么？在软件开发的周期里，我们(软件开发者、编程人员)为什么要使用设计模式？

 

设计模式的英文叫 Desing Pattern，是一套被反复使用、多数人知晓的、经过分类编辑的代码设计经验的总结。 使用设计模式是为了可重用代码（可重用），让代码更容易让他人理解（易维护）并保证代码的可靠性（可靠性）。 毫无疑问，设计模式于己于他人于系统都是非常实用的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。 项目代码中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及给出了该问题的核心解决方案，这也是它能被广泛应用的原因。笔者会以理论与实践(使用代码和UML图case展示)相结合的方式来进行介绍人们广泛使用的设计模式，也希望广大编程爱好者、软件开发者，在开发编程活动中善于运用设计模式，做一个具有良好编程习惯的编程人员！

 

一、设计模式的分类

总体来说设计模式分为三大类，共23种设计模式：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

 

二、设计模式的六大原则

总原则：开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类等，后面的具体设计中我们会提到这点。

1、单一职责原则（Single Responsibility Principle）

不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。

 

2、里氏替换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

历史替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。

 

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

 

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

 

5、迪米特法则（最少知道原则）（Demeter Principle）

就是说：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。

最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

 

6、合成复用原则（Composite Reuse Principle）

原则是尽量首先使用合成/聚合的方式，而不是使用继承。

 

三、设计模式介绍

1. 创建型模式

在软件工程中，创建型模式是处理对象创建的设计模式，试图根据实际情况使用合适的方式创建对象。基本的对象创建方式可能会导致设计上的问题，或增加设计的复杂度。创建型模式通过以某种方式控制对象的创建来解决问题。创建型模式由两个主导思想构成。一是将系统使用的具体类封装起来，二是隐藏这些具体类的实例创建和结合的方式。创建型模式又分为对象创建型模式和类创建型模式。对象创建型模式处理对象的创建，类创建型模式处理类的创建。详细地说，对象创建型模式把对象创建的一部分推迟到另一个对象中，而类创建型模式将它对象的创建推迟到子类中。

1.1 抽象工厂模式(Abstract Factory)

所谓抽象工厂模式就是她提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。他允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。它的优点是隔离了具体类的生成，使得客户端不需要知道什么被创建了，而缺点就在于新增新的行为会比较麻烦，因为当添加一个新的产品对象时，需要更加需要更改接口及其下所有子类。其UML结构图如下：

参与者：

AbstractFactory：抽象工厂，声明一个创建抽象产品对象的操作接口。

ConcreteFactory：具体工厂，实现创建具体对象的操作，实现AbstractProduct接口。

AbstractProduct：抽象产品，为一类产品对象声明一个接口。

ConcreteProduct：具体产品，定义一个将被相应的具体工厂创建的产品对象，实现AbstractProduct接口。

Clinent：仅使用由AbstractFactory和AbstractProduct类声明的接口。

协作过程：

通常在运行时刻创建一个ConcreteFactory类的实例。这一具体的工厂创建具有特定实现的产品对象。为创建不同的对象，客户应使用不同的具体工厂。AbstractFactory将产品对象的创建延迟到它的ConcreteFactory子类。

效果（优点）：

它（指代抽象工厂模式）分离了具体的类，抽象工厂方法模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。

通俗地来讲，类的具体设计和实现细节用户不必知道也不可知道。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码当中。

它使得易于交换产品系列 ，一个具体工厂类在一个应用中仅出现一次——即它在初始化的时候。这使得改变一个应用的具体工厂变得很容易。

它只需要改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变。

它有利于产品的一致性，当一系列中的产品对象被设计成一起工作是，一个应用一次只能使用同一个系列中的对象，这一点很重要。而AbstractFactory很容易实现这一点。

缺点：

难以支持新种类的产品，难以扩展抽象工厂以生成新种类的产品。这是因为AbstractFactory接口确定了可以被创建的产品集合。

支持新种类的产品就需要扩展该抽象工厂的接口，这将涉及AbstractFactory类及其所有子类的改变。

UML类图：

 

 

示例代码：

抽象工厂对应的是产品族概念。例如，汽车产品类型可以分为轿车、SUV、MPV等，品牌也可以分为奔驰、宝马等。我们可以将奔驰的所有车型看作是一个产品族，而将宝马的所有车型看作是另一个产品族。分别对应两个工厂，一个是奔驰的工厂，另一个是宝马的工厂。与工厂方法不同，奔驰的工厂不只是生产具体的某一个产品，而是一族产品（奔驰轿车、奔驰SUV、奔驰MPV）。

听起来可能会略显复杂，我们结合上面的UML类图一起看，左上方AbstractFactory为一个工厂抽象基类，对应上例的汽车厂，当然这里的汽车厂是统称，现实中所有是不存在这样抽象的汽车厂。由AbstractFactory派生了两个工厂类Factory1和Factory2，对应上例中的奔驰、宝马汽车厂。右方的ProductA和ProductB是两个产品族，对应首轿车和SUV，当然这里也是抽象基类，是不存在的，ProductA派生了两个子类，对应了奔驰的轿车ProductA1和宝马的轿车ProductA2。所以奔驰汽车厂生产奔驰轿车、奔驰SUV，宝马汽车厂生产宝马轿车和宝马SUV。怎么生产？和工厂方法一样。

package com.cnblogs.lints.abstractFactoryPattern.factory;

import com.cnblogs.lints.abstractFactoryPattern.product.MPV;
import com.cnblogs.lints.abstractFactoryPattern.product.SUV;

public interface CarAbstractFactory {
    SUV createSUV();
    MPV createMPV();
}

package com.cnblogs.lints.abstractFactoryPattern.factory;

import com.cnblogs.lints.abstractFactoryPattern.product.BMWMPV;
import com.cnblogs.lints.abstractFactoryPattern.product.BMWSUV;
import com.cnblogs.lints.abstractFactoryPattern.product.MPV;
import com.cnblogs.lints.abstractFactoryPattern.product.SUV;

public class BMWFactory implements CarAbstractFactory {

    public static BMWFactory BMW_Factory = null;
    
    private BMWFactory() {
    }
    
    //延迟加载的单例设计模式，确保程序中只有一个奔驰工厂对象。
    //但下面的代码不是线程安全的,多线程下有安全隐患。
    public static BMWFactory getBMWFactory() {
        if(BMW_Factory == null)
            BMW_Factory = new BMWFactory();
        return BMW_Factory;
    }

    @Override
    public SUV createSUV() {
        return new BMWSUV();
    }

    @Override
    public MPV createMPV() {
        // TODO Auto-generated method stub
        return new BMWMPV();
    }

}

package com.cnblogs.lints.abstractFactoryPattern.factory;

import com.cnblogs.lints.abstractFactoryPattern.product.BenzMPV;
import com.cnblogs.lints.abstractFactoryPattern.product.BenzSUV;
import com.cnblogs.lints.abstractFactoryPattern.product.MPV;
import com.cnblogs.lints.abstractFactoryPattern.product.SUV;

public class BenzFactory implements CarAbstractFactory {

    public static BenzFactory benzFactory = null;
    
    private BenzFactory() {
    }
    
    //延迟加载的单例设计模式，确保程序中只有一个奔驰工厂对象。
    //但下面的代码不是线程安全的,多线程下有安全隐患。
    public static BenzFactory getBenzFactory() {
        if(benzFactory == null)
            benzFactory = new BenzFactory();
        return benzFactory;
    }

    @Override
    public SUV createSUV() {
        // TODO Auto-generated method stub
        return new BenzSUV();
    }

    @Override
    public MPV createMPV() {
        // TODO Auto-generated method stub
        return new BenzMPV();
    }
}

 

package com.cnblogs.lints.abstractFactoryPattern.product;

public interface SUV {

    void productModel();
}

package com.cnblogs.lints.abstractFactoryPattern.product;

public interface MPV {
    void productModel();
}

package com.cnblogs.lints.abstractFactoryPattern.product;

public class BenzMPV implements MPV {

    @Override
    public void productModel() {
        System.out.println("get Benz's MPV");
    }

}

package com.cnblogs.lints.abstractFactoryPattern.product;

public class BenzSUV implements SUV {

    @Override
    public void productModel() {
        System.out.println("get Benz's SUV");
    }

}

package com.cnblogs.lints.abstractFactoryPattern.product;

public class BMWMPV implements MPV{

    @Override
    public void productModel() {
        System.out.println("get BMW's MPV");
    }
    
}

package com.cnblogs.lints.abstractFactoryPattern.product;

public class BMWSUV implements SUV {

    @Override
    public void productModel() {
        System.out.println("get BMW's SUV");
    }

}

 

package com.cnblogs.lints.abstractFactoryPattern.client;

import com.cnblogs.lints.abstractFactoryPattern.factory.BMWFactory;
import com.cnblogs.lints.abstractFactoryPattern.factory.BenzFactory;
import com.cnblogs.lints.abstractFactoryPattern.factory.CarAbstractFactory;
import com.cnblogs.lints.abstractFactoryPattern.product.MPV;
import com.cnblogs.lints.abstractFactoryPattern.product.SUV;

public class Client {

    public static void main(String[] args) {
        
        //获得奔驰工厂对象，通过工厂对象创建奔驰汽车产品，相当于现实中人去奔驰工厂提车
        CarAbstractFactory benzFactory = BenzFactory.getBenzFactory();
        SUV benzSUV = benzFactory.createSUV();
        MPV benzMPV = benzFactory.createMPV();
        
        //展示产品
        benzSUV.productModel();
        benzMPV.productModel();

        //获得宝马工厂对象，通过工厂对象创建宝马汽车产品，相当于现实中人去宝马工厂提车
        CarAbstractFactory BMW_Factory = BMWFactory.getBMWFactory();
        SUV BMW_SUV = BMW_Factory.createSUV();
        MPV BMW_MPV = BMW_Factory.createMPV();
        
        //展示产品
        BMW_SUV.productModel();
        BMW_MPV.productModel();
    }

}

 

1.2 工厂方法模式(Factory Method Pattern)

 

 

笔者的时间和水平有限，博客内容待补充，望读者见谅......