C# 继承

2025 年 8 月 21 日 | 阅读 13 分钟

在 C# 编程语言中，继承是指一个对象自动获取其父对象的所有属性和行为的过程。通过这种方式，我们可以重用、扩展或修改在另一个类中定义的属性和行为。

在 C# 中，继承了另一个类成员的类称为派生类，而被继承了成员的类称为基类。派生类是基类的专用类。

语法

它具有以下语法：

class BaseClass
{
    // base class members
}
class DerivedClass : BaseClass
{
    // derived class members
}

在此语法中；

派生类：它表示一个继承自另一个类的类，也称为子类。它可以向其他类添加字段和方法。
基类：也称为父类。它是被其他类继承其特性的类。

C# 继承示例

让我们以一个例子来说明 C# 中的继承。

示例

using System;  
   public class Animal    //base class
    {  
       public void eat() { 
Console.WriteLine("Eating..."); 
}  
   }  
   public class Dog: Animal    //derived class
   {  
       public void bark() { 
Console.WriteLine("Barking..."); 
}  
   }  
   class TestInheritance2{  
       public static void Main(string[] args)  
        {  
            Dog d1 = new Dog();  
            d1.eat();  
            d1.bark();  
        }  
    }  

编译并运行

输出

Eating...
Barking...

说明

在这个例子中，我们有一个基类 Animal，它定义了一个 eat() 方法，而派生类 Dog 继承自 Animal 并添加了自己的 bark() 方法。在 main() 函数中，创建了一个 Dog 对象，该对象可以调用 eat() 和 bark() 函数。最后，它显示了输出。

继承的类型

C# 编程语言中有几种继承类型。它们如下：

现在，我们将逐一讨论这些继承。

C# 单一继承

在 C# 编程语言中，单一继承定义为派生类仅从一个基类继承的继承。

单一继承示例

让我们以 C# 中的单一继承为例。

示例

using System;  
   public class Employee  
    {  
       public float salary = 40000;  
   }  
   public class Programmer: Employee  
   {  
       public float bonus = 10000;  
   }  
   class SingleInheritance{  
       public static void Main(string[] args)  
        {  
            Programmer p1 = new Programmer();    
            Console.WriteLine("Salary: " + p1.salary);  
            Console.WriteLine("Bonus: " + p1.bonus);  
        }  
    }

编译并运行

输出

Salary: 40000
Bonus: 10000

说明

在这个例子中，我们有一个基类 Employee，Programmer 是派生类。之后，Programmer 类继承了 Employee 类中的 salary 字段。它有自己的字段 bonus。当我们创建一个 programmer 对象时，我们可以同时访问 Salary 和 bonus。

多级继承

在 C# 编程语言中，多级继承是一个类继承另一个类，而该类又被另一个类继承的过程。继承是可传递的，因此最后一个派生类获取其所有基类的所有成员。

让我们考虑三个类，如 Class A、Class B 和 Class C，其中 Class A 代表基类，Class B 代表中间类，Class C 代表派生类。它表明一个类继承另一个类，而该类又被另一个类继承。

语法

它具有以下语法：

class Base  
{  
    // body of Base class  
};  
 class Intermediate : public Base   
{  
    //Body of intermediate class   
};  
class Derived : public Intermediate   
{  
    // Body of derived class   
}; 

多级继承示例

让我们以一个例子来说明 C# 中的多级继承。

示例

using System;  
   public class Animal  
    {  
       public void eat() { Console.WriteLine("Eating..."); }  
   }  
   public class Dog: Animal  
   {  
       public void bark() { Console.WriteLine("Barking..."); }  
   }  
   public class BabyDog : Dog  
   {  
       public void weep() { Console.WriteLine("Weeping..."); }  
   }  
   class Mul_level_inheritance{  
       public static void Main(string[] args)  
        {  
            BabyDog d1 = new BabyDog();  
            d1.eat();  
            d1.bark();  
            d1.weep();  
        }  
    }  

编译并运行

输出

Eating...
Barking...
Weeping...

说明

在这个例子中，我们有一个 Dog 类继承自 Animal，BabyDog 类继承自 Dog。因此，BabyDog 对象可以访问所有三个类中的方法：eat()、bark() 和 weep()。

层次继承

在 C# 编程语言中，层次继承是一个过程，其中多个派生类从单个基类继承。在这种继承中，我们可以将所有共有的特性包含在基类中。

语法

它具有以下语法：

class A    
{    
    // body of the class A.    
}      
class B : public A     
{    
    // body of class B.    
}    
class C : public A    
{    
    // body of class C.    
}     
class D : public A    
{    
    // body of class D.    
} 

C# 层次继承示例

让我们以一个例子来说明 C# 中的层次继承。

示例

