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

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

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

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

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

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

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

如果你使用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)会更好，这会让你的代码清晰而准确地推断出通用车辆的实际特征。(无论如何，你需要区分摩托车。)

如果你需要在车库中区分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而不关心实现。

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

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

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

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这样已转换的数据之前，最好总是进行类型检查。