多态的实现（重载,虚方法,抽象类,接口）

1.前言

多态是指，在同一个方法中，由于参数不同而导致执行效果各异。多态的实现方式主要是通过函数、运算符重载，虚成员，以及抽象类实现和接口。下面的内容就详细介绍一下前三种多态的实现形式。

2.方法重载

 在同一作用域范围内，可以为同一个方法名声明多个定义，但是方法之间的定义必须不同，可以是参数列表的类型或个数的差异，但不可以重载只有返回类型不同的函数。下面的示例展示了如何实现方法的重载。

class Person
{
    public void Show()
    {
        Console.WriteLine($"name: kyle");
    }
    public void Show(int age)
    {
        Console.WriteLine($"name: kyle, age: {age}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Person p = new Person();
        p.Show();
        p.Show(23);
        Console.ReadKey();
    }
}

输出结果如下：

name: kyle
name: kyle, age: 23

常见的函数重载是对 Object 类中的 ToString()方法进行重载：

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return "Person: " + Name + " " + Age;
    }
}

其测试代码及结果如下：

Person person = new Person { Name = "John", Age = 12 };
Console.WriteLine(person);
// Output:
// Person: John 12

3.运算符重载

可以重定义或重载 C# 中内置的运算符，以此使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数，是通过关键字 operator 后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表。

下面的代码演示了运算符 + 的重载：

class Box
{
    double length;
    double width;
    public Box(double l, double w)
    {
        length = l;
        width = w;
    }
    public double Area()
    {
        return length * width;
    }
    public static double operator + (Box box1, Box box2)
    {
        return box1.Area() + box2.Area();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Box b1 = new Box(2.3, 1.2);
        Box b2 = new Box(4.4, 2.6);
        double total = b1 + b2;
        Console.WriteLine($"total area is {total}");
        Console.ReadKey();
    }
}

输出结果如下：

total area is 14.2

3.虚成员

3.1 override重写

当派生类从普通基类继承时，它会获得基类的所有公开方法、字段、属性和事件，当基类的成员声明为 virtual 时，派生类还可以对基类的成员（除字段）进行重写。在进行成员的重写时，派生类中需使用 override 关键字显示成员的重写。

下面的代码展示了对基类中的虚成员的重写：

public class BaseClass
{
    public virtual void DoWork() { }
    public virtual int WorkProperty
    {
        get { return 0; }
    }
}

public class DerivedClass : BaseClass
{
    public override void DoWork() { }
    public override int WorkProperty
    {
        get { return 0; }
    }
}

在使用 override 重写虚成员时，会对基类中的虚方法的覆盖，因此即便将派生类的示例转为基类的实例，仍会调用重写后的新成员，调用过程及结果如下：

DerivedClass B = new DerivedClass();
B.DoWork();  // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork();  // Also calls the new method.

3.2 使用新成员隐藏基类成员

如果不希望覆盖掉基类中的既有虚成员，可以通过 new 关键字（默认），从而禁止派生类参与基类的虚成员调用。

以下代码展示了如何使用新成员来隐藏基类成员，而不是重写覆盖：

public class BaseClass
{
    public void DoWork() { WorkField++; }
    public int WorkField;
    public int WorkProperty
    {
        get { return 0; }
    }
}

public class DerivedClass : BaseClass
{
    public new void DoWork() { WorkField++; } // 不覆盖基类虚方法
    public new int WorkField;
    public new int WorkProperty
    {
        get { return 0; }
    }
}

在使用 new 关键字重写虚成员后，如果将派生类的实例转换为基类的实例，将会调用基类原有的虚成员，调用过程及结果如下：

DerivedClass B = new DerivedClass();
B.DoWork();  // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork();  // Calls the old method.

3.3 阻止派生类重写虚成员

在类的继承过程中，虚成员默认始终保持其虚拟性（因此 override 关键字声明的重写成员也具有虚拟性），如果希望停止其虚拟继承，可以将虚成员声明为 sealed 来实现，其实现代码如下：

public class A
{
    public virtual void DoWork() { }
}
public class B : A
{
    public override void DoWork() { }
}

public class C : B
{
    public sealed override void DoWork() { }
}

在使用 sealed 声明虚成员之后，有 C 继承而来的类中的 Dowork() 不再保留虚拟性，但对于 C 的实例而言仍旧是虚拟的。C 的派生类可以通过 new 关键字最后重写 C 中的 Dowork() ：

public class D : C
{
    public new void DoWork() { }
}

3.4 在派生类中访问基类虚成员

如果要在派生类中直接访问基类的虚成员，可以使用 base 关键字进行访问，示例代码如下：

public class Base
{
    public virtual void DoWork() {/*...*/ }
}
public class Derived : Base
{
    public override void DoWork()
    {
        //Perform Derived's work here
        //...
        // Call DoWork on base class
        base.DoWork();
    }
}

4.抽象类

通过 abstract 关键字声明一个抽象类，例如：

public abstract class A
{
    // Class members here.
}

抽象类不可以进行实例化，其作用是作为一个可供多个派生类继承的通用基类。在抽象类中可以定义字段、属性、方法等，还可以通过关键字 abstract 添加到方法的返回类型前定义一个抽象方法，例如：

public abstract class A
{
    public int name;
    public string Show()
    {
        return "string";        
    }
    public abstract void DoWork(int i);
} 

抽象方法没有实现，抽象类的派生类必须实现所有的抽象方法。当抽象类从基类继承虚方法时，抽象类也可以使用抽象方法重写虚方法，例如：

public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

继承抽象方法的类无法访问方法的原始实现，即类 F 上的实例无法调用 D 中的 DoWork() ，通过这种方式，抽象类可强制派生类向虚拟方法提供新的方法实现。

由于抽象类需要作为基类由派生类继承，所以，抽象类无法使用 sealed 关键字和 static 关键字进行声明。