多态性意外结果

Question

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

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

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. 特里·维格菲尔德
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 question

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”关键字重写基类的方法。如果您省略此关键字，编译器将编译您的源代码，就好像它存在一样。 所以我认为问题是：new 和 override 有什么区别？差别很大。

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

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

我希望我已经足够清楚了。