继承是面向对象编程中的一个重要概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。在 C# 中，使用 : 符号来实现继承。

基本语法

下面是 C# 继承的基本语法：

class ChildClass : ParentClass
{
    // 子类的成员
}

在上面的代码中，ChildClass 继承自 ParentClass。子类可以访问父类中的公共和受保护的成员，但不能访问私有成员。

示例代码

下面是一个简单的示例代码，演示了如何使用继承来创建一个基本的图形类：

using System;

class Shape
{
    protected int width;
    protected int height;

    public void SetWidth(int w)
    {
        width = w;
    }

    public void SetHeight(int h)
    {
        height = h;
    }
}

class Rectangle : Shape
{
    public int GetArea()
    {
        return (width * height);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Rectangle rect = new Rectangle();

        rect.SetWidth(5);
        rect.SetHeight(7);

        // 输出矩形的面积
        Console.WriteLine("矩形的面积：{0}", rect.GetArea());
        Console.ReadKey();
    }
}

在上面的代码中，Rectangle 类继承自 Shape 类。Shape 类中定义了 width 和 height 两个受保护的成员变量以及 SetWidth 和 SetHeight 两个公共的方法，用于设置宽度和高度。Rectangle 类中定义了 GetArea 方法，用于计算矩形的面积。在 Main 方法中，我们创建了一个 Rectangle 对象，设置其宽度和高度，并输出矩形的面积。

继承关系的访问修饰符

C# 中有三种访问修饰符用于控制继承关系中成员的访问权限：

• public：可以在任何地方访问。
• protected：可以在派生类中访问，但不能在其他地方访问。
• private：只能在当前类中访问。

下面是一个示例代码，演示了不同访问修饰符在继承关系中的应用：

using System;

class BaseClass
{
    public int publicVar = 1;
    protected int protectedVar = 2;
    private int privateVar = 3;
}

class DerivedClass : BaseClass
{
    public void PrintVars()
    {
        Console.WriteLine("publicVar = {0}", publicVar);
        Console.WriteLine("protectedVar = {0}", protectedVar); // 可以访问父类的受保护成员
        // Console.WriteLine

在上面的代码中，BaseClass 类中定义了三个成员变量，分别使用了 public、protected 和 private 访问修饰符。DerivedClass 类继承自 BaseClass 类，并在其中定义了 PrintVars 方法，用于输出不同访问修饰符的成员变量。可以看到，公共成员变量可以在任何地方访问，受保护成员变量可以在派生类中访问，但不能在其他地方访问，私有成员变量只能在当前类中访问。

多重继承

C# 不支持多重继承，即一个类不能同时继承多个类。但是，可以通过接口来实现多重继承的效果。接口是一种只包含抽象成员的类型，它定义了一组行为，由实现该接口的类来提供具体的实现。

下面是一个示例代码，演示了如何使用接口来实现多重继承的效果：

using System;

interface I1
{
    void Method1();
}

interface I2
{
    void Method2();
}

class MyClass : I1, I2
{
    public void Method1()
    {
        Console.WriteLine("实现 I1 中的 Method1 方法");
    }

    public void Method2()
    {
        Console.WriteLine("实现 I2 中的 Method2 方法");
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyClass obj = new MyClass();
        obj.Method1();
        obj.Method2();
        Console.ReadKey();
    }
}

在上面的代码中，MyClass 类实现了 I1 和 I2 两个接口，并分别实现了这两个接口中的方法。在 Main 方法中，我们创建了一个 MyClass 对象，并调用了其中的两个方法。可以看到，使用接口来实现多重继承的效果。

抽象类和虚方法

在 C# 中，可以使用抽象类和虚方法来实现多态性。抽象类是一种不能实例化的类，它的主要作用是作为其他类的基类，其中可以定义抽象方法、虚方法、属性等。抽象方法是一种没有具体实现的方法，由继承它的子类来提供具体实现。

下面是一个示例代码，演示了如何使用抽象类和抽象方法来实现多态性：

using System;

abstract class Shape
{
    public abstract void Draw(); // 抽象方法
}

class Circle : Shape
{
    public override void Draw() // 重写抽象方法
    {
        Console.WriteLine("画一个圆形");
    }
}

class Rectangle : Shape
{
    public override void Draw() // 重写抽象方法
    {
        Console.WriteLine("画一个矩形");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Shape[] shapes = new Shape[2];
        shapes[0] = new Circle();
        shapes[1] = new Rectangle();

        foreach (Shape shape in shapes)
        {
            shape.Draw(); // 多态调用
        }

        Console.ReadKey();
    }
}

在上面的代码中，Shape 类是一个抽象类，其中定义了一个抽象方法 Draw。Circle 类和 Rectangle 类分别继承自 Shape 类，并重写了 Draw 方法。在 Main 方法中，我们创建了一个 Shape 类型的数组，并分别将 Circle 类和 Rectangle 类的对象赋值给其中的元素。然后，我们使用 foreach 循环遍历数组，并多态调用其中的 Draw 方法。可以看到，多态性使得我们可以在运行时根据对象的实际类型来调用相应的方法。

另一种实现多态性的方法是使用虚方法。虚方法是一种带有默认实现的方法，可以在子类中被重写。在 C# 中，可以使用 virtual 关键字来定义虚方法。

下面是一个示例代码，演示了如何使用虚方法来实现多态性：

using System;

class Shape
{
    public virtual void Draw() // 虚方法
    {
        Console.WriteLine("画一个形状");
    }
}

class Circle : Shape
{
    public override void Draw() // 重写虚方法
    {
        Console.WriteLine("画一个圆形");
    }
}

class Rectangle : Shape
{
    public override void Draw() // 重写虚方法
    {
        Console.WriteLine("画一个矩形");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Shape[] shapes = new Shape[2];
        shapes[0] = new Circle();
        shapes[1] = new Rectangle();

        foreach (Shape shape in shapes)
        {
            shape.Draw(); // 多态调用
        }

        Console.ReadKey();
    }
}

在上面的代码中，Shape 类中定义了一个虚方法 Draw。Circle 类和 Rectangle 类分别继承自 Shape 类，并重写了 Draw 方法。在 Main 方法中，我们创建了一个 Shape 类型的数组，并分别将 Circle 类和 Rectangle 类的对象赋值给其中的元素。然后，我们使用 foreach 循环遍历数组，并多态调用其中的 Draw 方法。可以看到，虚方法也可以实现多态性，它使得子类可以重写父类中的方法，并根据需要进行自定义。

总结

继承是面向对象编程中的一个重要概念，它允许一个类继承另一个类的属性和方法。在 C# 中，使用 : 符号来实现继承。可以使用抽象类和抽象方法、虚方法以及接口来实现多态性。抽象类和抽象方法用于定义一组行为，由继承它的子类来提供具体实现；虚方法是一种带有默认实现的方法，可以在子类中被重写；接口是一种只包含抽象成员的类型，它定义了一组行为，由实现该接口的类来提供具体的实现。