C#学习教程06——继承

最新推荐文章于 2024-05-17 13:42:57 发布
最新推荐文章于 2024-05-17 13:42:57 发布
阅读量772 收藏 6
点赞数 2
分类专栏： C#学习 文章标签： c# microsoft
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46003347/article/details/123297688
版权

文章目录

6.继承

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

在 C# 语言中实现继承非常容易，只需要用:符号即可完成类之间继承的表示。

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

其中:

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

继承的特点：

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

6.1 Object类

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

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

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

using System;
class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
};
class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student();
        Student stu2 = new Student();
        bool flag = Equals(stu1, stu2);
        Console.WriteLine("stu1和stu2比较的结果为：{0}", flag);

        Student stu3 = stu1;
        Console.WriteLine("stu1和stu3比较的结果为：{0}", stu1.Equals(stu3));
    }
}
// stu1和stu2比较的结果为：False
// stu1和stu3比较的结果为：True

6.1.2 GetHashCode方法：获取哈希码

using System;
class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
};
class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student();
        Student stu2 = new Student();
        Console.WriteLine("stu1的哈希码为：" + stu1.GetHashCode());
        Console.WriteLine("stu2的哈希码为：" + stu2.GetHashCode());
    }
}
// stu1的哈希码为：58225482
// stu2的哈希码为：54267293

不同实例的哈希值是不同的，因此也可以通过该方法比较对象是否相等。

6.1.3 GetType方法：获取对象type类型

using System;
class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
};
class Program
{
    static void Main(string[] args)
    {
        int i = 100;
        string str = "abc";
        Student stu = new Student();
        Console.WriteLine(i.GetType());
        Console.WriteLine(str.GetType());
        Console.WriteLine(stu.GetType());
    }
}
// System.Int32
// System.String
// Student

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

using System;
class Program
{
    static void Main(string[] args)
    {
        Int32 a = 123456;
        Object b = new Object();
        Console.WriteLine("值类型(Int32类型)的字符串的表现形式:{0}", a.ToString());
        Console.WriteLine("引用类型字符串的表现形式:{0}", b.ToString());
    }
}
// 值类型(Int32类型)的字符串的表现形式:123456
// 引用类型字符串的表现形式:System.Object

6.2 base关键字

子类中定义的同名方法相当于在子类中重新定义了一个方法，在子类中的对象是调用不到父类中的同名方法的，调用的是子类中的方法。因此也经常说成是将父类中的同名方法隐藏了。

在继承的关系中，子类如果需要调用父类中的成员可以借助 base 关键字来完成，具体的用法如下。

base. 父类成员

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

6.3 virtual关键字

在C#语言中，默认情况下类中的成员都是非虚拟的，通常将类中的成员定义成虚拟的，表示这些成员将会在继承后重写其中的内容。

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

virtual关键字不能修饰使用static修饰的成员。（为什么？）

using System;
class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Sex { get; set; }

    public virtual void Print()
    {
        Console.WriteLine("编号：" + Id);
        Console.WriteLine("姓名：" + Name);
        Console.WriteLine("性别：" + Sex);
    }
}
class Student : Person
{
    public string Major { get; set; }
    public string Grade { get; set; }
    public override void Print()
    {
        base.Print();
        Console.WriteLine("专业：" + Major);
        Console.WriteLine("年级：" + Grade);
    }
}
class Program
{
    static void Main(string[] args)
    {
        Student stu = new Student();
        stu.Id = 1;
        stu.Name = "Kint";
        stu.Sex = "Male";
        stu.Major = "Software";
        stu.Grade = "undergraduate";
        stu.Print();
    }
}
// 编号：1
// 姓名：Kint
// 性别：Male
// 专业：Software
// 年级：undergraduate

在 Student 类中添加重写的 ToString 方法，代码如下。

using System;
class Student
{
    public string Major { get; set; }
    public string Grade { get; set; }
    public override string ToString()
    {
        return "专业：" + Major + "\n年级：" + Grade;
    }
}
class Program
{
    static void Main(string[] args)
    {
        Student stu = new Student();
        stu.Major = "Software";
        stu.Grade = "undergraduate";
        Console.WriteLine(stu.ToString());
    }
}
// 专业：Software
// 年级：undergraduate

除了ToString方法，在类中也可以重写Equals方法、GetHashCode方法。

6.4 abstract关键字

abstract关键字用于声明抽象类或抽象方法。

定义抽象类的语法形式如下。抽象类不能实例化，抽象类中可以有非抽象方法。

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

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

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

在抽象类中可以定义抽象方法，也可以定义非抽象方法。通常抽象类会被其他类继承，并重写其中的抽象方法或者虚方法。

using System;
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();
    }
}
// 学号为1数学专业学生的成绩为：86
// 学号为2英语专业学生的成绩为：84

6.5 sealed关键字

sealed关键字用于声明密封类或密封方法。密封类不能被继承，密封方法不能被重写。

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

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

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 方法不能被重写。

