如何理解Java中的高内聚低耦合（案例学习）

待我称王封你为后i 2024-04-25 08:54 2阅读 0赞

> 【文章序言】：很高兴你能来阅读，博客分享日常编程，希望自己向着优秀程序员前行！  
>   
> 博客来源于项目以及编程中遇到的问题总结，偶尔会有读书分享，我会陆续更新Java前端、后台、数据库、项目案例等相关知识点总结，感谢你的阅读和关注，希望我的博客能帮助到更多的人，分享获取新知，大家一起进步!  
>   
> 吾等采石之人，应怀大教堂之心，愿我们奔赴在各自的热爱里…

### 概念学习 ###

![在这里插入图片描述][6f795e2ca29d444fae3673f790db115a.png]

高内聚低耦合是软件设计的一种原则，它指的是模块或类内部的元素之间应该紧密相关且相互依赖，而模块或类之间的依赖应该尽量减少。

**具体来说，在Java中，高内聚低耦合的原则有以下几个方面：**

1.  **高内聚**：模块或类内部的元素应该紧密相关，共同完成一项任务。具体来说，一个类应该只有一个明确的职责，而且该类的所有方法和属性都应该与该职责相关。如果一个类实现了多个不相关的功能，那么就表示它的内聚性较低。
2.  **低耦合**：模块或类之间的依赖应该尽量减少。具体来说，一个类应该尽量少依赖其他类或模块，它的功能应该尽量独立完成。如果一个类依赖很多其他类或模块，那么就表示它的耦合性较高。
3.  **接口隔离原则**：当一个接口太大时，它依赖的类也会受到较大的影响，因此应该将大接口拆分为多个小接口，让类只依赖它们所需的接口。

高内聚低耦合的好处是可以提高代码的可维护性、可读性和可测试性。高内聚的模块或类具有清晰的职责，易于理解和修改。低耦合的模块或类之间的依赖较少，修改一个模块或类不会对其他模块或类产生太大的影响。

--------------------

### 案例学习 ###

#### 案例1 ####

以下是一个简单的Java代码示例，展示了如何实现高内聚低耦合的原则：

// High cohesion
    public class Order {
        private int orderId;
        private String customerName;
        private List<Item> items;
    
        // Constructor, getter and setter methods...
    }
    
    public class Item {
        private int itemId;
        private String itemName;
        private double price;
    
        // Constructor, getter and setter methods...
    }
    
    // Low coupling
    public class OrderService {
        private Order order;
    
        public void createOrder(String customerName, List<Item> items) {
            order = new Order();
            order.setCustomerName(customerName);
            order.setItems(items);
            // Other logic to create order...
        }
    
        // Other methods that operate on the order...
    }
    
    public class ItemService {
        public double calculateTotalPrice(List<Item> items) {
            double totalPrice = 0;
            for (Item item : items) {
                totalPrice += item.getPrice();
            }
            return totalPrice;
        }
    
        // Other methods that operate on the items...
    }
    
    public class Main {
        public static void main(String[] args) {
            Item item1 = new Item(1, "Item 1", 10.0);
            Item item2 = new Item(2, "Item 2", 20.0);
    
            List<Item> items = new ArrayList<>();
            items.add(item1);
            items.add(item2);
    
            OrderService orderService = new OrderService();
            orderService.createOrder("John Doe", items);
    
            ItemService itemService = new ItemService();
            double totalPrice = itemService.calculateTotalPrice(items);
    
            System.out.println("Total price: " + totalPrice);
        }
    }

在这个例子中，Order类和Item类分别表示订单和订单项，它们具有高内聚：Order类负责管理订单信息，Item类负责管理订单项信息。OrderService类和ItemService类分别表示订单服务和订单项服务，它们具有低耦合：OrderService类只依赖Order类，ItemService类只依赖Item类。

**通过将相关的属性和方法放在同一个类中，并尽量减少类之间的依赖，我们实现了高内聚低耦合的原则。这样的设计使得代码更易于理解、修改和维护。**

--------------------

#### 案例2 ####

