面向对象设计模式原则-迪米特法则

迪米特法则(LOD,Law of Demeter)

注：迪米特法则又名 ：最少知识原则

定义：一个软件实体应当尽可能少地与其他实体发生相互作用。

一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。例如在一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现。这样其他模块不需要了解另外一个模块的内部实现细节，这样当一个模块内部的实现发生改变时，不会影响其他模块的使用。(黑盒原理)

迪米特法则还有几种定义形式，包括：不要和“陌生人”说话、只与你的直接朋友通信等，在迪米特法则中，对于一个对象，其朋友包括以下几类：

（1）当前对象本身(this)；
（2）以参数形式传入到当前对象方法中的对象；
（3）当前对象的成员对象；
（4）如果当前对象的成员对象是一个集合，那么集合中的元素也都是朋友；
（5）当前对象所创建的对象。

任何一个对象，如果满足上面的条件之一，就是当前对象的“朋友”，否则就是“陌生人”。在应用迪米特法则时，一个对象只能与直接朋友发生交互，不要与“陌生人”发生直接交互，这样做可以降低系统的耦合度，一个对象的改变不会给太多其他对象带来影响。

迪米特法则要求我们在设计系统时，应该尽量减少对象之间的交互，如果两个对象之间不必彼此直接通信，那么这两个对象就不应当发生任何直接的相互作用，如果其中的一个对象需要调用另一个对象的某一个方法的话，可以通过第三者转发这个调用。简言之，就是通过引入一个合理的第三者来降低现有对象之间的耦合度。

迪米特法则的几种形式：

迪米特法则

1)和陌生人说话

2)不和陌生人说话

3) 与依赖倒转原则结合 某人和 抽象陌生人说话  让某人和陌生人进行解耦合

简单案例：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
using namespace std;

/*最少知识原则
*不需要知道别的类的具体实现细节，通过中介类来满足操作
*这里使用房子售卖流程来介绍迪米特法则
*买房者只需要找到中介说明自己的需求，中介有房源，查询后提供对应的楼盘信息
*/
class AbstractBuilding{
public:
	virtual void sale() = 0;
	virtual string getQuilty() = 0;
};

//楼盘A
class BuildingA : public AbstractBuilding{
public:
	BuildingA(){
		m_quilty = "好品质";
	}
	virtual void sale(){
		cout << "楼盘A:" << m_quilty << " 被售卖" << endl;
	}
	virtual string getQuilty(){
		return m_quilty;
	}
private:
	string m_quilty;
};

//楼盘B
class BuildingB : public AbstractBuilding{
public:
	BuildingB(){
		m_quilty = "经济适用房";
	}
	virtual void sale(){
		cout << "楼盘B:" << m_quilty << " 被售卖" << endl;
	}
	virtual string getQuilty(){
		return m_quilty;
	}
private:
	string m_quilty;
};

//中介类：收集楼盘信息
class Mediator{
public:
	Mediator(){
		BuildingA* ba = new BuildingA;
		m_building.push_back(ba);

		BuildingB *bb = new BuildingB;
		m_building.push_back(bb);
	}
	~Mediator(){
		for (vector<AbstractBuilding*>::iterator it = m_building.begin();
			it != m_building.end(); it++){
			if (*it != NULL){
				delete *it;
				*it = NULL;
			}
		}
	}
	AbstractBuilding* findBuilding(string quilty){
		for (vector<AbstractBuilding*>::iterator it = m_building.begin();
			it != m_building.end(); it++){
			if ((*it)->getQuilty() == quilty){
				return *it;
			}
		}

		return NULL;
	}
private:
	vector<AbstractBuilding* > m_building;
};

//客户端
void test(){
	Mediator* media = new Mediator;
	AbstractBuilding* building = media->findBuilding("好品质");

	if (building != NULL){
		building->sale();
	}
}

int main(){
	test();
	return 0;
}

简单总结：

在将迪米特法则运用到系统设计中时，要注意下面的几点：在类的划分上，应当尽量创建松耦合的类，类之间的耦合度越低，就越有利于复用，一个处在松耦合中的类一旦被修改，不会对关联的类造成太大波及；在类的结构设计上，每一个类都应当尽量降低其成员变量和成员函数的访问权限；在类的设计上，只要有可能，一个类型应当设计成不变类；在对其他类的引用上，一个对象对其他对象的引用应当降到最低。

迪米特法则的初衷是降低类之间的耦合，由于每个类都减少了不必要的依赖，因此的确可以降低耦合关系。但是凡事都有度，虽然可以避免与非直接的类通信，但是要通信，必然会通过一个“中介”来发生联系。过分的使用迪米特原则，会产生大量这样的中介和传递类，导致系统复杂度变大。所以在采用迪米特法则时要反复权衡，既做到结构清晰，又要高内聚低耦合。