C#继承和派生

2023-05-16

用户在程序中会遇到 this 和 base 关键字，this 关键字代表的是当前类的对象，而 base 关键字代表的是父类中的对象。

方法隐藏和重写方法有区别吗？

class Program
{
    static void Main(string[] args)
    {
        A a1 = new B();
        a1.Print();	//A
        A a2 = new C();
        a2.Print();	//C
    }
}
class A
{
    public virtual void Print()
    {
        Console.WriteLine("A");
    }
}
class B :A
{
    public new void Print()
    {
        Console.WriteLine("B");
    }
}
class C :A
{
    public override void Print()
    {
        Console.WriteLine("C");
    }
}


//从上面的执行效果可以看出，使用方法隐藏的方法调用的结果是父类 A 中 Print 方法中的内容，而使用方法重写的方法调用的结果是子类 C 中 Print 方法中的内容。

 //因此方法隐藏相当于在子类中定义新方法，而方法重写则是重新定义父类中方法的内容。

 //从上面的代码也可以看出，在“A a1=new B()”语句中 A 类是父类、B 类是子类，相当于将子类转换成父类，即隐式转换。



//如果需要将父类转换成子类，则需要强制转换，并且在强制转换前需要先将所需的子类转换成父类，示例代码如下。 
A a2=new C();	//子类转换成父类
C c=(C) a2;	//父类转换成子类
c.Print();

文章目录

- - C#继承：基类和派生类
  - C# Object类简介
  - C# Equals方法：判断两个对象是否相等
  - C# GetHashCode方法：获取哈希码
  - C# GetType方法：获取对象type类型
  - C# ToString方法：返回对象实例的字符串
  - C# VS2015类图的使用
  - C# virtual关键字详解
  - C# abstract：声明抽象类或抽象方法
  - C# sealed：声明密封类或密封方法
  - C#继承关系中构造器之间的关系
  - C#多态浅析

在 C# 语言中仅支持单重继承，主要用于解决代码的重用问题。

为了将继承关系灵活运地用到程序设计中，在 C# 语言中提供了接口来解决多重继承的关系。

在编程中灵活地使用类之间的继承关系能很好地实现类中成员的重用，有利于类的使用。

在 C# 语言中所有类都是从 Object 类继承而来的，Object 类中的属性和方法可以被用到任何类。

C#继承：基类和派生类

继承的思想实现了属于（IS-A）关系。例如，哺乳动物属于（IS-A）动物，狗属于（IS-A）哺乳动物，因此狗属于（IS-A）动物。

C# 继承的特点
• 派生类是对基类的扩展，派生类可以添加新的成员，但不能移除已经继承的成员的定义。
• 继承是可以传递的。如果 C 从 B 中派生，B 又从 A 中派生，那么 C 不仅继承了 B 中声明的成员，同样也继承了 A 中声明的成员。
• 构造函数和析构函数不能被继承，除此之外其他成员能被继承。基类中成员的访问方式只能决定派生类能否访问它们。
• 派生类如果定义了与继承而来的成员同名的新成员，那么就可以覆盖已继承的成员，但这并不是删除了这些成员，只是不能再访问这些成员。
• 类可以定义虚方法、虚属性及虚索引指示器，它的派生类能够重载这些成员，从而使类可以展示出多态性。
• 派生类只能从一个类中继承，可以通过接口来实现多重继承。

C# Object类简介

Object 类是 C# 语言中最原始、最重要的类，是所有类的“祖先”，每个 C# 类都是它的子类，它实现了每个类都必须具有的基本方法。

这里指的“所有类”，即不管是 C# 系统所提供的标准类，还是用户自行編写的类，都是从Object类直接或间接继承而来，它是类层次结构中的顶级类，即 C# 树型类层次结构的“根”。

Object 类中的属性和方法可以被用到任何类。

当編程者定义一个类时没有使用关键字 Extends 指明它的父类，则編译器认为该类从 Object 类继承而来。

在 Object 类中提供了 4 个常用的方法，即 Equals、GetHashCode、GetType 以及 ToString 方法。

既然任何一个类都继承了 Object 类，这 4 个方法也可以被任何类使用或重写。

C# Equals方法：判断两个对象是否相等

C# Equals 方法主要用于比较两个对象是否相等，如果相等则返回 True,否则返回 False。

如果是引用类型的对象，则用于判断两个对象是否引用了同一个对象。

在 C# 语言中，Equals 方法提供了两个，一个是静态的，一个是非静态的，具体的定义如下。

Equals (object ol, object o2); //静态方法
Equals (object o); //非静态方法

        //False
        Student stu1 = new Student();
        Student stu2 = new Student();
        bool flag = Equals(stu1, stu2);

//True
Student stu2=stu1;
stul.Equals(stu2);

C# GetHashCode方法：获取哈希码

C# GetHashCode 方法返回当前 System.Object 的哈希代码，每个对象的哈希值都是固定的。

该方法不含有任何参数，并且不是静态方法，因此需要使用实例来调用该方法。

由于该方法是在 Object 类中定义的，因此任何对象都可以直接调用该方法。