6.6 修饰符总结

修饰符应用于说明
new函数成员成员用相同的签名隐藏继承的成员
static所有成员成员不作用于类的具体实例，也称为类成员，而不是实例成员
virtual仅函数成员成员可以由派生类重写
abstract仅函数成员虚拟成员定义了成员的签名，但没有提供实现代码
override仅函数成员成员重写了继承的虚拟或抽象成员
sealed类、方法和属性对于类，不能继承自密封类；对于属性和方法，成员重写已继承的虚拟成员，但任何派生类中的任何成员都不能重写该成员。该修饰符必须与override一起使用

6.7 构造器之间的关系

using System;
class A
{
    public A()
    {
        Console.WriteLine("A类的构造器");
    }
}
class B : A
{
    public B()
    {
        Console.WriteLine("B类的构造器");
    }
    public B(string name)
    {
        Console.WriteLine("B类中带参数的构造器，传入的值为：" + name);
    }
}
class Program
{
    static void Main(string[] args)
    {
        B b = new B();
        Console.WriteLine("***************");
        B bb = new B("Kint");
    }
}
// A类的构造器
// B类的构造器
// ***************
// A类的构造器
// B类中带参数的构造器，传入的值为：Kint

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

using System;
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();
        Console.WriteLine("***************");
        B bb = new B("Kint");
    }
}
// A类的构造器
// B类的构造器
// ***************
// A类的构造器，传入的值为：Kint
// B类中带参数的构造器，传入的值为：Kint

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

6.8 多态

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

使用继承实现多态必须满足以下两个条件。

  • 子类在继承父类时必须有重写的父类的方法。
  • 在调用重写的方法时，必须创建父类的对象指向子类(即子类转换成父类)。
using System;
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学分");
    }
}
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();
    }
}
// 本科生信息：
// 学号：1姓名：张三
// 本科生学制4年，必须修满48学分
// 研究生信息：
// 学号：2姓名：李四
// 研究生学制3年，必须修满32学分

思考1：为什么virtual关键字不能修饰使用static修饰的成员？

static方法是一个静态方法，编译器会在编译时保留这个方法的实现。也就是说，这个方法属于类，但是不属于任何成员，不管这个类的实例是否存在，该方法都会存在。

virtual方法是一个虚拟方法，在实例化对象调用之前该方法都不存在于真实的内存空间中。

一个静态方法是真实存在的，而一个虚拟方法可以被派生类重写，这二者是冲突的。