using System;
class Vehicle
{
    public void Start()
    {
        Console.WriteLine("Vehicle has started");
    }
}
class Car : Vehicle
{
    public void Drive()
    {
        Console.WriteLine("Driving the car");
    }
}
class Bike : Vehicle
{
    public void Ride()
    {
        Console.WriteLine("Riding the bike");
    }
}
class Program
{
    static void Main()
    {
        Car car = new Car();
        car.Start();  
        car.Drive();  
        Bike bike = new Bike();
        bike.Start(); 
        bike.Ride();  
    }
}

编译并运行

输出

Vehicle has started
Driving the car
Vehicle has started
Riding the bike

说明

在这个例子中，我们有一个基类 Vehicle，它有一个 Start() 方法，以及两个派生类 Car 和 Bike，每个类都有自己的 Drive() 和 Ride() 方法。在 Main() 函数中，声明了 Car 和 Bike 的实例，它们都利用了重写的 Start() 方法以及其类特定的方法来演示层次继承。

多重继承

在 C# 中，多重继承是一个类从多个接口继承的过程。C# 不支持继承多个基类。使用接口实现多重继承。

语法

它具有以下语法：

interface A
{
    void Method1();
}

interface B
{
    void Method2();
}

class MyClass : A, B
{
    public void Method1() { }
    public void Method2() { }
}

C# 多重继承示例

让我们以一个例子来说明 C# 中的多重继承。

示例

using System;
interface IWriter
{
    void Write();
}
interface IReader
{
    void Read();
}
class Document : IWriter, IReader
{
    public void Write()
    {
        Console.WriteLine("Writing to the document.");
    }
    public void Read()
    {
        Console.WriteLine("Reading from the document.");
    }
}
class Program
{
    static void Main()
    {
        Document doc = new Document();
        doc.Read();   
        doc.Write(); 
    }
}

编译并运行

输出

Reading from the document.
Writing to the document.

说明

在这个例子中，我们有两个接口 IWriter 和 IReader，每个接口都声明了 Write() 和 Read() 方法。Document 类继承了这两个接口，因此 Document 为这两个方法提供了实现。在 Main 方法中，创建了一个 document 对象并用于调用 Read() 和 Write() 方法。它演示了 C# 如何允许一个类利用接口从多个位置派生功能，尽管它不支持直接的多类继承。

混合继承

C# 编程语言不直接支持类的多重继承（以避免歧义）。混合继承是多级继承和层次继承的混合。

语法

它具有以下语法：

// Base class
class BaseClass
{
    public void DisplayBase() { }
}

// Interface 1
interface A
{
    void Method1();
}

// Interface 2
interface B
{
    void Method2();
}

// Derived class inherits from BaseClass and implements multiple interfaces
class DerivedClass : BaseClass, A, B
{
    public void Method1() { }
    public void Method2() { }
}

C# 混合继承示例

让我们以一个例子来说明 C# 中的混合继承。

示例

using System;
interface Employee
{
    void Work();
}
class Person
{
    public void ShowDetails()
    {
        Console.WriteLine("Person details displayed");
    }
}
class Manager : Person, Employee
{
    public void ManageTeam()
    {
        Console.WriteLine("Managing the team");
    }
    public void Work()
    {
        Console.WriteLine("Manager is working");
    }
}
class Developer : Person, Employee
{
    public void WriteCode()
    {
        Console.WriteLine("Writing code");
    }

    public void Work()
    {
        Console.WriteLine("Developer is working");
    }
}
class Program
{
    static void Main()
    {
        Manager m = new Manager();
        m.ShowDetails();  
        m.ManageTeam();   
        m.Work();         
        Developer d = new Developer();
        d.ShowDetails();  
        d.WriteCode();    
        d.Work();         
    }
}

编译并运行

输出

Person details displayed
Managing the team
Manager is working
Person details displayed
Writing code
Developer is working

说明

在这个例子中，我们有一个父类 Person，Student 继承自 Person，CollegeStudent 进一步继承自 Student。CollegeStudent 实现了接口 IExaminable。在 main() 函数中，CollegeStudent 对象调用 Person、Student 的方法、其方法以及接口方法，从而演示了具有类和接口关系的混合继承。

C# 继承中的访问修饰符

在 C# 编程语言中，访问修饰符有助于通过继承控制类成员的可见性。C# 继承中主要有五种访问修饰符。它们如下：

1) 公共访问修饰符

在 C# 中，public 访问修饰符主要用于指定基类成员可以在类、派生类和类外部的任何地方访问。它也是派生类对象的一部分。它不限制数据到声明的块。

2) 私有访问修饰符

基类的私有成员只能在同一类内部访问。私有成员的可访问性在派生类外部受到限制。