// 高内聚的例子
    
    // 类A负责处理用户登录逻辑
    class A {
        
        public void login(String username, String password) {
        
            // 处理登录逻辑
        }
    }
    
    // 低耦合的例子
    
    // 类B负责处理用户注册逻辑
    class B {
        
        public void register(String username, String password) {
        
            // 处理注册逻辑
        }
    }
    
    // 类C作为一个调度类，通过依赖注入的方式将A和B类注入进来
    class C {
        
        private A a;
        private B b;
    
        public C(A a, B b) {
        
            this.a = a;
            this.b = b;
        }
    
        public void processLoginAndRegister(String username, String password) {
        
            a.login(username, password);
            b.register(username, password);
        }
    }
    
    // 在使用C类时，我们可以通过依赖注入的方式将A和B类注入进来
    public class Main {
        
        public static void main(String[] args) {
        
            A a = new A();
            B b = new B();
    
            C c = new C(a, b);
    
            c.processLoginAndRegister("username", "password");
        }
    }

在上面的示例中，类A和类B分别负责用户登录和注册的逻辑。它们都具有高内聚，因为它们的方法都与其职责相关。

类C作为一个调度类，通过依赖注入的方式将A和B类注入进来。这样，C类可以调用A类和B类的方法，而不需要直接依赖于A类和B类的具体实现。这样做可以降低类C的耦合性，使得C类更加灵活和可扩展。

通过示例可以清楚地看出，高内聚和低耦合的设计原则使得代码更加清晰、可维护和可测试。

--------------------

#### 案例3 ####

// 低内聚示例
    
    class Customer {
        
        private String name;
        private String email;
        
        // 添加订单
        public void addOrder(Order order) {
        
            // ...
        }
        
        // 发送邮件给顾客
        public void sendEmail() {
        
            // ...
        }
        
        // 计算折扣价格
        public double calculateDiscount() {
        
            // ...
        }
        
        // 生成报告
        public void generateReport() {
        
            // ...
        }
    }

在上述代码中，`Customer` 类具有多个职责，包括添加订单、发送邮件、计算折扣价格和生成报告。这违反了高内聚原则，因为这些方法与 `Customer` 类的主要职责（即处理顾客信息）无关。

**改进后的代码示例**：

一个处理用户信息的类应该只负责处理用户信息的操作，而不应该涉及其他功能，如发送邮件、生成报告等，这些功能应该由其他类来负责。这样做可以实现高内聚低耦合的设计，使代码更加清晰、可维护和可扩展。

// 高内聚示例
    
    class Customer {
        
        private String name;
        private String email;
        
        public void addOrder(Order order) {
        
            // ...
        }
    }
    
    class EmailService {
        
        public void sendEmail() {
        
            // ...
        }
    }
    
    class DiscountCalculator {
        
        public double calculateDiscount() {
        
            // ...
        }
    }
    
    class ReportGenerator {
        
        public void generateReport() {
        
            // ...
        }
    }

在改进后的代码中，将 `Customer` 类中的不相关方法分别移动到了独立的类中，每个类都只负责一个明确的职责。`Customer` 类只关注顾客信息的处理，而与订单处理、邮件发送、折扣计算和报告生成等无关。

这样改进后的代码具有更高的内聚性，每个类都具有明确的职责，易于理解和维护。同时，各个类之间的依赖性也较低，修改其中一个类不会影响到其他类的功能。

--------------------

**遵循单一职责原则的好处包括：**

*  提高代码的内聚性和可读性，使代码更易于理解、维护和重用。
 *  降低代码的复杂度和耦合度，使代码更易于扩展和测试。
 *  当需求发生变化时，不会影响到不相关的功能，提高代码的灵活性。

**需要注意的是，单一职责原则并不是要求一个类只能有一个方法。相反，它强调的是一个类的功能和目的的一致性。一个类可以有多个方法，但它们应该属于同一个职责范围内的相关行为或操作。**

--------------------

📖☕️🌊📝📚🎩🚀  
📣非常感谢你阅读到这里，如果这篇文章对你有帮助，希望能留下你的点赞👍 关注❤️ 分享👥 留言💬thanks！！！

📚愿我们奔赴在各自的热爱里！

[6f795e2ca29d444fae3673f790db115a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/8b42ea57a1f0441cac2e8cdfeacde06a.png