#yyds干货盘点#前端迪米特法则

迪米特法则(Law of Demeter )又叫做最少知识原则,也就是说,一个对象应当对其他对象尽可能少的了解。不和陌生人说话。英文简写为: LoD。

迪米特法则的目的在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖,因此,很容易使得系统的功能模块功能独立,相互之间不存在(或很少有)依赖关系。

迪米特法则不希望类之间建立直接的联系。如果真的有需要建立联系,也希望能通过它的友元类来转达。因此,应用迪米特法则有可能造成的一个后果就是:系统中存在大量的中介类,这些类之所以存在完全是为了传递类之间的相互调用关系——这在一定程度上增加了系统的复杂度。

为什么要遵守迪米特法则

在面向对象编程中有一些众所周知的抽象概念,比如封装、内聚和耦合,理论上可以用来生成清晰的设计和良好的代码。虽然这些都是非常重要的概念,但它们不够实用,不能直接用于开发环境,这些概念是比较主观的,非常依赖于使用人的经验和知识。对于其他概念,如单一责任原则、开闭原则等,情况也是一样的。迪米特法则的独特之处在于它简洁而准确的定义,它允许在编写代码时直接应用,几乎自动地应用了适当的封装、低内聚和松耦合。

迪米特法则实践

那么在实践中如何做到一个对象应该对其他对象有最少的了解呢?

如果我们把一个对象看作是一个人,那么要实现“一个人应该对其他人有最少的了解”,做到两点就足够了:

  • 只和直接的朋友交流;
  • 减少对朋友的了解。

下面就详细说说如何做到这两点。

  1. 只和直接的朋友交流

迪米特法则还有一个英文解释是:talk only to your immediate friends(只和直接的朋友交流)。

什么是朋友呢?

每个对象都必然会与其他的对象有耦合关系,两个对象之间的耦合就会成为朋友关系。那么什么又是直接的朋友呢?出现在成员变量、方法的输入输出参数中的类就是直接的朋友。迪米特法则要求只和直接的朋友通信。

注意:

只出现在方法体内部的类就不是直接的朋友,如果一个类和不是直接的朋友进行交流,就属于违反迪米特法则。

我们举一个例子说明什么是朋友,什么是直接的朋友。很简单的例子:老师让班长清点全班同学的人数。这个例子中总共有三个类:老师Teacher、班长GroupLeader和学生Student。

public interface ITeacher {
void command(IGroupLeader groupLeader);
}

public class Teacher implements ITeacher{
@Override
public void command(IGroupLeader groupLeader) {
// 全班同学
List<Student> allStudent = new ArrayList<>();
allStudent.add(new Student());
allStudent.add(new Student());
allStudent.add(new Student());
allStudent.add(new Student());
allStudent.add(new Student());
// 班长清点人数
groupLeader.count(allStudent);

}
}

**
* 班长类
*/
public interface IGroupLeader {

// 班长清点人数
void count(List<Student> students);
}

/**
* 班长类
*/
public class GroupLeader implements IGroupLeader{
/**
* 班长清点人数
* @param students
*/
@Override
public void count(List<Student> students) {
// 班长清点人数
System.out.println("上课的学生人数是: " + students.size());
}
}

/**
* 学生类
*/
public interface IStudent {
}

/**
* 学生类
*/
public class Student implements IStudent {


}

/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
// 老师类
ITeacher wangTeacher = new Teacher();

// 班长
IGroupLeader zhangBanzhang = new GroupLeader();
wangTeacher.command(zhangBanzhang);
}
}
复制代码

运行结果:

复制代码

在这个例子中,我们的Teacher有几个朋友?两个,一个是GroupLeader,它是Teacher的command()方法的入参;另一个是Student,因为在Teacher的command()方法体中使用了Student。

那么Teacher有几个是直接的朋友?按照直接的朋友的定义

出现在成员变量、方法的输入输出参数中的类就是直接的朋友

只有GroupLeader是Teacher的直接的朋友。

Teacher在command()方法中创建了Student的数组,和非直接的朋友Student发生了交流,所以,上述例子违反了迪米特法则。方法是类的一个行为,类竟然不知道自己的行为与其他的类产生了依赖关系,这是不允许的,严重违反了迪米特法则!

为了使上述例子符合迪米特法则,我们可以做如下修改:

public interface ITeacher {
void command(IGroupLeader groupLeader);
}

public class Teacher implements ITeacher {
@Override
public void command(IGroupLeader groupLeader) {
// 班长清点人数
groupLeader.count();
}
}

/**
* 班长类
*/
public interface IGroupLeader {
// 班长清点人数
void count();
}

