UML类图（Java相关）：虚线与点线的区别

假设你指的是单向关联和双向关联（UML类图中最常被对比的两种关联类型），二者存在明确差异，以下是具体说明及对应Java实现：

核心差异 #

Java示例代码 #

1. 单向关联 #

以「客户知道自己的订单，但订单不知道所属客户」为例：

import java.util.ArrayList;
import java.util.List;

// 订单类
public class Order {
    private String orderId;
    private double amount;

    public Order(String orderId, double amount) {
        this.orderId = orderId;
        this.amount = amount;
    }

    // 仅提供必要的getter方法
    public String getOrderId() {
        return orderId;
    }

    public double getAmount() {
        return amount;
    }
}

// 客户类（单向关联Order）
public class Customer {
    private String customerName;
    private List<Order> orders;

    public Customer(String customerName) {
        this.customerName = customerName;
        this.orders = new ArrayList<>();
    }

    public void addOrder(Order order) {
        orders.add(order);
    }

    public void displayOrders() {
        System.out.println(customerName + "的订单列表：");
        for (Order order : orders) {
            System.out.printf("订单ID：%s，金额：%.2f\n", order.getOrderId(), order.getAmount());
        }
    }

    public static void main(String[] args) {
        Order laptopOrder = new Order("O2024001", 4999.0);
        Order phoneOrder = new Order("O2024002", 2999.0);
        
        Customer alice = new Customer("Alice");
        alice.addOrder(laptopOrder);
        alice.addOrder(phoneOrder);
        
        alice.displayOrders();
        // 此处Order无法访问Customer，因为是单向关联
    }
}

2. 双向关联 #

修改上述场景，让「订单也知道所属客户」：

import java.util.ArrayList;
import java.util.List;

// 客户类
public class Customer {
    private String customerName;
    private List<Order> orders;

    public Customer(String customerName) {
        this.customerName = customerName;
        this.orders = new ArrayList<>();
    }

    public void addOrder(Order order) {
        // 添加订单时同步设置订单的所属客户，维护双向关联的一致性
        order.setCustomer(this);
        orders.add(order);
    }

    public String getCustomerName() {
        return customerName;
    }

    public void displayOrders() {
        System.out.println(customerName + "的订单列表：");
        for (Order order : orders) {
            System.out.printf("订单ID：%s，金额：%.2f\n", order.getOrderId(), order.getAmount());
        }
    }
}

// 订单类（双向关联Customer）
public class Order {
    private String orderId;
    private double amount;
    private Customer customer;

    public Order(String orderId, double amount) {
        this.orderId = orderId;
        this.amount = amount;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    public void displayCustomerInfo() {
        System.out.printf("订单%s的所属客户：%s\n", orderId, customer.getCustomerName());
    }

    public String getOrderId() {
        return orderId;
    }

    public double getAmount() {
        return amount;
    }

    public static void main(String[] args) {
        Customer bob = new Customer("Bob");
        Order bookOrder = new Order("O2024003", 89.0);
        Order penOrder = new Order("O2024004", 19.9);
        
        bob.addOrder(bookOrder);
        bob.addOrder(penOrder);
        
        bob.displayOrders();
        // 订单可以访问所属客户信息
        bookOrder.displayCustomerInfo();
        penOrder.displayCustomerInfo();
    }
}

额外提醒 #

双向关联容易引发循环引用问题（比如序列化、JSON转换时可能出错），实际开发中应优先使用单向关联降低耦合，仅在业务逻辑确实需要双向交互时才使用双向关联。

内容的提问来源于stack exchange，提问作者SKS