下面通过实例来演示该方法的使用。

        Student stu1 = new Student();
        Student stu2 = new Student();
        Console.WriteLine(stu1.GetHashCode());
        Console.WriteLine(stu2.GetHashCode());

C# GetType方法：获取对象type类型

C# GetType 方法用于获取当前实例的类型，返回值为 System.Type 类型。

C# GetType 方法不含任何参数，是非静态方法。

        int i = 100;
        string str = "abc";
        Student stu = new Student();

        Console.WriteLine(i.GetType());	//System.Int32
        Console.WriteLine(str.GetType());	//System.String
        Console.WriteLine(stu.GetType());	//[namspace name].Student

C# ToString方法：返回对象实例的字符串

C# ToString 方法返回一个对象实例的字符串，在默认情况下将返回类类型的限定名。

C# 中几乎所有的类型都派生自 Object，所以如果当前类型没有重写 ToString() 方法的情况下，调用 ToString() 方法，默认返回当前类型的名称。

任何类都可以重写 ToString 方法，返回自定义的字符串。

对于其他的值类型，则为将值转换为字符串类型的值。

        Int32 a = 1;
        Object b = new Object();
        Console.WriteLine("值类型(Int32类型)的字符串的表现形式:{0}", a.ToString());
        Console.WriteLine("引用类型字符串的表现形式:{0}", b.ToString());

C# VS2015类图的使用

在 Visual Studio 2015 中将类文件转换成类图非常简单，直接右击类文件,在右键菜单中选择“查看类图”命令。

类之间的继承关系的定义语法形式如下。

访问修饰符  class  ClassA:ClassB
 {
     //类成员
}

其中:
• 访问修饰符：包括public、internal。
• ClassA：称为子类、派生类，在子类中能直接使用 ClassB 中的成员。
• ClassB：称为父类、基类。

注意：一个类只能有一个父类，但是一个父类可以有多个子类，并且在 C# 语言中继承关系具有传递性，即 A 类继承 B 类、C 类继承 A 类，则 C 类也相当于继承了 B 类。

C# virtual关键字详解

virtual 关键字能修饰方法、属性、索引器以及事件等，用到父类的成员中。

使用 virtual 关键字修饰属性和方法的语法形式如下。

//修饰属性
public  virtual  数据类型  属性名{get; set; }

//修饰方法
 访问修饰符  virtual  返回值类型 方法名
{
     语句块；
}

需要注意的是，virtual 关键字不能修饰使用 static 修饰的成员。

此外，virtual 关键字既可以添加到访问修饰符的后面，也可以添加到访问修饰符的前面，但实际应用中习惯将该关键字放到访问修饰符的后面。

子类继承父类后能重写父类中的成员，重写的关键字是 override。

所谓重写是指子类和父类的成员定义一致，仅在子类中增加了 override 关键字修饰成员。

C# abstract：声明抽象类或抽象方法

C# abstract 关键字代表的是抽象的，使用该关键字能修饰类和方法，修饰的方法被称为抽象方法、修饰的类被称为抽象类。

在 C# 语言中抽象方法是一种不带方法体的方法，仅包含方法的定义，语法形式如下。

访问修饰符  abstract  方法返回值类型  方法名(参数列表);

其中，当 abstract 用于修饰方法时，也可以将 abstract 放到访问修饰符的前面。

抽象方法定义后面的“;”符号是必须保留的。需要注意的是，抽象方法必须定义在抽象类中。

在定义抽象类时，若使用 abstract 修饰类，将其放到 class 关键字的前面，语法形式如下。

访问修饰符  abstract class  类名
{
     //类成员
}

其中“abstract”关键字也可以放到访问修饰符的前面。

在抽象类中可以定义抽象方法，也可以定义非抽象方法。

通常抽象类会被其他类继承，并重写其中的抽象方法或者虚方法。

此外，尽管在抽象类中仍然能定义构造器，但抽象类不能实例化，即不能使用如下语句。

new  抽象类的名称();

【实例 1】创建抽象类 ExamResult，并在类中定义数学 (Math)、英语 (English) 成绩的属性，定义抽象方法计算总成绩。

abstract class ExamResult
{
    //学号
    public int Id { get; set; }
    //数学成绩
    public double Math { get; set; }
    //英语成绩
    public double English { get; set; }
    //计算总成绩
    public abstract void Total();
}
class MathMajor : ExamResult
{
    public override void Total()
    {
        double total = Math * 0.6 + English * 0.4;
        Console.WriteLine("学号为" + Id + "数学专业学生的成绩为：" + total);
    }
}
class EnglishMajor : ExamResult
{
    public override void Total()
    {
        double total = Math * 0.4 + English * 0.6;
        Console.WriteLine("学号为" + Id + "英语专业学生的成绩为：" + total);
    }
}






class Program
{
    static void Main(string[] args)
    {
        MathMajor mathMajor = new MathMajor();
        mathMajor.Id = 1;
        mathMajor.English = 80;
        mathMajor.Math = 90;
        mathMajor.Total();
        EnglishMajor englishMajor = new EnglishMajor();
        englishMajor.Id = 2;
        englishMajor.English = 80;
        englishMajor.Math = 90;
        englishMajor.Total();
    }
}

