Проблема проектирования ООП

Используйте общий базовый класс (если ваш язык поддерживает его (ниже - C #)):

public abstract class Car<TFuel>  where TFuel : Fuel
{
    public abstract void FillTank(TFuel fuel);
}

В основном это обеспечивает выполнение любого класса, наследуемого от автомобиля к укажите, какой вид топлива он использует. Кроме того, класс Car налагает ограничение, согласно которому TFuel должен быть некоторым подтипом абстрактного класса Fuel .

Допустим, у нас есть класс Дизель , который прост:

public class Diesel : Fuel
{
    ...
}

И автомобиль, который работает только на дизеле:

public DieselCar : Car<Diesel>
{
     public override void FillTank(Diesel fuel)
     {
          //perform diesel fuel logic here.
     }
}

Я согласен, что лучше всего (по крайней мере, не зная ничего больше о вашей проблеме) использовать std:: Последовательности . Но если вы настаиваете на управлении памятью самостоятельно, вы должны управлять ею полностью. Так что C++ путь:

class MyClass
{
private:
 const char *filename;

 MyClass(const MyClass&); // no implementation
 MyClass operator=(const MyClass &); // no implementation

public:
 MyClass() {filename = 0;}
 ~MyClass() {delete[] filename;}

 void func (const char *_filename);
}

void MyClass::func (const char *_filename)
{
 const size_t len = strlen(_filename);
 char * tmp_filename = new char[len + 1];
 strncpy(tmp_filename, _filename, len);
 tmp_filename[len] = '\0'; // I'm paranoid, maybe someone has changed something in _filename :-)
 delete[] filename;
 filename = tmp_filename;
}

и C путь

class MyClass
{
private:
 const char *filename;

 MyClass(const MyClass&); // no implementation
 MyClass operator=(const MyClass &); // no implementation

public:
 MyClass() {filename = 0;}
 ~MyClass() {free(filename);}

 void func (const char *_filename);
}

void MyClass::func (const char *_filename)
{
 free(filename);
 filename = strdup(_filename); // easier than C++, isn't it?
}

У меня нет опыта из первых рук., но я нашел эту запись в блоге довольно интересной.

Для этого можно использовать двойную отправку : принять некоторое количество топлива перед наполнять. Помните, что в языке, который не поддерживает его напрямую, вы вводите зависимости

Само по себе объектно-ориентированное программирование не может решить эту проблему. Что вам нужно, так это универсальное программирование (здесь показано решение C ++):

template <class FuelType>
class Car
{
public:
  void FillTank(FuelType fuel);
};

Тогда ваш дизельный автомобиль будет просто конкретным автомобилем, Car .

Похоже, что вы просто хотите ограничить тип топлива, которое поступает в ваш дизельный автомобиль. Что-то вроде:

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 */);

По сути, вы позволяете автомобилю иметь определенные типы топлива. Это также позволяет вам создать автомобиль, который будет поддерживать любой тип топлива (шанс был бы прекрасной вещью!). Однако в вашем случае, DieselCar, вы бы просто вывели класс из car и ограничили его использованием только Diesel топлива.

используйте оператор is для проверки допустимых классов, и вы можете создать исключение в конструкторе

Я думаю, что приемлемым методом будет наличие в вашем базовом классе метода 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
    }
}

В системе, подобной CLOS, вы можете сделать что-то вроде этого:

(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 .

вы можете расширить исходный интерфейс автомобиля

interface Car {
    drive();
}

interface DieselCar extends Car {
    fillTank(Diesel fuel);
}

interface SolarCar extends Car {
    chargeBattery(Sun fuel);
}

}