面向对象七大原则之迪米特法则

package com.waibizii;
/**
 * 迪米特法则
 * @author 
 *	 迪米特法则（Law of Demeter）又叫作最少知道原则（Least Knowledge Principle 简写LKP），就是说一个对象应当对其他对象有尽可能少的了解,不和陌生人说话。英文简写为: LoD.
 * 	优点(低耦合)
 *	在采用迪米特法则时要反复权衡，既做到结构清晰，又要高内聚低耦合。
 *	迪米特法则还有个更简单的定义：只与直接的朋友通信
 *	
 *	直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。
 *		耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，
 *		而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类不要以局部变量的形式出现在类的内部。
 */
import java.util.ArrayList;
import java.util.List;

/**
 * 	迪米特法则 改造前
 * 改造前的代码并未遵守迪米特法则，不理解的同学，可以仔细读下关于直接朋友的描述
 */
// 客户端
public class Demeter_Principle {
    public static void main(String[] args) {
        // 创建了一个 SchoolManager 对象
        SchoolManager schoolManager = new SchoolManager();
        // 输出学院地的员工id和学校总部的员工信息
        schoolManager.printAllEmployee(new CollegeManager());
        
    }
}

// 学院总部员工类
class Employee{
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

// 学院员工类
class CollegeEmployee{
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

// 管理学院员工的管理类
class CollegeManager{
    // 返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee(){
       List<CollegeEmployee> list = new ArrayList<>();
       for (int i = 0; i < 10;i++){ // 这里增加了10个员工到 list 集合
           CollegeEmployee emp = new CollegeEmployee();
           emp.setId("学院员工id=" + i);
           list.add(emp);
       }
       return list;
    }
}

// 学校管理类
// 分析 SchoolManager 类的直接朋友类有哪些？
// Employee - 返回值，CollegeManager - 方法参数，
// CollegeEmployee 不是直接朋友，而是一个陌生类，这样违背了 迪米特法则
class SchoolManager{
    // 返回学校总部的员工
    public List<Employee> getAllEmployee(){
        List<Employee> list = new ArrayList<>();
        for (int i = 0; i < 5;i++){ // 这里增加了5个员工到 list 集合
            Employee emp = new Employee();
            emp.setId("学校总部员工id=" + i);
            list.add(emp);
        }
        return list;
    }

    // 该方法完成输出学校总部和学院员工信息的方法(id)
    void printAllEmployee(CollegeManager sub){

        // 分析问题
        // 1.这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
        // 2.CollegeEmployee 是以局部变量的方式出现在 SchoolManager 中
        // 3. 违反了迪米特法则

        // 获取到学院员工
        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println("---------------学院员工-----------");
        for (CollegeEmployee employee : list1) {
            System.out.println(employee.getId());
        }

        // 获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("---------------学校总部员工-----------");
        for (Employee employee : list2) {
            System.out.println(employee.getId());
        }
    }
}

//迪米特法则 改造前

　　

改造后

package com.waibizii.improve;
/**
 * 1）前面设计的问题在于 SchoolManager 中， CollegeEmeployee 类并不是 SchoolManager 类的直接朋友（分析）

　　2）按照迪米特法则，应该避免类中出现这样非直接朋友关系的耦合。

　　3）对代码按照迪米特法则进行改进
 */
import java.util.ArrayList;
import java.util.List;

/**
 * 迪米特法则 改造后
 */
// 客户端
public class Demeter_Principle_improve {
    public static void main(String[] args) {
        System.out.println("使用迪米特法则改造");
        // 创建了一个 SchoolManager 对象
        SchoolManager schoolManager = new SchoolManager();
        // 输出学院地的员工id和学校总部的员工信息
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

// 学院总部员工类
class Employee{
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

// 学院员工类
class CollegeEmployee{
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

// 管理学院员工的管理类
class CollegeManager{
    // 返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee(){
       List<CollegeEmployee> list = new ArrayList<>();
       for (int i = 0; i < 10;i++){ // 这里增加了10个员工到 list 集合
           CollegeEmployee emp = new CollegeEmployee();
           emp.setId("学院员工id=" + i);
           list.add(emp);
       }
       return list;
    }

    // 输出学院员工的信息
    public void printEmployee(){
        // 获取到学院员工
        List<CollegeEmployee> list1 = getAllEmployee();
        System.out.println("---------------学院员工-----------");
        for (CollegeEmployee employee : list1) {
            System.out.println(employee.getId());
        }
    }
}

// 学校管理类
// 分析 SchoolManager 类的直接朋友类有哪些？
// Employee - 返回值，CollegeManager - 方法参数，
// CollegeEmployee 不是直接朋友，而是一个陌生类，这样违背了 迪米特法则
class SchoolManager{
    // 返回学校总部的员工
    public List<Employee> getAllEmployee(){
        List<Employee> list = new ArrayList<>();
        for (int i = 0; i < 5;i++){ // 这里增加了5个员工到 list 集合
            Employee emp = new Employee();
            emp.setId("学校总部员工id=" + i);
            list.add(emp);
        }
        return list;
    }

    // 该方法完成输出学校总部和学院员工信息的方法(id)
    void printAllEmployee(CollegeManager sub){

        // 分析问题
        // 1.将输出学院员工方法，封装到 CollegeManager 中
        sub.printEmployee();

        // 获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("---------------学校总部员工-----------");
        for (Employee employee : list2) {
            System.out.println(employee.getId());
        }
    }
}

//迪米特法则 改造后