3) 受保护访问修饰符

基类的受保护成员可以在同一类内部和派生类中访问。在继承的情况下，它在类继承结构外部是不可访问的。

4) 内部访问修饰符

内部成员可以在同一程序集中访问。它不能在类外部访问。internal 关键字用于定义 C# 中的内部访问修饰符。它在具有多个文件的应用程序中非常有用。

5) 受保护的内部访问修饰符

受保护的内部成员可以在声明它的同一程序集中（如内部）访问。它们也可以在派生类内部（如受保护）访问。protected internal 关键字用于指定受保护的内部访问修饰符。

C# 继承中的方法重写

在 C# 继承中，方法重写使派生类能够为基类中已定义的方法提供特定的执行。如果类的一个类似方法同时存在于基类和派生类中，则派生类的方法将重写基类方法。

C# 继承中的方法重写示例

让我们以一个例子来说明 C# 继承中的方法重写。

示例

using System;

class Student   // Base class
{
    public string Name;
    public int RollNo;

    public Student(string std_name, int std_rollNo)
    {
        Name = std_name;
        RollNo = std_rollNo;
    }

    // Virtual method
    public virtual void ShowInfo()
    {
        Console.WriteLine($"Student: {Name}, Roll No: {RollNo}");
    }
}

class CollegeStudent : Student   // Derived class
{
    public string Course;

    public CollegeStudent(string std_name, int std_rollNo, string std_course) 
        : base(std_name, std_rollNo)
    {
        Course = std_course;
    }

    // Overriding the base method
    public override void ShowInfo()
    {
        Console.WriteLine($"College Student: {Name}, Roll No: {RollNo}, Course: {Course}");
    }
}

class SchoolStudent : Student   // Another derived class
{
    public int ClassGrade;

    public SchoolStudent(string std_name, int std_rollNo, int std_grade)
        : base(std_name, std_rollNo)
    {
        ClassGrade = std_grade;
    }

    // Overriding the base method
    public override void ShowInfo()
    {
        Console.WriteLine($"School Student: {Name}, Roll No: {RollNo}, Grade: {ClassGrade}");
    }
}

class Program
{
    static void Main()
    {
        Student s1 = new CollegeStudent("Michael", 101, "Computer Science");
        Student s2 = new SchoolStudent("Richard", 202, 10);

        // Calls overridden methods
        s1.ShowInfo();
        s2.ShowInfo();
    }
}

编译并运行

输出

College Student: Michael, Roll No: 101, Course: Computer Science
School Student: Richard, Roll No: 202, Grade: 10

说明

在此示例中，我们演示了 C# 继承中的方法重写。这里，我们有一个基于 student 的类，它定义了一个虚拟方法 ShowInfo，该方法在派生类 CollegeStudent 和 SchoolStudent 中被重写，以提供更详细的信息。当我们使用基类引用创建对象时，会执行派生类中的重写方法。

C# 继承中的类型转换

在 C# 继承中，类型转换是指基类与其派生类之间的转换。派生类对象可以被隐式地视为基类对象（向上转型），而将基类对象转换回派生类则需要显式转换（向下转型）。当我们要通过基类引用处理派生对象时，这非常有用。

C# 继承中的类型转换示例

让我们以一个例子来说明 C# 继承中的类型转换。

示例

using System;
class Animal  //base class
{
    public void Speak()
    {
        Console.WriteLine("Animal speaks");
    }
}
class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Dog barks");
    }
}
class Program
{
    static void Main()
    {
        // Upcasting
        Animal a = new Dog();
        a.Speak(); 
        // Downcasting 
        if (a is Dog)
        {
            Dog d = (Dog)a;
            d.Bark();  
        // Downcasting using 'as'
        Dog d2 = a as Dog;
        if (d2 != null)
        {
            d2.Bark();  
        }
        }
    }
}

编译并运行

输出

Animal speaks
Dog barks
Dog barks

说明

在这个例子中，我们有一个 Person 类，它定义了一个构造函数和一个虚拟方法 ShowInfo()。派生类 Employee 继承自 Person，它使用 base(emp_name) 方法调用基类构造函数，并重写 ShowInfo()，同时还调用 base.ShowInfo() 方法。它确保同时显示基类信息（Name）和派生类信息（EmpID）。

C# 继承中的 base 关键字

在 C# 继承中，base 关键字主要在派生类内部用于访问基类成员，并用于从派生类构造函数调用基类构造函数。它还可以访问派生类中隐藏或重写了的基类方法、属性和字段。

语法

它具有以下语法：

base.MemberName
base (...)

在这个语法中，

MemberName：它有助于访问基类成员。
base (…)：它从派生类构造函数调用基类构造函数。

C# 继承中的 base 关键字示例

