Java面向对象设计原则之迪米特法则介绍

什么是迪米特法则

迪米特法则（Law of Demeter）又称最少知道原则（Least Knowledge Principle，简称 LKP），是指一个对象应该对其他对象保持最少的了解，使得系统的各个部分易于独立地修改、扩展、替换。迪米特法则强调了类之间的松耦合，减少了依赖，使得高层模块不依赖于底层模块的实现细节，从而提高了系统的可维护性、可扩展性和可复用性。

迪米特法则的具体内容是：一个对象应该对其他对象有尽可能少的了解，不和其他对象直接对话，而是尽可能通过中间对象进行间接沟通。

迪米特法则的优点

迪米特法则的优点主要体现在以下几个方面：

1. 降低了类之间的耦合性。由于对象之间的交互都是通过中介者进行的，因此各个对象之间的耦合度降低了，可以更加灵活地进行修改、扩展和替换。

2. 提高了代码的复用性。由于各个对象之间的耦合度降低了，因此每个对象都可以更加独立地运作，这样就可以将其复用到其他系统中，提高了代码的复用性。

3. 提高了系统的可维护性。由于各个对象之间的耦合度降低了，系统的维护也更加容易了，可以更加方便地进行单元测试、模块化编程等。

迪米特法则的实现方式

迪米特法则的实现需要遵循以下几个原则：

1. 尽量面向接口编程。通过面向接口编程，可以降低类之间的耦合度，达到类之间松耦合的目的。

2. 尽量少使用 public 方法。如果一个方法是 public 的，那么它就可以被其它对象直接调用，从而增加了对象之间的耦合度。因此，应该尽量减少 public 方法的使用。

3. 尽量不要在类的内部直接访问其它对象的属性。通过调用该对象的方法来获取其属性值，可以达到降低耦合度的目的。

迪米特法则的示例说明

例 1：飞机出租和购买

假设有一个飞机租赁公司，顾客可以租赁或者购买飞机。现在需要实现一个订购飞机的系统，这个系统包括创建订单、支付订单、生成发票等功能。

根据迪米特法则，我们应该尽量降低对象之间的耦合度。因此，我们可以将各个对象封装起来，让它们之间少有直接的交互。

以下是一个可能的实现示例：

public class Customer {
    private String name;
    private RentPlane rentPlane;
    private BuyPlane buyPlane;

    public Customer(String name) {
        this.name = name;
        this.rentPlane = new RentPlane();
        this.buyPlane = new BuyPlane();
    }

    public void rentPlane() {
        this.rentPlane.rent();
    }

    public void buyPlane() {
        this.buyPlane.buy();
    }
}

public class RentPlane {
    public void rent() {
        // rent the plane
    }
}

public class BuyPlane {
    public void buy() {
        // buy the plane
    }
}

在这个示例中，我们创建了一个顾客类，这个顾客类可以租赁或购买飞机。在顾客类的构造函数中，我们创建了租赁和购买飞机的实例。当顾客需要租赁或购买飞机时，只需要调用相应的方法即可。

例 2：为别人整理书籍

假设你的朋友有很多书籍，他希望你能够帮他整理一下，把它们分成不同的类别，并放在不同的书架上。你应该如何实现呢？

根据迪米特法则，我们应该尽量降低对象之间的耦合度。因此，在实现过程中，我们应该注重对象之间的分离。

以下是一个可能的实现示例：

public class Book {
    private String name;
    private String category;

    public Book(String name, String category) {
        this.name = name;
        this.category = category;
    }

    public String getCategory() {
        return category;
    }
}

public class BookShelf {
    private String name;
    private List<Book> books;

    public BookShelf(String name) {
        this.name = name;
        this.books = new ArrayList<>();
    }

    public void addBook(Book book) {
        this.books.add(book);
    }

    public List<Book> getBooks() {
        return books;
    }
}

public class Friend {
    private String name;
    private List<Book> books;

    public Friend(String name) {
        this.name = name;
        this.books = new ArrayList<>();
    }

    public void addBook(Book book) {
        this.books.add(book);
    }

    public void arrangeBooks() {
        Map<String, BookShelf> categoryMap = new HashMap<>();

        // 遍历所有书籍，将它们进行分类
        for (Book book : this.books) {
            String category = book.getCategory();
            BookShelf bookShelf = categoryMap.get(category);

            if (bookShelf == null) {
                bookShelf = new BookShelf(category);
                categoryMap.put(category, bookShelf);
            }
            bookShelf.addBook(book);
        }

        // 打印每一种类别书籍的数量
        for (Map.Entry<String, BookShelf> entry : categoryMap.entrySet()) {
            String category = entry.getKey();
            List<Book> books = entry.getValue().getBooks();
            System.out.println(category + " 书籍数量： " + books.size());
        }
    }
}

在这个示例中，我们创建了一个 Book 类，这个类包含书籍的名称和分类。我们还创建了一个 BookShelf 类，这个类包含书架的名称和书籍列表。最后，我们创建了一个 Friend 类，这个类包含朋友的名称和书籍列表。在 ArrageBooks 方法中，我们遍历了所有的书籍，将它们都进行分类，并放在相应的书架上。最后，我们打印了每一种类别书籍的数量。