我真的只是汇集了其他人的想法(我不是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人，所以上面的一些语法可能是错误的，但这些概念应该是成立的。然而，在没有测试之前，不要在任何重要的地方运行上面的代码。

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

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

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

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

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

或更短，没有温度字段:

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

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

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

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

你问管家:

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

懒惰的吉夫斯说:

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

这是所有。

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