C# sealed：声明密封类或密封方法

C# sealed 关键字的含义是密封的，使用该关键字能修饰类或者类中的方法，修饰的类被称为密封类、修饰的方法被称为密封方法。

但是密封方法必须出现在子类中，并且是子类重写的父类方法，即 sealed 关键字必须与 override 关键字一起使用。

密封类不能被继承，密封方法不能被重写。在实际应用中，在发布的软件产品里有些类或方法不希望再被继承或重写，可以将其定义为密封类或密封方法。

【实例】创建一个计算面积的抽象类 AreaAbstract ,并定义抽象方法计算面积。

//定义矩形类继承该抽象类，并重写抽象方法，将其定义为密封方法；定义圆类继承该抽象类，并重写抽象方法，将该类定义为密封类。

abstract class AreaAbstract
{
    public abstract void Area();
}
class Rectangle : AreaAbstract
{
    public double Width { get; set; }
    public double Length { get; set; }
    public sealed override void Area()
    {
        Console.WriteLine("矩形的面积是：" + Width * Length);
    }
}
sealed class Circle : AreaAbstract
{
    public double r { get; set; }
    public override void Area()
    {
        Console.WriteLine("圆的面积是：" + r * 3.14 * 3.14);
    }
}

//在上面的实例中，Circle 类不能被继承，Rectangle 类中的 Area 方法不能被重写。

C#继承关系中构造器之间的关系

在创建子类的实例时，先执行父类 A 中的无参构造器，再执行子类 B 中的无参构造器。
尽管在子类中调用了带参数的构造器，也会先调用其父类中的无参构造器。
通过在子类的构造器中使用“:base(参数)”的方式即可调用父类带参数的构造器，实际上这也是子类和父类中构造器的一种继承关系表示。

默认情况下，在子类的构造器中都会自动调用父类的无参构造器，如果需要调用父类中带参数的构造器才使用“:base(参数)”的形式。

class A
{
    public A()
    {
        Console.WriteLine("A类的构造器");
    }
    public A(string name)
    {
        Console.WriteLine("A类的构造器，传入的值为：" + name);
    }
}
class B :A
{
    public B()
    {
        Console.WriteLine("B类的构造器");
    }
    public B(string name):base(name)    //调用父类中带参数的构造器
    {
        Console.WriteLine("B类中带参数的构造器，传入的值为：" + name);
    }
}


class Program
{
    static void Main(string[] args)
    {
        B b = new B();		//A类的构造器  \n  B类的构造器
        B b = new B("ok");	//A类的构造器，传入的值为：ok   \n    B类中带参数的构造器，传入的值为：ok
    }
}

如果在父类中没有无参构造器，必须在子类的构造器中继承父类的构造器，否则程序无法成功编译。

C#多态浅析

在 C# 语言中多态称为运行时多态，也就是在程序运行时自动让父类的实例调用子类中重写的方法，它并不是在程序编译阶段完成的。

使用继承实现多态，实际上是指子类在继承父类后，重写了父类的虚方法或抽象方法。

在创建父类的对象指向每一个子类的时候，根据调用的不同子类中重写的方法产生了不同的执行效果。

总而言之，使用继承实现多态必须满足以下两个条件。
• 子类在继承父类时必须有重写的父类的方法。
• 在调用重写的方法时，必须创建父类的对象指向子类(即子类转换成父类)。

【实例】根据不同层次（本科生、研究生）的学生打印出不同的专业要求。

//创建专业信息的抽象类 (Major)，并在其中定义学号 (Id)、姓名 (Name)，以及打印专业要求的抽象方法 (Requirenwnt)。
 //分别使用本科生和研究生类继承专业信息类，并重写其中的打印专业要求的方法。实现的代码如下。 

class Program
{
    static void Main(string[] args)
    {
        Major major1 = new Undergraduate();
        major1.Id = 1;
        major1.Name = "张晓";
        Console.WriteLine("本科生信息：");
        Console.WriteLine("学号：" + major1.Id + "姓名：" + major1.Name);
        major1.Requirement();
        Major major2 = new Graduate();
        major2.Id = 2;
        major2.Name = "李明";
        Console.WriteLine("研究生信息：");
        Console.WriteLine("学号：" + major2.Id + "姓名：" + major2.Name);
        major2.Requirement();
    }
}
abstract class Major
{
    public int Id { get; set; }
    public string Name { get; set; }
    public abstract void Requirement();
}
class Undergraduate :Major
{
    public override void Requirement()
    {
        Console.WriteLine("本科生学制4年，必须修满48学分");
    }
}
class Graduate : Major
{
    public override void Requirement()
    {
        Console.WriteLine("研究生学制3年，必须修满32学分");
    }
}


//创建父类的实例指向了不同的子类，在程序运行时会自动调用子类中重写后的方法内容，显示出本科生和研究生的要求信息。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)