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

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”，有多种方法可以做到这一点。

我是Java编程的新手，试图掌握OOP的诀窍。

这只是我的观点——我将尽量简短，因为很多有趣的事情已经说过了。但实际上，这里有两个问题。一个是关于“面向对象”的，一个是关于它如何在Java中实现的。

首先，是的，你的车库里有辆车。所以你的假设是对的。但是，Java是一种静态类型语言。而编译器中的类型系统只能通过相应的声明来“知道”各种对象的类型。不是他们的习惯。如果你有一个Vehicle数组，编译器只知道它。所以它会检查你只在任何车辆上执行允许的操作。(换句话说，方法和属性在Vehicle声明中可见)。

你可以通过显式类型转换(Car)向编译器解释“你实际上知道这个Vehicle是Car”。编译器会相信你——即使在Java中有一个在运行时的检查，这可能会导致一个ClassCastException，以防止进一步的损害，如果你撒谎(其他语言，如c++不会在运行时检查-你必须知道你在做什么)

最后，如果你真的需要，你可以依靠运行时类型标识(即:instanceof)在尝试强制转换之前检查对象的“真实”类型。但在Java中，这通常被认为是一种糟糕的实践。

正如我所说，这是实现OOP的Java方式。有完全不同的类语言家族，通常被称为“动态语言”，它们只在运行时检查是否允许对对象进行操作。使用这些语言，您不需要将所有公共方法“上移”到某些(可能是抽象的)基类来满足类型系统。这就是所谓的鸭子打字。

你在这里的问题是在一个更基本的层面上:你以这样一种方式构建了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)会更好，这会让你的代码清晰而准确地推断出通用车辆的实际特征。(无论如何，你需要区分摩托车。)

你问管家:

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

懒惰的吉夫斯说:

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

这是所有。

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

我真的只是汇集了其他人的想法(我不是Java的人，所以这是伪的而不是实际的)，但是，在这个人为的例子中，我将把我的汽车检查方法抽象为一个专门的类，它只知道汽车，只关心查看车库时的汽车:

abstract class Vehicle { 
    public abstract string getDescription() ;
}

class Transmission {
    public Transmission(bool isAutomatic) {
        this.isAutomatic = isAutomatic;
    }
    private bool isAutomatic;
    public bool getIsAutomatic() { return isAutomatic; }
}

class Car extends Vehicle {
    @Override
    public string getDescription() { 
        return "a car";
    }

    private Transmission transmission;

    public Transmission getTransmission() {
        return transmission;
    }
}

class Boat extends Vehicle {
    @Override
    public string getDescription() {
        return "a boat";
    }
}

public enum InspectionBoolean {
    FALSE, TRUE, UNSUPPORTED
}

public class CarInspector {
    public bool isCar(Vehicle v) {
        return (v instanceof Car);
    }
    public bool isAutomatic(Car car) {
        Transmission t = car.getTransmission();
        return t.getIsAutomatic();
    }
    public bool isAutomatic(Vehicle vehicle) {
        if (!isCar(vehicle)) throw new UnsupportedVehicleException();
        return isAutomatic((Car)vehicle);
    }
    public InspectionBoolean isAutomatic(Vehicle[] garage, int bay) {
        if (!isCar(garage[bay])) return InspectionBoolean.UNSUPPORTED;
        return isAutomatic(garage[bay]) 
             ? InspectionBoolean.TRUE
             : InspectionBoolean.FALSE;
    }
}

重点是，当你问汽车的传动装置时你已经决定只关心汽车了。所以只要问问CarInspector就行了。多亏了三状态枚举，你现在可以知道它是自动的，甚至它不是一辆车。

当然，你需要为你关心的每辆车使用不同的vehicleinspector。你已经把哪个VehicleInspector实例化的问题推到了链上。

因此，您可能想要查看接口。

抽象getTransmission到接口(例如hastrtransmission)。这样，你就可以检查车辆是否有变速器，或者写一个TransmissionInspector:

abstract class Vehicle { }

class Transmission {
    public Transmission(bool isAutomatic) {
        this.isAutomatic = isAutomatic;
    }
    private bool isAutomatic;
    public bool getIsAutomatic() { return isAutomatic; }
}

interface HasTransmission { 
    Transmission getTransmission(); 
}

class Car extends Vehicle, HasTransmission {
    private Transmission transmission;

    @Override
    public Transmission getTransmission() {
        return transmission;
    }
}

class Bus extends Vehicle, HasTransmission {
    private Transmission transmission;

    @Override
    public Transmission getTransmission() {
        return transmission;
    }
}

class Boat extends Vehicle { }

enum InspectionBoolean {
    FALSE, TRUE, UNSUPPORTED
}

class TransmissionInspector {
    public bool hasTransmission(Vehicle v) {
        return (v instanceof HasTransmission);
    }
    public bool isAutomatic(HasTransmission h) {
        Transmission t = h.getTransmission();
        return t.getIsAutomatic();
    }
    public bool isAutomatic(Vehicle v) {
        if (!hasTranmission(v)) throw new UnsupportedVehicleException();
        return isAutomatic((HasTransmission)v);
    }
    public InspectionBoolean isAutomatic(Vehicle[] garage, int bay) {
        if (!hasTranmission(garage[bay])) return InspectionBoolean.UNSUPPORTED;
        return isAutomatic(garage[bay]) 
             ? InspectionBoolean.TRUE
             : InspectionBoolean.FALSE;
    }
}

现在你说，你只关心变速器，而不考虑车辆，所以可以问变速器检查员。TransmissionInspector可以检查公共汽车和汽车，但它只能询问有关变速器的信息。

现在，您可能认为布尔值并不是您所关心的全部。在这一点上，你可能更喜欢使用泛型的Supported类型，它同时暴露了受支持的状态和值:

class Supported<T> {
    private bool supported = false;
    private T value;

    public Supported() { }
    public Supported(T value) { 
        this.isSupported = true;
        this.value = value; 
    }

    public bool isSupported() { return supported; }
    public T getValue() { 
        if (!supported) throw new NotSupportedException();
        return value;
    }
}

现在你的检查器可能被定义为:

class TransmissionInspector {
    public Supported<bool> isAutomatic(Vehicle[] garage, int bay) {
        if (!hasTranmission(garage[bay])) return new Supported<bool>();
        return new Supported<bool>(isAutomatic(garage[bay]));
    }

    public Supported<int> getGearCount(Vehicle[] garage, int bay) {
        if (!hasTranmission(garage[bay])) return new Supported<int>();
        return new Supported<int>(getGearCount(garage[bay]));
    }
}

正如我说过的，我不是一个Java人，所以上面的一些语法可能是错误的，但这些概念应该是成立的。然而，在没有测试之前，不要在任何重要的地方运行上面的代码。

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