暄踽
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c#类与对象的继承与多态——图形间的继承关系
11-19
通过分析这些代码，开发者可以更直观地理解C#中的继承和多态是如何工作的，并学习如何将这些概念应用到实际项目中。 总结来说，本主题涉及了C#中的面向对象编程，主要集中在继承和多态这两个关键特性。通过Shape...
C#关于函数继承关系
qq_40203714的博客
12-14 1031
定义: “类继承其基类的成员。 继承是指隐式包含其基类的所有成员的类，实例和静态构造函数以及基类的终结器除外。” 先考察该定义中的隐式包含基类所有成员的类。 通过下面的代码段及代码结果来比较清楚地理解： using System; using System.Collections.Generic; using System.Linq; using System.Text; using Sys...
.NET和NET CORE 100道基础面试题
极客神殿
04-12 9189
1.面向对象的语言特性？ A：封装性、继承性、多态性。 2.在.NET中所有类的基类是？ A：Object。 3.在C#中，&和&&的区别？ A：&是按位与运算符(或取地址运算符)，&&是条件与运算符(也叫逻辑与运算符)。 4.委托声明的关键字是？ A：delegate。 5.在.NET中所有可序列化的类都被标记为？ A：Serializable。 6.一个类不想被继承应该？ A：标记为sealed。 7.简单描述CLR? A：CLR(Common Langu
【C#】构造函数继承父类的构造函数
最新发布
指错||纠正||建议||水评+点赞&&评论&&关注&&转发，在这里你大概率会有所收获
05-17 324
在C#中，构造函数是一种特殊的方法，它的主要任务是在创建对象时初始化对象。构造函数的名称与类的名称完全相同，且不返回任何值。 在C#中，构造函数并不直接支持继承。每个类都有自己的构造函数，用于初始化该类的新实例。但是，有一种机制叫做“构造函数链”，它允许子类在其构造函数中调用父类的构造函数，以便初始化从父类继承的字段或执行父类构造函数中的其他操作。 这是通过在子类的构造函数中使用:base(...)语法来完成的，其中(...)是父类构造函数所需的参数（如果有的话）。
C# 继承的详细介绍和使用
qq_35320456的博客
02-02 2243
C# 继承的详细介绍和使用
C# 继承详解
W_H_M_2018的博客
12-15 4378
简介 继承(封装、多态)是面向对象编程三大特性之一，继承的思想就是摈弃代码的冗余，实现更好的重用性。 继承从字面上理解，无外乎让人想到某人继承某人的某些东西，一个给一个拿。这个语义在生活中，就像家族继承财产，爷爷将财产继承给儿女，儿女在将财产继承给子孙，有些东西可以继承有些的东西只继承给某人。映射到编程当中，其思想也大致如此。 通过示例引出继承的作用 在代码中定义个三个类：Cat猫、Dog狗、Cattle牛。 从类图上可以看出红色标识区域，三个类的定义出现了大量的冗余(字段、属性、方法)，那么
c# --- 继承与重写函数
qq_51947882的博客
08-16 1995
1. 实现继承其实就是类的继承 ---- 父类（基类），子类（派生类）2.子类中重写父类函数的实现代码后，再通过子类调用这个函数的话，就能够执行重写后的代码了3.c#不支持多重类继承，但支持多重接口继承4.在c#中每一个类都必须具有一个父类，且只能有一个父类。当你没有给一个类指定父类的时候，编译器就会给这个类指定一个默认的父类 Object ，如果给一个类指定了一个父类后，Object父类就会被替代，然后新的父类不会出现被替代的情况。......
c#面向对象——继承
03-12
c#面向对象——继承
c sharp——继承.txt
08-17
方法修饰符的介绍，protected在父子是否访问，sealed的介绍 object的主要两个方法，清屏函数，传递给下一代的方法
c#视频教程c#视频教程
11-05
在"C#视频教程"中，我们可以期待学习到以下关键知识点： 1. **基础语法**：包括变量、数据类型、控制流（如if语句、for循环、while循环）、函数和数组等基本概念。这些都是学习任何编程语言的基石。 2. **面向对象...
c#入门-继承，多态
zms9110750的博客
01-26 805
当多个类型具有相同的成员时，可以使用继承来少写代码。继承语法为：类型名+冒号+被继承的类型名。
C#中类静态成员的继承（注：static知识是wpf依赖项属性的基础，wpf开发者必须得掌握）
极客神殿
08-23 1208
c#中静态的字段或方法，是可以被子类继承的。 但是，存在如下问题需要注意： （1）子类继承的字段，并不属于子类，仍然属于父类。 （2）在子类中修改了父类的静态字段，则父类的静态字段就确实被改了。 （3）在子类中可以用同名的静态字段覆盖父类的静态字段，但是不能使用virtual和override关键字。不过，vs中在子类中会给出警告提示，但确实可以正确运行。 （4）在子类的实例方法中可以直接操作父类的静态字段，而无需用“父类类名.字段名”的调用方法。但是，当子类中具有同名的静态字段覆盖了父类的静态字段时，如果
C#对象的继承详解
Jackyoung66的博客
12-29 4411
C#中对象的继承，父类和子类的继承关系，以及抽象类与抽象方法的详解
C# 继承(inheritance)
weixin_47336109的博客
10-03 2595
派生类是对基类的扩展，派生类可以添加新的成员，但不能移除已经继承的成员的定义。继承是可以传递的。如果 C 从 B 中派生，B 又从 A 中派生，那么 C 不仅继承了 B 中声明的成员，同样也继承了 A 中声明的成员。构造函数和析构函数不能被继承，除此之外其他成员能被继承。基类中成员的访问方式只能决定派生类能否访问它们...
C#基础知识点总结（三）- 继承
weixin_43152495的博客
10-19 3175
继承：虚方法，多态，隐藏，抽象，密封，派生类构造函数 修饰符：public等 接口 is和as
C# 可访问和继承关键字总结（自己部分总结，还是觉得这两个放在一起好些）
qq_32584715的博客
03-12 459
关于C#访问修饰符，看别人的总结不是给个表，然后那些情况符合，看的让人困惑，或许他们的总结是因为他们对基础十分熟悉，能够做到从高处往下看。我的总结想想，倒是一种细分，从不同角度划分。下面就从不同角度试着看看，细致划分(其中会掺杂相关在我看来比较重要的补充)，更利于学习理解。 一、类成员 可访问性修饰符： public 公共，整个项目可访问使用 private 私有，类内部（比如嵌套类 ）或者累得实例可使用 protected 受保护的，派生类以及程序集 i...
C#静态类的继承等疑惑解答
Heroin的博客
08-15 6307
文章本人原创，请勿随意粘贴转载 1.静态类可以从静态类中派生吗？ 静态类不允许从静态类中进行派生，也不允许从非静态类中派生，静态类必须从对象派生（个人觉得可能静态类不允许继承类），不允许有非静态的构造函数。下面代码会报错 public static class staFun { static staFun() { Consol...
【C#基础】static和继承
qq_61845982的博客
09-11 865
本文就介绍了static和继承的基础内容。一、Static我们建立了三个类，Person,Student,Teacher语法 ---》class 类名:你需要继承类名{set;}}{set;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

暄踽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值