Java中如何处理抽象属性？车辆类设计的方案抉择问询

嘿，这个问题挺典型的——本质上是在处理不同类型对象的差异化行为，既要避免给摩托车加无意义的getSteeringWheel方法，又不想写一堆繁琐的类型判断。咱们一步步来拆解分析：

先聊聊你提出的两个方案 #

方案1：抽象Vehicle+子类继承 #

• 优点：完全符合面向对象的单一职责原则，Car和Motorcycle各自只实现自己该有的方法，不会出现“摩托车有方向盘方法”这种逻辑矛盾的情况，类的职责清晰。
• 缺点：确实，每次获取方向盘都要写instanceof判断+强转，代码显得啰嗦，而且如果后续要加更多差异化操作（比如获取汽车的安全带、摩托车的头盔），这种判断会越来越多，维护起来很麻烦。

方案2：单一Vehicle类+类型枚举 #

• 优点：调用时只需要判断枚举类型，不用强转，看起来代码简洁一点。
• 缺点：这个设计完全违背了接口隔离原则和单一职责原则——摩托车类型的Vehicle对象带着一个毫无意义的getSteeringWheel方法，不仅容易让调用者误解（以为所有交通工具都有方向盘），后续如果新增自行车、卡车等类型，这个类会越来越臃肿，变成一个大杂烩，迟早会踩维护的大坑。

方案对比结论 #

方案1比方案2要优得多，因为它的设计符合面向对象的核心原则，只是有instanceof的小问题；而方案2的设计缺陷是根本性的，后续维护成本会极高，绝对不推荐。

更优雅的替代方案 #

方案3：Optional+抽象类默认方法（Java 8+适用） #

如果你的场景比较简单，这是最简洁的解决方式。我们可以在抽象Vehicle类里定义一个默认的getSteeringWheel方法，返回Optional.empty()，然后让Car重写这个方法返回实际的方向盘：

abstract class Vehicle {
    // 默认实现：没有方向盘，返回空Optional
    public Optional<SteeringWheel> getSteeringWheel() {
        return Optional.empty();
    }
}

class Car extends Vehicle {
    private SteeringWheel steeringWheel;

    @Override
    public Optional<SteeringWheel> getSteeringWheel() {
        return Optional.ofNullable(steeringWheel);
    }
}

class Motorcycle extends Vehicle {
    // 不用重写，继承默认的空实现即可
}

使用的时候也很优雅，直接通过Optional的方法处理空值：

Vehicle vehicle = getVehicle();
// 如果有方向盘就执行逻辑，没有就跳过
vehicle.getSteeringWheel().ifPresent(steeringWheel -> {
    // 处理方向盘的业务逻辑
});

这种方式既避免了给摩托车加无意义的方法，又不用写instanceof判断，调用者通过Optional也能清晰知道这个方法可能返回空，从根源上避免空指针异常。

方案4：访问者模式（适合复杂场景） #

如果后续需要给不同交通工具添加很多差异化操作（比如不仅要获取方向盘，还要处理汽车的加油、摩托车的换机油等），访问者模式会是更好的选择，它能彻底消除instanceof判断，同时符合开闭原则（新增类型或操作时不用修改原有代码）。

具体实现步骤：

1. 定义访问者接口，针对不同交通工具类型定义方法：

interface VehicleVisitor {
    void visitCar(Car car);
    void visitMotorcycle(Motorcycle motorcycle);
}

2. 在抽象Vehicle类中添加accept方法，让子类实现：

abstract class Vehicle {
    public abstract void accept(VehicleVisitor visitor);
}

3. Car和Motorcycle实现accept方法：

class Car extends Vehicle {
    private SteeringWheel steeringWheel;

    public SteeringWheel getSteeringWheel() {
        return steeringWheel;
    }

    @Override
    public void accept(VehicleVisitor visitor) {
        visitor.visitCar(this);
    }
}

class Motorcycle extends Vehicle {
    @Override
    public void accept(VehicleVisitor visitor) {
        visitor.visitMotorcycle(this);
    }
}

4. 实现一个获取方向盘的访问者：

class SteeringWheelVisitor implements VehicleVisitor {
    private SteeringWheel steeringWheel;

    @Override
    public void visitCar(Car car) {
        this.steeringWheel = car.getSteeringWheel();
    }

    @Override
    public void visitMotorcycle(Motorcycle motorcycle) {
        // 摩托车没有方向盘，这里可以什么都不做，或者根据业务抛出异常
    }

    public SteeringWheel getSteeringWheel() {
        return steeringWheel;
    }
}

5. 使用时无需类型判断：

Vehicle vehicle = getVehicle();
SteeringWheelVisitor visitor = new SteeringWheelVisitor();
vehicle.accept(visitor);
SteeringWheel steeringWheel = visitor.getSteeringWheel();
// 根据业务处理steeringWheel为空的情况

这种方式的好处是，后续新增交通工具类型（比如Truck）或新增操作（比如获取后备箱），只需要扩展访问者接口和对应子类，不用修改原有代码，扩展性极强。

最终建议 #

• 如果你的业务场景比较简单，只需要处理方向盘这一个差异化属性，优先选方案3，代码简洁易读，维护成本低。
• 如果后续有大量差异化操作需要扩展，选方案4，它能让代码结构更清晰，扩展性更好。
• 绝对不要选方案2，它的设计会给后续维护埋下无数坑。

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