Java 面向对象设计：如何写出高内聚、低耦合的代码？

在Java开发中，高内聚、低耦合是面向对象设计的核心原则之一。高内聚意味着模块内部的元素紧密相关，低耦合则意味着模块之间的依赖关系尽可能少。遵循这一原则，不仅可以提高代码的可维护性，还能降低系统的复杂性。本文将通过代码示例，深入探讨如何在实际开发中实现高内聚、低耦合的设计。

为什么需要高内聚、低耦合？

在实际开发中，代码的复杂性往往是导致项目难以维护的主要原因。如果模块之间的依赖关系过于紧密，任何一处修改都可能引发连锁反应，导致系统崩溃。而高内聚、低耦合的设计可以有效解决这一问题。

1. 高内聚的好处
   高内聚的模块专注于单一职责，代码逻辑清晰，便于理解和维护。例如，一个负责计算图书价格的模块，只包含与价格计算相关的逻辑，而不涉及库存管理或用户通知。

2. 低耦合的好处
   低耦合的模块之间依赖关系松散，修改一个模块时，不会轻易影响到其他模块。例如，图书管理系统中，库存模块和订单模块可以独立开发和测试，而不需要彼此依赖。

高内聚、低耦合的设计原则

单一职责原则（SRP）

单一职责原则要求一个类只负责一个功能领域中的相应职责。这是实现高内聚的基础。

问题场景
假设我们有一个BookManager类，它既负责计算图书价格，又负责生成订单和发送通知。这种设计显然违背了单一职责原则。

public class BookManager {
    public double calculatePrice(Book book) {
        // 计算价格的逻辑
        return book.getPrice() * 0.9;
    }

    public void generateOrder(Book book, int quantity) {
        // 生成订单的逻辑
        System.out.println("生成订单：" + book.getTitle() + " 数量：" + quantity);
    }

    public void sendNotification(String message) {
        // 发送通知的逻辑
        System.out.println("发送通知：" + message);
    }
}

改进方案
将不同职责拆分为独立的类，每个类只负责一个功能。

// 计算价格的类
public class PriceCalculator {
    public double calculatePrice(Book book) {
        return book.getPrice() * 0.9;
    }
}

// 生成订单的类
public class OrderGenerator {
    public void generateOrder(Book book, int quantity) {
        System.out.println("生成订单：" + book.getTitle() + " 数量：" + quantity);
    }
}

// 发送通知的类
public class NotificationService {
    public void sendNotification(String message) {
        System.out.println("发送通知：" + message);
    }
}

开闭原则（OCP）

开闭原则要求软件实体应该对扩展开放，对修改关闭。通过抽象和接口，可以实现这一原则。

问题场景
假设我们有一个DiscountCalculator类，用于计算不同类型的折扣。如果每次新增折扣类型都需要修改类的代码，这显然违背了开闭原则。

public class DiscountCalculator {
    public double calculateDiscount(Book book, String discountType) {
        if ("STUDENT".equals(discountType)) {
            return book.getPrice() * 0.8;
        } else if ("SENIOR".equals(discountType)) {
            return book.getPrice() * 0.7;
        }
        return book.getPrice();
    }
}

改进方案
通过接口和多态，将折扣逻辑抽象化，新增折扣类型时无需修改现有代码。

// 抽象折扣接口
public interface DiscountStrategy {
    double calculateDiscount(Book book);
}

// 学生折扣实现
public class StudentDiscount implements DiscountStrategy {
    @Override
    public double calculateDiscount(Book book) {
        return book.getPrice() * 0.8;
    }
}

// 老年折扣实现
public class SeniorDiscount implements DiscountStrategy {
    @Override
    public double calculateDiscount(Book book) {
        return book.getPrice() * 0.7;
    }
}

// 折扣计算器
public class DiscountCalculator {
    private DiscountStrategy strategy;

    public DiscountCalculator(DiscountStrategy strategy) {
        this.strategy = strategy;
    }

    public double calculateDiscount(Book book) {
        return strategy.calculateDiscount(book);
    }
}

依赖倒置原则（DIP）

依赖倒置原则要求高层模块不应该依赖低层模块，两者都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象。

问题场景
假设我们有一个BookService类，它直接依赖于具体的Database类。这种设计导致BookService无法轻松切换到其他数据源。

public class BookService {
    private Database database;

    public BookService() {
        this.database = new Database();
    }

    public void save(Book book) {
        database.save(book);
    }
}

改进方案
通过接口抽象数据源，让BookService依赖于接口而非具体实现。

// 数据源接口
public interface DataSource {
    void save(Book book);
}

// 数据库实现
public class Database implements DataSource {
    @Override
    public void save(Book book) {
        System.out.println("保存到数据库：" + book.getTitle());
    }
}

// 文件实现
public class FileStorage implements DataSource {
    @Override
    public void save(Book book) {
        System.out.println("保存到文件：" + book.getTitle());
    }
}

// 书籍服务类
public class BookService {
    private DataSource dataSource;

    public BookService(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void save(Book book) {
        dataSource.save(book);
    }
}

实践中的注意事项

1. 避免过度设计
   虽然高内聚、低耦合是理想状态，但在实际开发中，过度设计可能导致代码复杂化。应在设计和实现之间找到平衡。

2. 使用设计模式
   设计模式是实现高内聚、低耦合的有效工具。例如，工厂模式、策略模式等都可以帮助我们构建灵活的系统。

3. 持续重构
   代码设计不是一蹴而就的，需要在开发过程中不断优化。通过重构，可以逐步提高代码的内聚性和降低耦合度。

总结

高内聚、低耦合是Java面向对象设计的核心原则，它能帮助我们构建更灵活、更可维护的系统。通过遵循单一职责原则、开闭原则和依赖倒置原则，我们可以在实际开发中实现这一目标。记住，设计的最终目的是服务于业务需求，而不是追求完美。希望本文的代码示例和设计思路能为你提供一些启发！