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

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

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

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

这是应用访问者设计模式的好地方。

这种模式的美妙之处在于，您可以在一个超类的不同子类上调用不相关的代码，而不必到处执行奇怪的强制转换，也不必在超类中放入大量不相关的方法。

这是通过创建一个Visitor对象并允许我们的Vehicle类接受()访问者来实现的。

您还可以创建许多类型的Visitor，并使用相同的方法调用不相关的代码，只是不同的Visitor实现，这使得这种设计模式在创建干净的类时非常强大。

举个例子:

public class VisitorDemo {

    // We'll use this to mark a class visitable.
    public static interface Visitable {

        void accept(Visitor visitor);
    }

    // This is the visitor
    public static interface Visitor {

        void visit(Boat boat);

        void visit(Car car);

    }

    // Abstract
    public static abstract class Vehicle implements Visitable {

            // NO OTHER RANDOM ABSTRACT METHODS!

    }

    // Concrete
    public static class Car extends Vehicle {

        public void doCarStuff() {
            System.out.println("Doing car stuff");
        }

        @Override
        public void accept(Visitor visitor) {
            visitor.visit(this);
        }

    }

    // Concrete
    public static class Boat extends Vehicle {

        public void doBoatStuff() {
            System.out.println("Doing boat stuff");
        }

        @Override
        public void accept(Visitor visitor) {
            visitor.visit(this);
        }

    }

    // Concrete visitor
    public static class StuffVisitor implements Visitor {

        @Override
        public void visit(Boat boat) {
            boat.doBoatStuff();
        }

        @Override
        public void visit(Car car) {
            car.doCarStuff();
        }
    }

    public static void main(String[] args) {
        // Create our garage
        Vehicle[] garage = {
            new Boat(),
            new Car(),
            new Car(),
            new Boat(),
            new Car()
        };

        // Create our visitor
        Visitor visitor = new StuffVisitor();

        // Visit each item in our garage in turn
        for (Vehicle v : garage) {
            v.accept(visitor);
        }
    }

}

如您所见，StuffVisitor允许您在Boat或Car上调用不同的代码，这取决于调用哪个访问实现。您还可以创建Visitor的其他实现，以使用相同的.visit()模式调用不同的代码。

还要注意，使用此方法时，不使用instanceof或任何hack类检查。类之间唯一重复的代码是方法void accept(Visitor)。

例如，如果你想支持3种类型的具体子类，你也可以将该实现添加到Visitor接口中。

创建车辆级别字段，这将有助于使每个单独的车辆更加独特。

public abstract class Vehicle {
    public final boolean isCar;
    public final boolean isBoat;

    public Vehicle (boolean isCar, boolean isBoat) {
        this.isCar  = isCar;
        this.isBoat = isBoat;
    }
}

将继承类中的Vehicle level字段设置为适当的值。

public class Car extends Vehicle {
    public Car (...) {
        super(true, false);
        ...
    }
}

public class Boat extends Vehicle {
    public Boat (...) {
        super(false, true);
        ...
    }
}

实现使用车辆级别字段正确地破译车辆类型。

boolean carIsAutomatic = false;

if (myGarage[0].isCar) {
    Car car = (Car) myGarage[0];
    car.carMethod();
    carIsAutomatic = car.auto;
}

else if (myGarage[0].isBoat) {
    Boat boat = (Boat) myGarage[0];
    boat.boatMethod();
}

因为你告诉编译器车库中的所有东西都是Vehicle，所以你只能使用Vehicle类级别的方法和字段。如果你想正确地破译车辆类型，那么你应该设置一些类级别的字段，例如isCar和isBoat，这将使你的程序员更好地理解你正在使用的车辆类型。

Java是一种类型安全的语言，所以在处理像Boats和Cars这样已转换的数据之前，最好总是进行类型检查。

You defined that your garage will store vehicles, so you do not care what type of vehicles you have. The vehicles have common features like engine, wheel, behavior like moving. The actual representation of these features might be different, but at abstract layer are the same. You used abstract class which means that some attributes, behaviors are exactly the same by both vehicle. If you want to express that your vehicles have common abstract features then use interface like moving might mean different by car and boat. Both can get from point A to point B, but in a different way (on wheel or on water - so the implementation will be different) So you have vehicles in the garage which behave the same way and you do not car about the specific features of them.

回答评论:

接口是指描述如何与外部世界通信的契约。在合同中，你定义了你的车辆可以移动，可以操纵，但你没有描述它实际是如何工作的，它是在实现中描述的。通过抽象类，你可能有共享某些实现的函数，但你也有不知道如何实现的函数。

一个使用抽象类的例子:

    abstract class Vehicle {

    protected abstract void identifyWhereIAm();
    protected abstract void startEngine();
    protected abstract void driveUntilIArriveHome();
    protected abstract void stopEngine();

    public void navigateToHome() {
        identifyWhereIAm();
        startEngine();
        driveUntilIArriveHome();
        stopEngine();
    } 
}

每辆车都将使用相同的步骤，但步骤的实现将因车辆类型而异。汽车可能会使用GPS，船只可能会使用声纳来确定它的位置。

你在这里的问题是在一个更基本的层面上:你以这样一种方式构建了Vehicle，车库需要了解更多关于它的对象的信息，而不是Vehicle接口所提供的信息。您应该尝试从Garage透视图来构建Vehicle类(通常从所有将使用Vehicle的东西的透视图来构建):他们需要用他们的车辆做什么样的事情?我怎样才能用我的方法实现这些呢?

例如，从你的例子:

bool carIsAutomatic = myGarage[0].auto;

你的车库想知道一辆车的发动机…原因吗?不管怎样，没有必要只是通过Car来曝光。你仍然可以在Vehicle中暴露一个未实现的isAutomatic()方法，然后在Boat中实现它为return True并返回this。Car中的auto。

如果有一个三值的EngineType enum (HAS_NO_GEARS, HAS_GEARS_AUTO_SHIFT, HAS_GEARS_MANUAL_SHIFT)会更好，这会让你的代码清晰而准确地推断出通用车辆的实际特征。(无论如何，你需要区分摩托车。)