/**
* 班长类
*/
public class GroupLeader implements IGroupLeader {

private List<Student> students;

public GroupLeader(List<Student> students) {
this.students = students;
}

/**
* 班长清点人数
*/
@Override
public void count() {
// 班长清点人数
System.out.println("上课的学生人数是: " + students.size());
}
}


/**
* 学生类
*/
public interface IStudent {
}

/**
* 学生类
*/
public class Student implements IStudent {


}


/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
// 老师类
ITeacher wangTeacher = new Teacher();

List<Student> allStudent = new ArrayList(10);
allStudent.add(new Student());
allStudent.add(new Student());
allStudent.add(new Student());
allStudent.add(new Student());

// 班长
IGroupLeader zhangBanzhang = new GroupLeader(allStudent);
wangTeacher.command(zhangBanzhang);
}
}
复制代码

运行结果:

复制代码

这样修改后,每个类都只和直接的朋友交流,有效减少了类之间的耦合

  1. 减少对朋友的了解

如何减少对朋友的了解?如果你的朋友是个话痨加大喇叭,那就算你不主动去问他,他也会在你面前说个不停,把他所有的经历都讲给你听。所以,要减少对朋友的了解,请换一个内敛一点的朋友吧~换作在一个类中,就是尽量减少一个类对外暴露的方法。

举一个简单的例子说明一个类暴露方法过多的情况。一个人用咖啡机煮咖啡的过程,例子中只有两个类,一个是人,一个是咖啡机。

首先是咖啡机类CoffeeMachine,咖啡机制作咖啡只需要三个方法:1.加咖啡豆;2.加水;3.制作咖啡:

/**
* 咖啡机抽象接口
*/
public interface ICoffeeMachine {

//加咖啡豆
void addCoffeeBean();

//加水
void addWater();

//制作咖啡
void makeCoffee();
}


/**
* 咖啡机实现类
*/
public class CoffeeMachine implements ICoffeeMachine{

//加咖啡豆
public void addCoffeeBean() {
System.out.println("放咖啡豆");
}

//加水
public void addWater() {
System.out.println("加水");
}

//制作咖啡
public void makeCoffee() {
System.out.println("制作咖啡");
}
}


/**
* 人, 制作咖啡
*/
public interface IMan {
/**
* 制作咖啡
*/
void makeCoffee();
}

/**
* 人制作咖啡
*/
public class Man implements IMan {
private ICoffeeMachine coffeeMachine;

public Man(ICoffeeMachine coffeeMachine) {
this.coffeeMachine = coffeeMachine;
}

/**
* 制作咖啡
*/
public void makeCoffee() {
coffeeMachine.addWater();
coffeeMachine.addCoffeeBean();
coffeeMachine.makeCoffee();
}
}

/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
ICoffeeMachine coffeeMachine = new CoffeeMachine();

IMan man = new Man(coffeeMachine);
man.makeCoffee();

}
}
复制代码

运行结果:

复制代码

在这个例子中,CoffeeMachine是Man的直接好友,但问题是Man对CoffeeMachine了解的太多了,其实人根本不关心咖啡机具体制作咖啡的过程。所以我们可以作如下优化:

优化后的咖啡机类,只暴露一个work方法,把制作咖啡的三个具体的方法addCoffeeBean、addWater、makeCoffee设为私有:

/**
* 咖啡机抽象接口
*/
public interface ICoffeeMachine {

//咖啡机工作
void work();

}

/**
* 咖啡机实现类
*/
public class CoffeeMachine implements ICoffeeMachine {

//加咖啡豆
public void addCoffeeBean() {
System.out.println("放咖啡豆");
}

//加水
public void addWater() {
System.out.println("加水");
}

//制作咖啡
public void makeCoffee() {
System.out.println("制作咖啡");
}

@Override
public void work() {
addCoffeeBean();
addWater();
makeCoffee();
}
}

/**
* 人, 制作咖啡
*/
public interface IMan {
/**
* 制作咖啡
*/
void makeCoffee();
}


/**
* 人制作咖啡
*/
public class Man implements IMan {
private ICoffeeMachine coffeeMachine;

public Man(ICoffeeMachine coffeeMachine) {
this.coffeeMachine = coffeeMachine;
}

/**
* 制作咖啡
*/
public void makeCoffee() {
coffeeMachine.work();
}
}

/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
ICoffeeMachine coffeeMachine = new CoffeeMachine();

IMan man = new Man(coffeeMachine);
man.makeCoffee();

}
}
复制代码

这样修改后,通过减少CoffeeMachine对外暴露的方法,减少Man对CoffeeMachine的了解,从而降低了它们之间的耦合。

发表评论

相关文章