设计模式笔记（五）设计六大原则之五--迪米特法则

也叫最少知道原则，Least Knowledge Principle

定义

一个对象应该对其他对象有最少的了解，通俗的讲，一个类应该对自己需要耦合或调用的类知道得最少，被耦合或调用的类的内部是多么复杂和我没有关系，我只要知道提供的public方法，就知道这么多，其他的都不关心。

四层含义

迪米特法则对类的低耦合提出了明确的要求

只和直接的朋友交流

两个对象之间的耦合成为朋友关系。

举个栗子：

老师向体育委员发命令，让他清点女生人数

/*
* 老师类
*/
public class Teacher {
//老师对学生发布命令，清点一下女生
public void commond(GroupLeader groupLeader) {
List<Girl> listGirl = new ArrayList<Girl>();
//初始化女生
for (int i = 0;i<20;i++) {
listGirl.add(new Girl());

}

//告诉体育委员开始执行清查任务
groupLeader.countGirls(listGirl);
}
}

/*
* 体育委员
*/
public class GroupLeader {
//清查女生数量
public void countGirls(List<Girl> listGirls) {
System.out.println("女生的数量是："+listGirls.size());
}
}

/*
* 女生
*/
public class Girl {

}

/*
* 模拟老师命令体育委员清点女生人数场景
*/
public class Client {
public static void main(String[] args) {
Teacher teacher = new Teacher();
//老师发布命令
teacher.commond(new GroupLeader());
}
}

发现Teacher的直接朋友是GroupLeader但是方法间却用了不是直接朋友的对象Girl，commond方法时teacher的方法，teacher却不知道自己与Girl有了依赖，这是不允许的。

现在要将这个依赖关系去掉。

/*
* 老师类
*/
public class Teacher {
//老师对学生发布命令，清点一下女生
public void commond(GroupLeader groupLeader) {
//告诉体育委员开始执行清查任务
groupLeader.countGirls();
}
}

/*
* 体育委员
*/
public class GroupLeader {
private List<Girl> listGirls ;
public GroupLeader(List<Girl> listGirls ) {
this.listGirls = listGirls;
}
//清查女生数量
public void countGirls() {
System.out.println("女生的数量是："+this.listGirls.size());
}
}

/*
* 模拟老师命令体育委员清点女生人数场景
*/
public class Client {
public static void main(String[] args) {
//女生群体
List<Girl> listGirls = new ArrayList<Girl>();
Teacher teacher = new Teacher();
//老师发布命令
teacher.commond(new GroupLeader(listGirls));
}
}

避开了Teacher类对陌生类的访问，降低了耦合性，提高了系统的健壮性。

朋友间是有距离的

类之间的耦合关系不能过于牢固，即使是朋友之间也不能无话不说。

举个栗子：

/*
* 模拟安装软件动作，根据向导，第一个动作完毕下一个动作运行
*/
public class InstallSoftware {
public void installWizard(Wizard wizard) {
int first = wizard.first();
if(first > 50) {
int second = wizard.second();
if(second>50) {
int third = wizard.third();
if(third > 50) {
wizard.first();
}
}
}
}
}

/*
* 向导类
*/
public class Wizard {
private Random rand = new Random(System.currentTimeMillis());

//第一步
public int first() {
System.out.println("执行第一个方法");
return rand.nextInt(100);
}

//第二步
public int second() {
System.out.println("执行第二个方法");
return rand.nextInt(100);
}

//第三步
public int third() {
System.out.println("执行第三个方法");
return rand.nextInt(100);
}
}

/*
* 场景类
*/
public class ClientForInstall {
public static void main(String[] args) {
InstallSoftware invoker = new InstallSoftware();
invoker.installWizard(new Wizard());
}
}

如果Wizard类中first方法返回值变了，那么InstallSoftware类也要发生变化，这样过于依赖了。

可以让public的方法减少，让private或者protected的方法多一些。

修改后：

/*
* 模拟安装软件动作，根据向导，第一个动作完毕下一个动作运行
*/
public class InstallSoftware {
public void installWizard(Wizard wizard) {
wizard.installWizard();
}
}

/*
* 向导类
*/
public class Wizard {
private Random rand = new Random(System.currentTimeMillis());

//第一步
private int first() {
System.out.println("执行第一个方法");
return rand.nextInt(100);
}

//第二步
private int second() {
System.out.println("执行第二个方法");
return rand.nextInt(100);
}

//第三步
private int third() {
System.out.println("执行第三个方法");
return rand.nextInt(100);
}

//软件安装过程
public void installWizard() {
int first = this.first();
if(first > 50) {
int second = this.second();
if(second>50) {
int third = this.third();
if(third > 50) {
this.first();
}
}
}
}
}

是自己的就是自己的

如果一个方法放在本类中不增加类间关系，对本类不产生负面影响，那么就放在本类中。

谨慎使用Serializable

如果一个项目使用了远程方法调用，这个对象就必须实现Serializable接口，也就是需要把网络传输的对象序列化，否则就会出现异常。突然，客户端的VO修改了一个属性的访问权限，private变为public访问权限变大了，如果程序上没有变更，就会报序列化失败。