设计模式七大原则(C++描述)

前言

最近在学习一些基本的设计模式,发现很多博客都是写了六个原则,但我认为有7个原则,并且我认为在编码中思想还是挺重要,所以写下一篇博客来总结下

之后有机会会写下一些设计模式的博客(咕咕咕........

设计模式的七大原则

1.单一职责原则

2.开放-封闭原则

3.依赖倒置原则

4.里氏替换原则(LSP)

5.接口隔离原则

6.迪米特原则(最少知道原则)

7.合成复用原则

1.单一职责原则

准确解析:就一个类而言,应该仅有一个引起它变化的原因

当一个类职责变化时不会导致另一个类职责的变化.

优点:可以降低类的复杂度,提高可读性

2.开放-封闭原则

准确解析:软件实体(类,模板,函数等等)应该可以扩展,但不可修改

开闭原则是面对对象设计的核心所在;开放人员应该仅对程序中呈现出频繁变化

的那些部分做出抽象.

3.依赖倒置原则

准确解析:A.高层模板(稳定)不应该依赖底层模板(变化).两个都应该依赖抽象(稳定)

B.抽象(稳定)不应该依赖实现细节(变化).细节(变化)应该依赖抽象(稳定).

不论变化还是稳定都应该依赖于稳定

说白了:要面对接口编程,不要对实现编程.

#include<iostream>
class Book
{
    public:void look()
    {
        ....
    }
    .....
}
class Man
{
   puclic:void Action(Book book)
   {
      book.look();
   }
   ....
}

int main()
{
    Man man=new Man();
    Book book=new book();
    Man->Action(book);
    ....
}

上面显示的是人看书的行为

那么假设现有我想要人进行看视频行为,视频类的代码如下:

class Video
{
    public:void Video()
    {
        ....
    }
    .....
}

那么我不仅要对人这个类中修改,还有对主函数的代码进行修改;如果有大量的需要的话,这个修改过程将会变得非常痛苦,因为书和人的耦合度太高.

接下来使用依赖倒置原则来会解决当前的痛苦,能够降低书和人的耦合度

书和视频我们当作一个可以看的东西ILOOK作为接口类,然后书和视频继承这个类

class ILOOK
{
    public:virtual void look()=0;
}

class Bookpublic ILOOk
{
    public:void look()
    {
        ....
    }
    .....
}

class Video:public ILOOk
{
    public:void look()
    {
        ....
    }
    .....
}
class Man
{
   puclic:void Action(ILOOK ilook)
   {
      ilook.look();
   }
   ....
}

int main()
{
    Man man=new Man();
    ILOOK ilook=new book();
    Man->Action(ilook);
    ILOOK ilook2=new video();
    Man->Action(ilook2);
    ....
}

这样就实现了简单的依赖倒置,人依赖于ILOOK这个类,并且书和视频也都依赖于ILook(即高层和底层都应该依赖抽象

这便是一个简单的面对接口编程.

这个依赖倒置原则将会贯串于所有设计模式,所以对于这个原则一定要有清晰的认识

4.里氏替换原则(LSP)

准确解析:子类型必须能够替换掉它们的父类型

说白了就是一种IS-A的另一种表达

比如说:鸟是一个父类,有 fly()这个虚函数,燕子是一个鸟,因为它能够飞,所以它可以继承鸟类;

企鹅不能飞,所以它不能继承鸟类,即使他在生物学上是鸟类,但它在编程世界中不能够继承鸟类

这里说出LSP的一个特点:只有当子类可以替换掉父类,软件单位的功能不受影响时,父类才能够被复用,而子类也能够在父类的基础上增加新的行为

通俗来说:子类可以扩展父类的功能,但不能改变父类原来的功能。

包括4层含义:1.子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。

2.子类中可以增加自己特有的方法。

3.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

4.当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

4种含义不展开讲,但用下面的一个例子来简单说明

#include<iostream>

class A
{
public:
	int fun1(int a, int b) {
		return a - b;
	}
};

class B :public A
{
public:
	int fun1(int a, int b) {
		return a + b;
	}
	int fun2(int a, int b)
	{
	     return fun1(a, b)-100;   //想要a-b-100,但现实是a+b-100
	}
};
int main()
{
	int a = 100, b = 20;
	B* m_b=new B();
	std::cout << m_b->fun2(a, b) << std::endl;
}

上面显示的结果会是20,因为B类中的fun1()覆盖到了A类中的fun1();所以fun2()中调用的是B类的fun1(),这便违反了里氏替换原则

不遵循里氏替换原则的后果是:出问题的概率会大大提高

5.接口隔离原则

准确解释:不应该强迫客户程序依赖他们不用的方法;接口应该小而完备

class I
{
    public:
    void method1()=0;
    void method2()=0;
    void method3()=0;
    void method4()=0;
    void method5()=0;
}

class A
{
    public:
    void depend1(I i)
    {
        i.method1();
    }
     void depend2(I i)
    {
        i.method2();
    }
     void depend3(I i)
    {
        i.method3();
    }
}
class B:public I
{
    public:
    void method1()
    {
        std::cout<<"B实现方法1"<<std::endl;
    }
    void method2()
    {
        std::cout<<"B实现方法2"<<std::endl;
    }
    void method3()
    {
        std::cout<<"B实现方法3"<<std::endl;
    }
    //B类种方法4和5不是必须的
    //但方法4和5因为继承的原因仍让需要空实现
    void method4(){}
    void method5(){}
}

class C
{
    public:
    void depend1(I i)
    {
        i.method1();
    }
     void depend2(I i)
    {
        i.method4();
    }
     void depend3(I i)
    {
        i.method5();
    }
}
class D:public I
{
    public:
    void method1()
    {
        std::cout<<"B实现方法1"<<std::endl;
    }
    void method4()
    {
        std::cout<<"B实现方法4"<<std::endl;
    }
    void method5()
    {
        std::cout<<"B实现方法4"<<std::endl;
    }
    //B类种方法2和3不是必须的
    //但方法2和3因为继承的原因仍让需要空实现
    void method2(){}
    void method3(){}
}

上面便没有使用接口隔离原则

下面便使用了接口隔离,所以一些无关的方法就可以不用去实现

class I1
{
    public:
    void method1()=0;
}
class I2
{
    public:
    void method2()=0;
    void method3()=0;
}
class I3
{
    public:
    void method4()=0;
    void method5()=0;
}
class A
{
    public:
    void depend1(I1 i)
    {
        i1.method1();
    }
     void depend2(I2 i)
    {
        i2.method2();
    }
     void depend3(I2 i)
    {
        i2.method3();
    }
}
class B:public I1,public I2
{
    public:
    void method1()
    {
        std::cout<<"B实现I1方法1"<<std::endl;
    }
    void method2()
    {
        std::cout<<"B实现I2方法2"<<std::endl;
    }
    void method3()
    {
        std::cout<<"B实现I2方法3"<<std::endl;
    }
}

class C
{
    public:
    void depend1(I1 i)
    {
        i1.method1();
    }
     void depend2(I2 i)
    {
        i3.method4();
    }
     void depend3(I2 i)
    {
        i3.method5();
    }
}
class D:public I1,public I3
{
    public:
    void method1()
    {
        std::cout<<"B实现I1方法1"<<std::endl;
    }
    void method4()
    {
        std::cout<<"B实现I3方法4"<<std::endl;
    }
    void method5()
    {
        std::cout<<"B实现I3方法4"<<std::endl;
    }

}

使用接口隔离原则时应注意:

1.接口尽量小，但是要有限度。如果过小，则会造成接口数量过多，使设计复杂化。所以一定要适度。

2.为依赖接口的类定制服务，只暴露给调用的类它需要的方法，它不需要的方法则隐藏起来。

3.提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。

这个原则可以在实践多花时间思考,才可以准确地使用它

6.迪米特原则(最少知道原则)

准确解释:一个对象应该对其他对象保持最少的了解

因为类之间的关系最紧密,耦合度越高,一个类变化时对另一个类的影响也大

我们使用迪米特原则就是要降低类之间的耦合度

C++中一个重要的特性:高内聚,低耦合.高内聚,低耦合.高内聚,低耦合.(重要的事情说三遍)

#include<iostream>
#include<list>
#include<string>

class Employee
{
private:
	std::string m_id;
public:
	Employee(){}
	Employee(std::string id) :m_id(id) {}
	std::string get_id()
	{
		return m_id;
	}
};
class SubEmployee
{
private:
	std::string m_id;
public:
	SubEmployee() {

	}
	SubEmployee(std::string id) :m_id(id) {}
	std::string get_id()
	{
		return m_id;
	}
};
class SubCompanyManager
{
public:
	std::list<SubEmployee> getAllEmployee()
	{
		std::list<SubEmployee> list(100);
		for (int i = 0; i < 100; i++)
		{
			SubEmployee emp("分公司" + std::to_string(i));
			list.push_back(emp);
		}
		return list;
	}
};
class CompanyManager
{
public:
	std::list<Employee> getAllEmployee()
	{
		std::list<Employee> list(30);
		for (int i = 0; i < 30; i++)
		{
			Employee emp("总公司"+std::to_string(i));
			list.push_back(emp);
		}
		return list;
	}
	void printALLEmployee(SubCompanyManager sub)
	{
		std::list<SubEmployee> list1(100);
		list1 = sub.getAllEmployee();
		std::list<SubEmployee>::iterator itor= list1.begin();
		for (; itor != list1.end(); itor++)
		{
			std::cout << itor->get_id();
		}
		std::list<Employee> list2(30);
		list2= getAllEmployee();
		std::list<Employee>::iterator itor2 = list2.begin();
		for (; itor2 != list2.end(); itor2++)
		{
			std::cout << itor2->get_id();
		}
	}
};

int main()
{
	CompanyManager* e = new CompanyManager();
	SubCompanyManager s;
	e->printALLEmployee(s);
	system("pause");
	return 0;
}

上面的代码违反了迪米特原则

根据迪米特法则，只与直接的朋友发生通信，而SubEmployee类并不是CompanyManager类的直接朋友（以局部变量出现的耦合不属于直接朋友），从逻辑上讲总公司只与他的分公司耦合就行了，与分公司的员工并没有任何联系，这样设计显然是增加了不必要的耦合。

class SubCompanyManager
{
public:
	std::list<SubEmployee> getAllEmployee()
	{
		std::list<SubEmployee> list(100);
		for (int i = 0; i < 100; i++)
		{
			SubEmployee emp("分公司" + std::to_string(i));
			list.push_back(emp);
		}
		return list;
	}
	void printALLEmployee()
	{
		std::list<SubEmployee> list = getAllEmployee();
		std::list<SubEmployee>::iterator itor = list.begin();
		for (; itor != list.end(); itor++)
		{
			std::cout << itor->get_id();
		}
	}
};
class CompanyManager
{
public:
	std::list<Employee> getAllEmployee()
	{
		std::list<Employee> list(30);
		for (int i = 0; i < 30; i++)
		{
			Employee emp("总公司" + std::to_string(i));
			list.push_back(emp);
		}
		return list;
	}
	void printALLEmployee(SubCompanyManager sub)
	{
		sub.printALLEmployee();
		std::list<Employee> list2(30);
		list2 = getAllEmployee();
		std::list<Employee>::iterator itor2 = list2.begin();
		for (; itor2 != list2.end(); itor2++)
		{
			std::cout << itor2->get_id();
		}
	}
};

为分公司增加了打印人员ID的方法，总公司直接调用来打印，从而避免了与分公司的员工发生耦合。

另外切记不要过分使用迪米特原则,否则会产生大量的这样的中介和传递类,

7.合成复用原则

准确解析:尽量先使用组合后聚合等关联关系来实现,其次才考虑使用继承关系来实现

继承复用:又称"白箱""复用,耦合度搞,不利于类的扩展和维护

组合或聚合复用:又称"黑箱"复用,耦合度低,灵活度高

上面的图使用继承复合产生了大量的子类,如何需要增加新的"动力源"或者"颜色"

都要修改源代码,因为耦合度高,这违背了开闭原则

如果改为组合或聚合复用就可以很好的解决上述问题,如下图所示

七点原则总结

单一职责原则告诉我们实现类要职责单一；里氏替换原则告诉我们不要破坏继承体系；依赖倒置原则告诉我们要面向接口编程；接口隔离原则告诉我们在设计接口的时候要精简单一；迪米特法则告诉我们要降低耦合。而开闭原则是总纲，他告诉我们要对扩展开放，对修改关闭。合成复用原则告诉我们要优先使用组合或者聚合关系复用，少用继承关系复用。

我们在实践时应该根据实际情况灵活使运用,才能达到良好的设计

参考博客:

http://www.uml.org.cn/sjms/201211023.asp#2

参考视频:

https://www.bilibili.com/video/av22292899

参考书籍:<<大话设计模式>>

作者：Ligo丶

出处：https://www.cnblogs.com/Ligo-Z/

本文版权归作者和博客园共有，欢迎转载，但必须给出原文链接，并保留此段声明，否则保留追究法律责任的权利。