共享对象与独立状态：Java 类设计技巧

本文旨在解决Java中一类常见的设计问题：如何在多个对象之间共享某些属性（如汽车的型号），同时保持其他属性（如油量）的独立性。通过区分“类别”和“实例”的概念，并使用组合关系，我们能够设计出更灵活且易于维护的类结构，从而避免共享对象状态带来的意外修改。

在面向对象编程中，正确地建模对象之间的关系至关重要。一个常见的问题是，如何在一个类的多个对象之间共享某些属性，同时保持其他属性的独立性。例如，我们可能希望多个 Person 对象共享同一个 Car 对象的型号信息，但每个 Person 对象的 Car 对象应该拥有独立的油量。直接共享 Car 对象会导致一个 Person 修改油量时，其他 Person 的 Car 对象油量也会随之改变，这通常不是我们期望的行为。

为了解决这个问题，我们需要区分“类别”和“实例”的概念。Car 可以表示一个汽车类别（例如“Ford100”），也可以表示一辆具体的汽车。汽车类别定义了所有该类别汽车的通用属性，而具体的汽车则拥有自己的独立属性。

因此，我们可以将 Car 类拆分为两个类：CarCategory 和 Car。CarCategory 类用于存储汽车的类别信息，如品牌和型号。Car 类则包含一个 CarCategory 对象的引用，以及汽车的独立属性，如油量和颜色。

以下是一个示例代码：

class CarCategory {
    String brand;
    String model;
    int maxVolume;

    public CarCategory(String brand, String model, int maxVolume) {
        this.brand = brand;
        this.model = model;
        this.maxVolume = maxVolume;
    }

    public String getModel() {
        return model;
    }
}

class Car {
    CarCategory category;
    String serialNumber;
    int volume;
    String color;

    public Car(CarCategory category, String serialNumber, int volume, String color) {
        this.category = category;
        this.serialNumber = serialNumber;
        this.volume = volume;
        this.color = color;
    }

    public void decreaseVolume() {
        this.volume--;
    }

    public int getVolume() {
        return volume;
    }

    public String getModel() {
        return category.getModel();
    }
}

class Person {
    String name;
    Car car;

    public Person(String name, Car car) {
        this.name = name;
        this.car = car;
    }

    public void drive() {
        car.decreaseVolume();
    }

    public int getCarVolume() {
        return car.getVolume();
    }
}

public class Main {
    public static void main(String[] args) {
        CarCategory ford100 = new CarCategory("Ford", "Ford100", 100);
        Car car1 = new Car(ford100, "SN123", 80, "Red");
        Car car2 = new Car(ford100, "SN456", 90, "Blue");

        Person p1 = new Person("Alice", car1);
        Person p2 = new Person("Bob", car2);

        System.out.println("Alice's car volume: " + p1.getCarVolume()); // Output: Alice's car volume: 80
        System.out.println("Bob's car volume: " + p2.getCarVolume());   // Output: Bob's car volume: 90

        p1.drive();

        System.out.println("Alice's car volume after driving: " + p1.getCarVolume()); // Output: Alice's car volume after driving: 79
        System.out.println("Bob's car volume after Alice driving: " + p2.getCarVolume());   // Output: Bob's car volume after Alice driving: 90
    }
}

在这个例子中，CarCategory 对象 ford100 被 car1 和 car2 共享，但 car1 和 car2 各自拥有独立的油量。当 Alice 驾驶她的汽车时，只有 Alice 的汽车油量会减少，而 Bob 的汽车油量不会受到影响。

注意事项：

• 不可变性： 如果 CarCategory 对象的属性在创建后不应该被修改，可以将其设置为不可变的。
• 关系方向： 在这个例子中，Person 对象拥有一个 Car 对象的引用。也可以反过来，让 Car 对象拥有一个 Person 对象的引用，表示汽车的所有者。根据实际需求选择合适的关系方向。
• 集合： 如果一个人可以拥有多辆汽车，可以将 Person 类中的 Car car 字段改为 List cars。

总结：

通过区分“类别”和“实例”的概念，并使用组合关系，我们可以设计出更灵活且易于维护的类结构。这种设计模式可以避免共享对象状态带来的意外修改，并提高代码的可读性和可维护性。在实际应用中，需要根据具体需求选择合适的设计方案。例如，如果需要支持汽车改装，可能需要更复杂的设计，例如克隆 CarCategory 对象。