让我们以一个例子来说明 C# 继承中的 base 关键字。

示例

using System;

class Person   // Base class
{
    public string Name;

    public Person(string emp_name)
    {
        Name = emp_name;
    }

    public virtual void ShowInfo()
    {
        Console.WriteLine($"Employee Name: {Name}");
    }
}

class Employee : Person   // Derived class
{
    public int EmpID;

    // Calling base constructor
    public Employee(string emp_name, int emp_id) : base(emp_name)
    {
        EmpID = emp_id;
    }

    // Overriding method
    public override void ShowInfo()
    {
        // Calling base class method using base keyword
        base.ShowInfo();
        Console.WriteLine($"Employee ID: {EmpID}");
    }
}

class Program
{
    static void Main()
    {
        Employee emp = new Employee("Johnson", 201);
        emp.ShowInfo();
    }
}

编译并运行

输出

Employee Name: Johnson
Employee ID: 201

说明

在这个例子中，我们有一个基类 Person，它定义了一个构造函数和一个虚拟方法 ShowInfo()。之后，我们有派生类 Employee，它继承自 Person，它使用 base 方法调用基类构造函数，并重写 ShowInfo() 方法。最后，我们使用 base.ShowInfo() 方法来确保同时显示基类信息和派生类信息。

C# 继承的优点

C# 继承有几个优点。其中一些如下：

继承允许我们在派生类中重用基类的方法和属性，这有助于减少代码重复。
它允许方法重写，这使我们能够使用不同的类提供特定的实现，同时共享相同的接口。
它创建了一个分层类结构，这有助于使代码更结构化，更容易理解。
如果我们对基类进行一些更改，它会自动应用于所有派生类。

C# 继承的缺点

C# 继承有几个缺点。其中一些如下：

在 C# 继承中，派生类与基类紧密耦合，因为它们继承了基类的方法和属性。如果我们对基类进行任何更改，可能会影响所有派生类。
通过引入额外的抽象级别，它可能会增加代码的复杂性。
如果我们创建了基类和派生类之间的依赖关系，继承可能会使代码变弱。
深的继承层次结构可能会使代码更难理解、调试和维护。

结论

总之，C# 继承是一种重要的面向对象编程方法，通过该方法，一个类可以继承另一个类的属性和行为。在 C# 中，继承另一个类成员的类称为派生类，而被继承了成员的类称为基类。它有助于促进代码的可重用性、可扩展性和多态性，从而使应用程序更易于维护和组织。

C# 继承常见问题解答

1) 什么是 C# 编程语言中的继承？

在 C# 编程语言中，继承是一种面向对象编程的特性，它允许一个类继承另一个类的行为和特性。它允许代码重用和在层次结构中嵌套类。

2) 我们如何在 C# 中使用继承？

我们使用冒号（:）符号来表示 C# 中的继承

class BaseClass { }
class DerivedClass: BaseClass { }

这里，DerivedClass 继承自 BaseClass。

3) C# 继承的主要优点是什么？

C# 继承的几个优点如下：

它通过共享代码来避免重复。
它允许我们扩展或修改基类的行为。
它使程序设计更加逻辑化和可维护。

4) 在 C# 继承方面，抽象类和接口之间的主要区别是什么？

抽象类和接口之间的主要区别在于，抽象类可以包含实现、构造函数和字段。另一方面，接口不应该包含实现（除了 C# 新版本中的默认实现）、构造函数或字段，仅用于合同声明。

5) C# 编程语言中的 base 关键字有什么作用？

在 C# 编程语言中，base 关键字使我们能够在派生类型中调用基类型成员，特别是构造函数和重写的方法。

下一主题C# 聚合（HAS-A 关系）

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

.Net Framework

C# 教程

C# 控制语句

C# 函数

C# 数组

C# Object 类

C# 属性

C# 继承

C# 多态

C# 抽象

C# 命名空间

C# 字符串

C# 异常处理

C# 文件 IO

C# 集合

C# 泛型

C# 委托

C# 反射

匿名函数

C# 多线程

C# 同步

C# 高级主题

C# 2.0

C# 3.0

C# 4.0

C# 5.0

C# 6.0

C# 7.0

C# 7.1

C# 程序

C# 面试问题

C# 杂项

ASP.NET 教程

ADO.NET 教程

C# Web 服务

C# 字符串函数

C# 新特性

C# 继承

语法

C# 继承示例

示例

继承的类型

C# 单一继承

示例

多级继承

示例

层次继承

示例

多重继承

示例

混合继承

示例

C# 继承中的访问修饰符

C# 继承中的方法重写

C# 继承中的方法重写示例

示例

C# 继承中的类型转换

C# 继承中的类型转换示例

示例

C# 继承中的 base 关键字