在这个简单的情况下，什么是好的设计：
假设我有一个基类Car，其中有一个方法FillTank(Fuel fuel)，
其中fuel也是一个基类，有几个子类，例如柴油、乙醇等。
在我的叶子车类DieselCar.FillTank(Fuel fuel)中只允许使用某种类型的燃料（没有惊喜:))。
现在我的问题是，根据我的接口，每辆汽车都可以用任何燃料加油，但我觉得这是错误的，在每个FillTank()实现中检查输入的燃料类型是否正确，如果不正确则抛出错误或其他异常。
如何重新设计这样的情况以更准确地解决这个问题，这是可能的吗？ 如何设计一个采用基类作为输入的基本方法而不会得到这些“奇怪的结果”？
使用通用的基类（如果您的语言支持的话（下面是C#示例））：
public abstract class Car<TFuel> where TFuel : Fuel
{
public abstract void FillTank(TFuel fuel);
}
基本上，这强制任何继承自汽车的类都必须指定所使用的燃料类型。此外，Car 类还施加了一个限制，即 TFuel 必须是抽象 Fuel 类的某个子类型。
假设我们有一个简单的 Diesel 类：
public class Diesel : Fuel
{
...
}
还有一辆只能使用柴油运行的汽车：
public DieselCar : Car<Diesel>
{
public override void FillTank(Diesel fuel)
{
//perform diesel fuel logic here.
}
}
仅靠面向对象编程不能很好地解决这个问题。你需要的是泛型编程（C++ 解决方案如下）：
template <class FuelType>
class Car
{
public:
void FillTank(FuelType fuel);
};
你的柴油车只是一种特定的汽车，Car<Diesel>。
FillTank() 就没有在基础的 Car 类中的业务，因为只知道你有一车并不能告诉你它使用什么燃料。因此，为了确保在 编译时的正确性，FillTank() 应该在子类中定义，并且只应该使用适用的 Fuel 的子类。FillingTank() 方法，让子类的方法调用它。对于Fuel也是一样。DieselCar 和 GasCar 的两个子类，并且需要确保将 Car 声明为虚拟超类，以便在 DualFuelCar 对象中不会有两个Car 实例。加油应该可以直接奏效，几乎不需要修改:默认情况下，您将获得两个按类型重载的函数 DualFuelCar.FillTank(GasFuel) 和 DualFuelCar.FillTank(DieselFuel)。FillTank() 函数呢? 那么您需要切换到运行时检查，并执行您认为必须执行的操作:使子类检查 Fuel.type，如果存在不匹配，则抛出异常或返回错误代码（后者更好）。在C++中，我建议使用RTTI和dynamic_cast<>。在Python中，使用 isinstance()。听起来你只是想限制进入你的柴油车的燃料类型。可以尝试以下代码：
public class Fuel
{
public Fuel()
{
}
}
public class Diesel: Fuel
{
}
public class Car<T> where T: Fuel
{
public Car()
{
}
public void FillTank(T fuel)
{
}
}
public class DieselCar: Car<Diesel>
{
}
这个可以解决问题，例如：
var car = new DieselCar();
car.FillTank(/* would expect Diesel fuel only */);
本质上，您在此处所做的是允许Car具有特定的燃料类型。它还允许您创建一辆支持任何类型Fuel的汽车（这将是一件好事！）。但是，在您的情况下，DieselCar，您只需从汽车派生一个类并限制其仅使用Diesel燃料。
ValidFuel(Fuel f)的方法，如果“叶子”汽车没有覆盖它，则抛出某种NotImplementedException（不同语言有不同的术语）。
FillTank 可以完全在基类中，并调用 ValidFuel 来查看它是否有效。public class BaseCar {
public bool ValidFuel(Fuel f) {
throw new Exception("IMPLEMENT THIS FUNCTION!!!");
}
public void FillTank(Fuel fuel) {
if (!this.ValidFuel(fuel))
throw new Exception("Fuel type is not valid for this car.");
// do what you'd do to fill the car
}
}
public class DieselCar:BaseCar {
public bool ValidFuel(Fuel f) {
return f is DeiselFuel
}
}
(defclass vehicle () ())
(defclass fuel () ())
(defgeneric fill-tank (vehicle fuel))
(defmethod fill-tank ((v vehicle) (f fuel)) (format nil "Dude, you can't put that kind of fuel in this car"))
(defclass diesel-truck (vehicle) ())
(defclass normal-truck (vehicle) ())
(defclass diesel (fuel) ())
(defmethod fill-tank ((v diesel-truck) (f diesel)) (format nil "Glug glug"))
给你这种行为：
CL> (fill-tank (make-instance 'normal-truck) (make-instance 'diesel))
"Dude, you can't put that kind of fuel in this car"
CL> (fill-tank (make-instance 'diesel-truck) (make-instance 'diesel))
"Glug glug"
这实际上是Common Lisp中的双重分派版本，正如stefaanv所提到的。
您可以扩展您的原始Car接口
interface Car {
drive();
}
interface DieselCar extends Car {
fillTank(Diesel fuel);
}
interface SolarCar extends Car {
chargeBattery(Sun fuel);
}
}
使用is运算符来检查接受的类，你可以在构造函数中抛出异常。