迪米特法则

迪米特法则

基本介绍

• 1.一个对象应该对其他对象保持最少的了解。
• 2.类和类的关系越密切，耦合度越大。
• 3.迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量封装在类的内部。对外除了public的方法，不对外泄露任何信息。
• 4.迪米特法则还有更简单的定义，只与直接朋友通信。
• 5.直接朋友定义：每个对象都会和其他对象有耦合关系，只要两个对象存在耦合关系，就可以称这两个对象为朋友关系。耦合关系有很多，依赖，关联，组合，聚合等。其中，把出现在成员变量，方法参数，方法返回值中的类称为直接朋友，而出现在局部变量的类则不是直接朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

案例1

/**
 * @author 长名06
 * @version 1.0
 * 迪米特法则 案例1
 * 分析，这样写违反了迪米特法则，因为SchoolManager类和CollegeEmployee
 * 不是直接朋友，却在局部变量中使用了CollegeEmployee
 * 改进，将对于CollegeEmployee的操作，封装到CollegeManager中
 */
public class Demeter1 {
    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        CollegeManager collegeManager = new CollegeManager();
        schoolManager.printAllEmployee(collegeManager);
    }
}

class Employee {

    private long id;

    public Long getId() {
        return id;
    }

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

class CollegeEmployee {

    private long id;

    public Long getId() {
        return id;
    }

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

class CollegeManager {

    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            CollegeEmployee c = new CollegeEmployee();
            c.setId((long)i);
            list.add(c);
        }
        return list;
    }
}

class SchoolManager {

    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<>();

        for (int i = 0; i < 5; i++) {
            Employee e = new Employee();
            e.setId((long)i);
            list.add(e);
        }
        return list;
    }

    public void printAllEmployee(CollegeManager collegeManager){
        List<CollegeEmployee> allEmployee = collegeManager.getAllEmployee();
        System.out.println("学院员工");
        for(CollegeEmployee e : allEmployee){
            System.out.print(e.getId());
        }

        System.out.println("\n学校总部员工");
        List<Employee> employees = this.getAllEmployee();
        for(Employee e : employees){
            System.out.print(e.getId());
        }
    }
}

案例1改进

/**
 * @author 长名06
 * @version 1.0
 * 迪米特法则 案例1 改进
 */
public class Demeter2 {
    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

class Employee {

    private long id;

    public Long getId() {
        return id;
    }

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

class CollegeEmployee {

    private long id;

    public Long getId() {
        return id;
    }

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

class CollegeManager {

    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            CollegeEmployee c = new CollegeEmployee();
            c.setId((long) i);
            list.add(c);
        }
        return list;
    }

    public void printAllEmployee() {
        List<CollegeEmployee> allEmployee = this.getAllEmployee();
        System.out.println("学院员工");
        for (CollegeEmployee e : allEmployee) {
            System.out.print("学院员工id=" + e.getId());
        }
        System.out.println();
    }
}

class SchoolManager {

    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<>();

        for (int i = 0; i < 5; i++) {
            Employee e = new Employee();
            e.setId((long) i);
            list.add(e);
        }
        return list;
    }

    public void printAllEmployee(CollegeManager collegeManager) {
        collegeManager.printAllEmployee();
        System.out.println("学校总部员工");
        List<Employee> employees = this.getAllEmployee();
        for (Employee e : employees) {
            System.out.print("学校总部员工id=" + e.getId());
        }
    }
}

注意事项和细节

• 1.迪米特法则核心是降低类之间的耦合。
• 2.类与类之间存在必需的依赖，因此迪米特法则也只是要求降低类与类间(对象间)的耦合关系，不是要求完全没有依赖(完全没有依赖，也做不到)。
  只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。