高内聚低耦合举个例子详细介绍

学习目标：

• 高内聚低耦合举个例子详细介绍

---

学习内容：

高内聚和低耦合是软件设计中的两个重要原则，旨在提高系统的可维护性、可扩展性和灵活性。下面我们通过一个例子详细介绍高内聚和低耦合的概念及其实现方法。

例子：在线购物系统

场景描述
假设我们正在设计一个在线购物系统，该系统包括以下功能：

• 用户管理
• 商品管理
• 订单处理
• 支付处理

高内聚
高内聚指的是类或模块内部的元素紧密相关，共同完成一个单一的任务或功能。内聚性越高，类或模块的职责越单一，代码的可理解性和可维护性就越高。

示例：订单类
订单类负责管理与订单相关的所有功能，如添加商品、计算总价等。

// 商品类
public class Product {
    private String id;
    private String name;
    private double price;

    public Product(String id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

// 订单项类
public class OrderItem {
    private Product product;
    private int quantity;

    public OrderItem(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
    }

    public Product getProduct() {
        return product;
    }

    public int getQuantity() {
        return quantity;
    }

    public double getItemTotal() {
        return product.getPrice() * quantity;
    }
}

// 订单类
import java.util.ArrayList;
import java.util.List;

public class Order {
    private List<OrderItem> items;

    public Order() {
        items = new ArrayList<>();
    }

    public void addItem(Product product, int quantity) {
        OrderItem item = new OrderItem(product, quantity);
        items.add(item);
    }

    public double calculateTotal() {
        double total = 0;
        for (OrderItem item : items) {
            total += item.getItemTotal();
        }
        return total;
    }
}

在这个示例中，Order类高度内聚，因为它负责与订单相关的所有操作：添加商品和计算总价。OrderItem类和Product类分别负责订单项和商品的信息，职责单一明确。

低耦合
低耦合指的是类或模块之间的依赖关系尽量松散，减少相互之间的直接依赖。耦合度越低，系统的灵活性和可维护性就越高。

示例：支付处理
在支付处理中，我们可以通过接口和抽象类来实现低耦合，使得系统可以轻松扩展不同的支付方式。

// 支付策略接口
public interface PaymentStrategy {
    void pay(double amount);
}

// 信用卡支付实现
public class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;

    public CreditCardPayment(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(double amount) {
        // 信用卡支付逻辑
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

// 支付宝支付实现
public class AlipayPayment implements PaymentStrategy {
    private String alipayId;

    public AlipayPayment(String alipayId) {
        this.alipayId = alipayId;
    }

    @Override
    public void pay(double amount) {
        // 支付宝支付逻辑
        System.out.println("Paid " + amount + " using Alipay.");
    }
}

// 订单类中的支付处理
public class Order {
    private List<OrderItem> items;
    private PaymentStrategy paymentStrategy;

    public Order() {
        items = new ArrayList<>();
    }

    public void addItem(Product product, int quantity) {
        OrderItem item = new OrderItem(product, quantity);
        items.add(item);
    }

    public double calculateTotal() {
        double total = 0;
        for (OrderItem item : items) {
            total += item.getItemTotal();
        }
        return total;
    }

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void pay() {
        double amount = calculateTotal();
        paymentStrategy.pay(amount);
    }
}

在这个示例中，PaymentStrategy接口定义了支付策略，而具体的支付方式（如信用卡支付和支付宝支付）通过实现这个接口来定义各自的支付逻辑。Order类通过设置支付策略来完成支付处理，而无需了解具体的支付实现。这种设计降低了类之间的耦合度，使得添加新的支付方式变得简单而不影响现有代码。

总结

通过高内聚和低耦合的设计，我们可以创建一个更清晰、更易维护、更灵活的系统。高内聚确保类或模块职责单一，代码更易理解和维护；低耦合通过减少类或模块之间的依赖关系，提高系统的可扩展性和灵活性。这两个原则在软件设计中相辅相成，帮助我们构建健壮的系统。

---