要回答你的问题，你可以找到你的车库里到底有什么，你可以做下面的事情:

Vehicle v = myGarage[0];

if (v instanceof Car) {
   // This vehicle is a car
   ((Car)v).doSomeCarStuff();
} else if(v instanceof Boat){
   // This vehicle is a boat
   ((Boat)v).doSomeBoatStuff();
}

更新:正如你可以从下面的评论中读到的，这种方法对于简单的解决方案是可以的，但它不是一个好的实践，特别是如果你的车库里有大量的车辆。所以，只有在你知道车库不会太大的情况下才使用它。如果不是这样，在堆栈溢出时搜索“avoid instanceof”，有多种方法可以做到这一点。

如果你需要在车库中区分Car和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);
}

每个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));  
    }
}

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而不关心实现。

通常，下倾是设计缺陷的标志:如果需要区分车辆的实际类型，请不要将所有车辆存储在一起。

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

你的车库包含车辆，所以编译器静态控制视图中你有一个车辆，因为。auto是一个Car字段，你不能访问它，动态地它是一个Car，所以转换不会产生一些问题，如果它是一个船，你试图将转换为Car会在运行时引发异常。

你问管家:

吉夫斯，还记得我在爪哇岛的车库吗?去看看第一辆停在那里的车是不是自动挡的。

懒惰的吉夫斯说:

但是，先生，如果这是一辆既不能自动也不能非自动的车呢?

这是所有。

好吧，这还不是全部，因为现实中更多的是鸭子类型而不是静态类型。这就是为什么我说吉夫斯很懒。

要回答你的问题，你可以找到你的车库里到底有什么，你可以做下面的事情:

Vehicle v = myGarage[0];

if (v instanceof Car) {
   // This vehicle is a car
   ((Car)v).doSomeCarStuff();
} else if(v instanceof Boat){
   // This vehicle is a boat
   ((Boat)v).doSomeBoatStuff();
}

更新:正如你可以从下面的评论中读到的，这种方法对于简单的解决方案是可以的，但它不是一个好的实践，特别是如果你的车库里有大量的车辆。所以，只有在你知道车库不会太大的情况下才使用它。如果不是这样，在堆栈溢出时搜索“avoid instanceof”，有多种方法可以做到这一点。

如果对基类型进行操作，则只能访问它的公共方法和字段。

如果你想访问扩展类型，但有一个基类型的字段存储它(在你的情况下)，你首先必须强制转换它，然后你可以访问它:

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

或更短，没有温度字段:

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

由于您使用的是Vehicle对象，所以只能从它们的基类调用方法，而不能强制转换。因此，对于车库来说，最好区分不同数组(或者更好的列表)中的对象——数组通常不是一个好主意，因为它在处理方面远不如基于collection的类灵活。