Question

我有一个持久的对象，为了这个问题，我将开车CAR类。

public class Car
{
   public string model {get;set}
   public int year {get;set}
}

显然非常简化。

现在，随着代码的开发，我自然地创建了一个接受CAR作为参数的函数。例如：

public void PaintCar (Car theCar)
{
  //Does some work
}

到目前为止一直很好，但后来我有一个场景，我需要另一个类，这与CAR非常相似，但汽车缺少一些字段。没问题我想OOP来救援，我只是从Car继承，最终得到：

public class SuperCar : Car
{
   public string newProp {get;set}
   // and some more properties
}

一切看起来都很好看，直到我遇到了一个非常有用的实用功能，我用来填充汽车的原始属性。

Public void SetCarProperties(Car theCar)
{
    //sets the properties for car here
}

我想mmm，我希望我可以使用相同的函数来设置我的superCar类的属性而不需要覆盖。我也不想更改基本汽车定义以包含superCar类的所有属性。

此时我陷入了两难境地。覆盖可以工作，但这是额外的工作。有更优雅的解决方案吗？基本上我想通过超类传递给期望基类的函数。这可能与c＃？

有关

我的最终代码结果如下：

Car myCar = new Car(); 
SetCarProperties(myCar); // ALL GOOD

SuperCar mySuperCar = new SuperCar(); 
SetCarProperties(mySuperCar); // at the moment this function is expecting type Car...

Answer 1

更优雅的解决方案是将函数SetCarProperties放在Car类上，并在SuperCar中覆盖它以使用base来填充Car属性和一些其他代码来填充SuperCar属性。

编辑：也称为多态。

Answer 2

介绍覆盖，但让原始调用基类版本来设置公共属性：

public void SetCarProperties(Car car)
{
    // set general properties
}

public void SetCarProperties(SuperCar veyron)
{
    this.SetCarProperties((Car) veyron);

    // SuperCar specific properties
}

Answer 3

您应该在Car类中创建一个具有受保护的virtual的方法，因此每个想要设置自己的属性的子类都可以在此函数内部执行此操作，因此您的代码可以如下所示：

   public class Car
   {
      public string model {get;set}
      public int year {get;set}

      public void SetCarProperties(Car theCar)
      {
          //sets the properties for car here
         ….
        //at the end:
          SetExtraProperties();
       }

      protected virtual void SetExtraProperties()
      {
      }

  }

在任何想要设置其自己的属性的子类中，它必须重写该方法为遵循：

    public class SuperCar : Car
     {
      public string newProp {get;set}
       // and some more properties
      protected override void SetExtraProperties()
       {
       this.newProp = "";
        …
       }

     }

Answer 4

SuperCar sCar =汽车作为SuperCar; if（sCar！= null） { 设置疤痕的属性; }

在汽车上设置属性;

关于继承和OOP的问题c＃

4 个答案: