我的车库里真的有一辆车吗？ [复制]

我是 Java 编程的新手，正在尝试掌握 OOP。

所以我构建了这个抽象类：

public abstract class Vehicle{....}

和2个子类：

public class Car extends Vehicle{....}
public class Boat extends Vehicle{....}

Car and Boat还包含一些不常见的独特字段和方法（没有相同的名称，因此我无法在 Vehicle 中为它们定义抽象方法）。

现在在 mainClass 中我已经设置了我的新车库：

Vehicle[] myGarage= new Vehicle[10];
myGarage[0]=new Car(2,true);
myGarage[1]=new Boat(4,600);

我对多态性非常满意，直到我尝试访问 Car 独有的字段之一，例如：

boolean carIsAutomatic = myGarage[0].auto;

编译器不接受这一点。我使用强制转换解决了这个问题：

boolean carIsAutomatic = ((Car)myGarage[0]).auto;

这可行......但它对方法没有帮助，只对字段有帮助。意思是我做不到

(Car)myGarage[0].doSomeCarStuff();

所以我的问题是——我的车库里到底有什么？我试图获得直觉并了解“幕后”发生的事情。

为了方便未来的读者，以下是答案的简短摘要：

1. 是的，有一个Car in myGarage[]
2. 作为一种静态类型语言，如果通过基于 Vehicle 超类的数据结构（例如Vehicle myGarage[])
3. As for how to solve, there are 2 main approaches below:
   1. 使用类型转换，这将减轻编译器的担忧并将设计中的任何错误留给运行时
   2. 我需要选角的事实表明设计有缺陷。如果我需要访问非车辆功能，那么我不应该将汽车和船只存储在基于车辆的数据结构中。要么使所有这些功能属于车辆，要么使用更具体（派生）的基于类型的结构
4. 在许多情况下，组合和/或接口将是继承的更好替代方案。可能是我下一个问题的主题......
5. 如果有人有时间浏览答案的话，还有许多其他好的见解。

如果您需要区分Car and Boat在你的车库里，那么你应该将它们存放在不同的结构中。

例如：

public class Garage {
    private List<Car> cars;
    private List<Boat> boats;
}

然后您可以定义特定于船只或特定于汽车的方法。

那为什么还要有多态性呢？

比方说Vehicle就好像：

public abstract class Vehicle {
   protected int price;
   public getPrice() { return price; }
   public abstract int getPriceAfterYears(int years);
}

Every Vehicle有一个价格，因此可以将其放入Vehicle抽象类。

然而，确定 n 年后价格的公式取决于车辆，因此由实现类来定义它。例如：

public Car extends Vehicle {
    // car specific
    private boolean automatic;
    @Override
    public getPriceAfterYears(int years) {
        // losing 1000$ every year
        return Math.max(0, this.price - (years * 1000));  
    }
}

The Boat类可能有其他定义getPriceAfterYears以及具体的属性和方法。

所以现在回到Garage类，您可以定义：

// car specific
public int numberOfAutomaticCars() {
    int s = 0;
    for(Car car : cars) {
        if(car.isAutomatic()) {
            s++;
        }
    }
    return s;
}
public List<Vehicle> getVehicles() {
    List<Vehicle> v = new ArrayList<>(); // init with sum
    v.addAll(cars);
    v.addAll(boats);
    return v;
}
// all vehicles method
public getAveragePriceAfterYears(int years) {
    List<Vehicle> vehicules = getVehicles();
    int s = 0;
    for(Vehicle v : vehicules) {
        // call the implementation of the actual type!
        s += v.getPriceAfterYears(years);  
    }
    return s / vehicules.size();
}

多态性的好处是能够调用getPriceAfterYears on a Vehicle without关心落实。

通常，向下转型是设计有缺陷的标志：如果您需要区分车辆的实际类型，请勿将车辆全部存放在一起。

注意：当然这里的设计可以很容易地改进。这只是一个证明要点的例子。