多态性意想不到的结果

Question

为了更多地理解多态性，我构建了一个小测试，它返回了意想不到的结果。

所以这个想法是用虚拟/覆盖关键字覆盖基类的方法，但似乎我不需要这些？

public class Employee 
     { 
      public Employee() 
      { 
       this.firstName = "Terry"; 
       this.lastName = "Wingfield"; 
      } 

      public string firstName { get; set; } 
      public string lastName { get; set; } 

      public void writeName() 
      { 
       Console.WriteLine(this.firstName + " " + this.lastName); 
       Console.ReadLine(); 
      } 
     } 

     public class PartTimeEmployee : Employee 
     { 
      public void writeName() 
      { 
       Console.WriteLine("John" + " " + "Doe"); 
       Console.ReadLine(); 
      } 
     } 
     public class FullTimeEmployee : Employee 
     { 
      public void writeName() 
      { 
       Console.WriteLine("Jane" + " " + "Doe"); 
       Console.ReadLine(); 
      } 
     } 

     static void Main(string[] args) 
     { 
      Employee employee = new Employee(); 
      PartTimeEmployee partTimeEmployee = new PartTimeEmployee(); 
      FullTimeEmployee fullTimeEmployee = new FullTimeEmployee(); 

      employee.writeName(); 
      partTimeEmployee.writeName(); 
      fullTimeEmployee.writeName(); 
     } 
    } 

利用上述我期待的代码导致像这样：

1. 特里Wignfield
2. 特里温菲尔德
3. 特里温菲尔德

但代替下面被写入到控制台：

1. 特里温菲尔德
2. 李四
3. 李四

我认为后者是行不通的，因为这将所需要的ovrride关键字。

所以问题是为什么我看到没有适当的关键字后面的名字？

我希望这是足够清晰的阅读。

问候，

Answer 1

您所展示的代码中没有多态性。

将其更改为：

Employee employee = new Employee(); 
Employee partTimeEmployee = new PartTimeEmployee(); 
Employee fullTimeEmployee = new FullTimeEmployee(); 

，你会得到您预期的结果。

更新：

在OOP“多态性”（许多形式）的概念是指具有某种类型（基类或接口）的引用的代码的交易而有可能是不同类型的（后代，实现的实例）在这些参考之后。为了多态性“踢入”，必须有继承和虚拟方法（在接口实现中使用不同的术语，但让我们使用与您的代码示例相关的术语）。你有继承，但没有虚拟方法。对于常规（非虚拟）方法，方法调用将在编译时根据其方法被调用的对象的类型来解析。

下面的代码：

PartTimeEmployee partTimeEmployee = ...; 
partTimeEmployee.writeName(); 

很显然编译器调用什么方法writeName，它是PartTimeEmployee.writeName。 类似地，对于代码：

Employee partTimeEmployee = ...; 
partTimeEmployee.writeName(); 

的方法来调用是Employee.writeName。

Answer 2

这被称为方法隐藏。你只是在派生类中隐藏基类方法。你应该得到一个警告，但它是完全合法的。欲了解更多信息，请参阅documentation。您可能还想看看this问题

Answer 3

对于多态行为，其必须为override这些方法在PartTimeEmployee和FullTimeEmployee。你在那里做的是把这些方法隐藏在基类中。

 public class Employee 
     { 
      public Employee() 
      { 
       this.firstName = "Terry"; 
       this.lastName = "Wingfield"; 
      } 

      public string firstName { get; set; } 
      public string lastName { get; set; } 

      public virtual void writeName() 
      { 
       Console.WriteLine(this.firstName + " " + this.lastName); 
       Console.ReadLine(); 
      } 
     } 

    public class PartTimeEmployee : Employee 
    { 
     public override void writeName() 
     { 
      Console.WriteLine("John" + " " + "Doe"); 
      Console.ReadLine(); 
     } 
    } 
    public class FullTimeEmployee : Employee 
    { 
     public override void writeName() 
     { 
      Console.WriteLine("Jane" + " " + "Doe"); 
      Console.ReadLine(); 
     } 
    } 

Answer 4

使用C＃，您可以使用“new”关键字重写基类的方法。如果你省略了这个关键字，编译器会编译你的源代码，就好像它存在一样。 所以现在的问题，我想，就是：什么是新的，覆盖之间的区别？这是一个很大的区别。

“新”指示编译器使用您的实现，而不是基类实现的，但不是直接引用类的任何代码将使用基类的实现。

“覆盖”用于虚拟和抽象方法。这指示编译器使用方法的最后定义的实现。如果方法在对基类的引用上调用，它将使用最后一个实现在该对象上覆盖它。

我希望我已经足够清晰。