Table of Contents:

软件设计模式概述

《设计模式:可复用面向对象软件的基础》(Design Patterns: Elements of Reusable Object-Oriented Software)一书,在本教程中收录了 23 个设计模式,这是设计模式领域里程碑的事件,导致了软件设计模式的突破。这 4 位作者在软件开发领域里也以他们的“四人组”(Gang of Four,GoF)匿名著称。
设计模式的本质是面向对象设计原则的实际运用,是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。

软件设计模式的基本要素

  1. 模式名称

  2. 问题
    描述了该模式的应用环境,即何时使用该模式

  3. 解决方案

  4. 效果
    描述了模式的应用效果以及使用该模式应该权衡的问题,即模式的优缺点。主要是对时间和空间的衡量,以及该模式对系统的灵活性、扩充性、可移植性的影响,也考虑其实现问题。

    GoF 的 23 种设计模式的分类和功能

    设计模式有两种分类方法,即根据模式的目的来分和根据模式的作用的范围来分。

  5. 根据目的来分
    根据模式是用来完成什么工作来划分,这种方式可分为创建型模式、结构型模式和行为型模式 3 种。

  1. 根据作用范围来分
    根据模式是主要用于类上还是主要用于对象上来分,这种方式可分为类模式和对象模式两种。
  1. 依赖关系
    依赖(Dependency)关系是一种使用关系,在代码中,某个类的方法通过局部变量、方法的参数或者对静态方法的调用来访问另一个类(被依赖类)中的某些方法来完成一些职责。

  2. 关联关系
    关联(Association)关系是对象之间的一种引用关系,用于表示一类对象与另一类对象之间的联系,如老师和学生、师傅和徒弟、丈夫和妻子等。
    在代码中通常将一个类的对象作为另一个类的成员变量来实现关联关系。

  3. 聚合关系
    聚合(Aggregation)关系是关联关系的一种,是强关联关系,是整体和部分之间的关系,是 has-a 的关系。
    聚合关系也是通过成员对象来实现的,其中成员对象是整体对象的一部分,但是成员对象可以脱离整体对象而独立存在。例如,学校与老师的关系,学校包含老师,但如果学校停办了,老师依然存在。
    4.组合关系
    组合(Composition)关系也是关联关系的一种,也表示类之间的整体与部分的关系,但它是一种更强烈的聚合关系,是 contains-a 关系。
    在组合关系中,整体对象可以控制部分对象的生命周期,一旦整体对象不存在,部分对象也将不存在,部分对象不能脱离整体对象而存在。例如,头和嘴的关系,没有了头,嘴也就不存在了。
    5.泛化关系
    泛化(Generalization)关系是对象之间耦合度最大的一种关系,表示一般与特殊的关系,是父类与子类之间的关系,是一种继承关系,是 is-a 的关系。
    6.实现关系
    实现(Realization)关系是接口与实现类之间的关系。在这种关系中,类实现了接口,类中的操作实现了接口中所声明的所有的抽象操作。

    面向对象设计原则

    1.开闭原则的定义

    软件实体应当对扩展开放,对修改关闭(Software entities should be open for extension,but closed for modification)
    这里的软件实体包括以下几个部分:1.项目中划分出的模块 2.类与接口 3.方法
    开闭原则的含义是:当应用的需求改变时,在不修改软件实体的源代码或者二进制代码的前提下,可以扩展模块的功能,使其满足新的需求。

    2.里氏替换原则

    继承必须确保超类所拥有的性质在子类中仍然成立(Inheritance should ensure that any property proved about supertype objects also holds for subtype objects)
    里氏替换原则主要阐述了有关继承的一些原则,也就是什么时候应该使用继承,什么时候不应该使用继承,以及其中蕴含的原理。
    里氏替换原是继承复用的基础,它反映了基类与子类之间的关系,是对开闭原则的补充,是对实现抽象化的具体步骤的规范。
    里氏替换原则通俗来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。也就是说:子类继承父类时,除添加新的方法完成新增功能外,尽量不要重写父类的方法。

    3.依赖倒置原则

    依赖倒置原则的原始定义为:高层模块不应该依赖低层模块,两者都应该依赖其抽象;抽象不应该依赖细节,细节应该依赖抽象。其核心思想是:要面向接口编程,不要面向实现编程
    依赖倒置原则是实现开闭原则的重要途径之一,它降低了客户与实现模块之间的耦合。
    由于在软件设计中,细节具有多变性,而抽象层则相对稳定,因此以抽象为基础搭建起来的架构要比以细节为基础搭建起来的架构要稳定得多。这里的抽象指的是接口或者抽象类,而细节是指具体的实现类。
    依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性,所以我们在实际编程中只要遵循以下4点,就能在项目中满足这个规则。
    每个类尽量提供接口或抽象类,或者两者都具备。
    变量的声明类型尽量是接口或者是抽象类。
    任何类都不应该从具体类派生。
    使用继承时尽量遵循里氏替换原则。

    4.单一职责原则

    该原则提出对象不应该承担太多职责,否则类应该被拆分,如果一个对象承担了太多的职责,至少存在以下两个缺点:

  4. 一个职责的变化可能会削弱或者抑制这个类实现其他职责的能力;

  5. 当客户端需要该对象的某一个职责时,不得不将其他不需要的职责全都包含进来,从而造成冗余代码或代码的浪费。
    单一职责原则的核心就是控制类的粒度大小、将对象解耦、提高其内聚性。

    5.接口隔离原则的定义

    接口隔离原则(Interface Segregation Principle,ISP)要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口,让接口中只包含客户感兴趣的方法。
    要为各个类建立它们需要的专用接口,而不要试图去建立一个很庞大的接口供所有依赖它的类去调用

    6.迪米特法则

    迪米特法则又叫作最少知识原则:只与你的直接朋友交谈,不跟“陌生人”说话(Talk only to your immediate friends and not to strangers)。其含义是:如果两个软件实体无须直接通信,那么就不应当发生直接的相互调用,可以通过第三方转发该调用。其目的是降低类之间的耦合度,提高模块的相对独立性。
    迪米特法则中的“朋友”是指:当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等,这些对象同当前对象存在关联、聚合或组合关系,可以直接访问这些对象的方法。

    7.合成复用原则

    合成复用原则(Composite Reuse Principle,CRP)又叫组合/聚合复用原则(Composition/Aggregate Reuse Principle,CARP)。它要求在软件复用时,要尽量先使用组合或者聚合等关联关系来实现,其次才考虑使用继承关系来实现。
    如果要使用继承关系,则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的,两者都是开闭原则的具体实现规范。

    创建型模式

    创建型模式的主要关注点是“怎样创建对象?”,它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度,使用者不需要关注对象的创建细节,对象的创建由相关的工厂来完成。

    单例模式

    懒汉式

class Singleton
{
public:
    static Singleton* GetInstance()
    {
         if ( inst == NULL )
             inst = new Singleton();
         return inst;
    }
private:
    Singleton(){};
    static Singleton * inst;

饿汉式

class Singleton
{
private:
    Singleton(){}
    static Singleton * inst;
public:
    static Singleton * GetInstance()
    {
        return inst;
    }
};
Singleton::inst = new Singleton()

工厂模式

简单工厂模式

缺点是当新增产品的时候就要去修改工厂的类,这就违反了开放封闭原则,(类、模块、函数)可以扩展,但是不可以修改

#include<iostream>
using namespace std;
class Product
{
public:
    virtual void show() = 0;
};
class Product_A : public Product
{
public:
    void show()
    {
        cout << "Product_A" << endl;
    }
};
class Product_B : public Product
{
public:
    void show()
    {
        cout << "Product_B" << endl;
    }
};
class Factory
{
public:
    Product* Create(int i)
    {
        switch (i)
        {
        case 1:
            return new Product_A;
            break;
        case 2:
            return new Product_B;
            break;
        default:
            break;
        }
    }
};
int main()
{
    Factory *factory = new Factory();
    factory->Create(1)->show();
    factory->Create(2)->show();
    system("pause");
    return 0;
}

工厂方法模式

所谓工厂方法模式,是指定义一个用于创建对象的接口,让子类决定实例化哪一个类。打个比方
现在有A、B两种产品,那么就开两个工厂。工厂A负责生产A产品,工厂B负责生产B种产品。
工厂方法模式的主要角色如下:
抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。

#include "stdafx.h"
#include<iostream>
using namespace std;
class Product
{
public:
    virtual void show() = 0;
};
class Product_A : public Product
{
public:
    void show()
    {
        cout << "Product_A" << endl;
    }
};
class Product_B : public Product
{
public:
    void show()
    {
        cout << "Product_B" << endl;
    }
};
class Factory
{
public:
    virtual Product* create() = 0;
};
class Factory_A : public Factory
{
public:
    Product* create()
    {
        return new Product_A;
    }
};
class Factory_B : public Factory
{
public:
    Product* create()
    {
        return new Product_B;
    }
};
int main()
{
    Factory_A* productA = new Factory_A();
    Factory_B* productB = new Factory_B();
    productA->create()->show();
    productB->create()->show();
    system("pause");
    return 0;
}

抽象工厂

抽象工厂模式的扩展有一定的“开闭原则”倾斜性:
当增加一个新的产品族时只需增加一个新的具体工厂,不需要修改原代码,满足开闭原则。
当产品族中需要增加一个新种类的产品时,则所有的工厂类都需要进行修改,不满足开闭原则。
另一方面,当系统中只存在一个等级结构的产品时,抽象工厂模式将退化到工厂方法模式,其实俩都差不多。

#include <iostream>
using namespace std;
 
//定义抽象类
class product1
{
public:
    virtual void show() = 0;
};
 
//定义具体类
class product_A1 :public product1
{
public:
    void show(){ cout << "product A1" << endl; }
};
 
class product_B1 :public product1
{
public:
    void show(){ cout << "product B1" << endl; }
};
 
//定义抽象类
class product2
{
public:
    virtual void show() = 0;
};
 
//定义具体类
class product_A2 :public product2
{
public:
    void show(){ cout << "product A2" << endl; }
};
 
class product_B2 :public product2
{
public:
    void show(){ cout << "product B2" << endl; }
};
 
 
class Factory
{
public:
    virtual product1 *creat1() = 0;
    virtual product2 *creat2() = 0;
};
 
class FactoryA
{
public:
    product1 *creat1(){ return new product_A1(); }
    product2 *creat2(){ return new product_A2(); }
};
 
class FactoryB
{
public:
    product1 *creat1(){ return new product_B1(); }
    product2 *creat2(){ return new product_B2(); }
};
 
int main()
{
    FactoryA *factoryA = new FactoryA();
    factoryA->creat1()->show();
    factoryA->creat2()->show();
 
    FactoryB *factoryB = new FactoryB();
    factoryB->creat1()->show();
    factoryB->creat2()->show();
 
    return 0;
}