迪米特法则

迪米特法则

什么是迪米特法则

迪米特法则（Law of Demeter，LoD）也称为最少知识原则，是一种面向对象的设计原则，其核心思想是：一个对象应该对其他对象有最少的了解。具体来说，一个对象应当只与它的直接朋友（即成员变量、方法的参数、返回值）交流，不与陌生的对象通信。这样做可以降低类之间的耦合度，提高系统的可维护性和可扩展性。

迪米特法则(LoD)也叫最少知识原则

迪米特法则(LoD),如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用

迪米特法则首先强调的前提是在类的结构设计上，每一个类都应当尽量降低成员的访问权限,也就是说，一个类包装好自己的private状态，不需要让别的类知道的字段或行为就不要公开

迪米特法则其根本思想，是强调了类之间的松耦合

我们在程序设计时，类之间的耦合越弱，越有利于复用，一个处在弱耦合的类被修改，不会对有关系的类造成波及。也就是说，信息的隐藏促进了软件的复用

示例

以下是一个使用迪米特法则编写的 Java 示例，以模拟一个简单的图书馆借阅系统。我们将遵循以下原则：

• 图书馆用户（User）只知道图书（Book）的标题，不知道具体的借阅操作。
• 用户只知道图书管理员（Librarian），通过管理员进行借书和还书操作。
• 图书管理员负责管理图书库存（BookInventory），但不知道具体的用户操作。

1. 定义 Book 类：

public class Book {
    private String title;

    public Book(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }
}

2. 定义 BookInventory 类：

import java.util.HashMap;
import java.util.Map;

public class BookInventory {
    private Map<String, Book> books;

    public BookInventory() {
        books = new HashMap<>();
    }

    public void addBook(Book book) {
        books.put(book.getTitle(), book);
    }

    public boolean hasBook(String title) {
        return books.containsKey(title);
    }

    public void removeBook(String title) {
        books.remove(title);
    }

    public Book borrowBook(String title) {
        if (!hasBook(title)) {
            throw new IllegalArgumentException("The book is not available.");
        }
        Book borrowedBook = books.get(title);
        books.remove(title);
        return borrowedBook;
    }

    public void returnBook(Book book) {
        books.put(book.getTitle(), book);
    }
}

3. 定义 Librarian 类：

public class Librarian {
    private BookInventory inventory;

    public Librarian(BookInventory inventory) {
        this.inventory = inventory;
    }

    public Book borrowBook(String title, User user) {
        Book book = inventory.borrowBook(title);
        user.borrowedBook(book);
        return book;
    }

    public void returnBook(Book book, User user) {
        inventory.returnBook(book);
        user.returnedBook(book);
    }
}

4. 定义 User 类：

public class User {
    // 借书
    public void borrowedBook(Book book) {
        System.out.println("User borrowed the book: " + book.getTitle());
    }

    // 还书
    public void returnedBook(Book book) {
        System.out.println("User returned the book: " + book.getTitle());
    }
}

5. 客户端代码：

public class LibraryDemo {
    public static void main(String[] args) {
        BookInventory inventory = new BookInventory();
        inventory.addBook(new Book("Design Patterns"));
        inventory.addBook(new Book("Clean Code"));

        Librarian librarian = new Librarian(inventory);
        User user = new User();

        Book borrowedBook = librarian.borrowBook("Design Patterns", user);
        System.out.println("\n---\n");
        librarian.returnBook(borrowedBook, user);
    }
}

在这个示例中，我们遵循了迪米特法则：

• 用户只知道图书的标题，不知道具体的借阅操作。
• 用户通过图书管理员进行借书和还书操作，不直接与图书库存交互。
• 图书管理员负责管理图书库存，但不知道具体的用户操作。
• 通过这种方式，各组件之间的耦合度较低，系统更易于维护和扩展。