C#学习教程06——继承

最新推荐文章于 2024-05-17 13:42:57 发布
最新推荐文章于 2024-05-17 13:42:57 发布
阅读量758 收藏 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#对象的继承详解
Jackyoung66的博客
12-29 4384
C#中对象的继承，父类和子类的继承关系，以及抽象类与抽象方法的详解
c#入门-继承，多态
zms9110750的博客
01-26 801
当多个类型具有相同的成员时，可以使用继承来少写代码。继承语法为：类型名+冒号+被继承的类型名。
【C#】构造函数继承父类的构造函数
最新发布
指错||纠正||建议||水评+点赞&&评论&&关注&&转发，在这里你大概率会有所收获
05-17 297
在C#中，构造函数是一种特殊的方法，它的主要任务是在创建对象时初始化对象。构造函数的名称与类的名称完全相同，且不返回任何值。 在C#中，构造函数并不直接支持继承。每个类都有自己的构造函数，用于初始化该类的新实例。但是，有一种机制叫做“构造函数链”，它允许子类在其构造函数中调用父类的构造函数，以便初始化从父类继承的字段或执行父类构造函数中的其他操作。 这是通过在子类的构造函数中使用:base(...)语法来完成的，其中(...)是父类构造函数所需的参数（如果有的话）。
对象的三大特性
LiPing122335的博客
10-12 2821
一 封装 1.1 定义 封装（what）：将类的某些信息隐藏在类内部(private)，不允许外部程序直接访问，而是通过该类提供的公共属性(public）来实现对隐藏信息的操作和访问。 1.2 作用 Why：防止类中的数据被恶意修改 1.3 封装的好处 1、隐藏类的实现细节 2、只能通过规定属性访问数据 3、方便加入控制语句 4、方便修改实现 二 继承 2.1定义 一个类具有另一个类的属性和方法，这个类叫子类（派生类），另一个类叫父类（基类、超类） 2.2 ..
C#基础知识点总结（三）- 继承
weixin_43152495的博客
10-19 3168
继承：虚方法，多态，隐藏，抽象，密封，派生类构造函数 修饰符：public等 接口 is和as
【C# 学习笔记 ③】C#面向对象编程（基础概念、静态成员、继承、多态 =＞ 虚方法、接口、抽象类及它们的区别）
一个努力学习的程序猿
09-05 519
C#面向对象编程的相关基础概念，静态成员，继承、多态 => 虚方法、接口、抽象类及它们的区别。
c#类与对象的继承与多态——图形间的继承关系
11-19
通过分析这些代码，开发者可以更直观地理解C#中的继承和多态是如何工作的，并学习如何将这些概念应用到实际项目中。 总结来说，本主题涉及了C#中的面向对象编程，主要集中在继承和多态这两个关键特性。通过Shape...
c#面向对象——继承
03-12
c#面向对象——继承
c sharp——继承.txt
08-17
方法修饰符的介绍，protected在父子是否访问，sealed的介绍 object的主要两个方法，清屏函数，传递给下一代的方法
c#视频教程c#视频教程
11-05
在"C#视频教程"中，我们可以期待学习到以下关键知识点： 1. **基础语法**：包括变量、数据类型、控制流（如if语句、for循环、while循环）、函数和数组等基本概念。这些都是学习任何编程语言的基石。 2. **面向对象...
C#_单元四——面向对象编程.pdf
07-06
C#语言是支持OOP概念的强大工具，常用于构建各种应用程序，包括C/S模式的系统，如"职苑物业管理系统"。 在OOP中，类（Class）是核心概念，它是对象（Object）的模板或蓝图，描述了一组具有相同属性和行为的对象。类...
C#什么是继承？如何实现继承？
01-16
什么是继承？如何实现继承？ New 关键字的作用构造函数有无返回值静态构造函数和实例构造函数的区别析构函数的作用 New 关键字的作用构造函数有无返回值静态构造函数和实例构造函数的区别析构函数的作用New 关键字的作用构造函数有无返回值静态构造函数和实例构造函数的区别析构函数的作用
C# 可访问和继承关键字总结（自己部分总结，还是觉得这两个放在一起好些）
qq_32584715的博客
03-12 457
关于C#访问修饰符，看别人的总结不是给个表，然后那些情况符合，看的让人困惑，或许他们的总结是因为他们对基础十分熟悉，能够做到从高处往下看。我的总结想想，倒是一种细分，从不同角度划分。下面就从不同角度试着看看，细致划分(其中会掺杂相关在我看来比较重要的补充)，更利于学习理解。 一、类成员 可访问性修饰符： public 公共，整个项目可访问使用 private 私有，类内部（比如嵌套类 ）或者累得实例可使用 protected 受保护的，派生类以及程序集 i...
C# 类的继承
qq_42607586的博客
02-23 1918
1.我们可能会在一些类中，写一些重复的成员，我们可以将这些重复的成员，单独的封装到一个类中，作为这些类的父亲；5.代码块:父类:Person;子类:student;3.子类继承了父亲，那么子类从父亲哪里继承过来了什么？（1）继承的单根性，一个子类只能有一个父类；4.问题：子类有没有继承父类的构造函数？
java. base关键字_C# base关键字：调用父类成员方法
weixin_42412250的博客
03-02 499
在上一节《C# VS2015类图的使用》中介绍的继承关系的类图中可以看出，在每个类中都有 Print 方法，即子类和父类中有同名的方法。那么这种方式是方法的重载吗？答案是否定的，方法重载是指方法名相同而方法的参数不同的方法。在 C# 语言中子类中定义的同名方法相当于在子类中重新定义了一个方法，在子类中的对象是调用不到父类中的同名方法的，调用的是子类中的方法。因此也经常说成是将父类中的同名方法隐藏了...
C#继承和派生
weixin_42715287的博客
08-15 1309
用户在程序中会遇到 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 { .
C# 使用继承（一）
weixin_40875853的博客
06-05 7238
继承的含义 编程上的继承和我们现实意义上的继承有点不一样，在现实意义上继承是您的家人遗产传给了你，这就是现实继承，在编程上继承是指派生类（子类）和母类形成一种联系。 继承作用 为什么我们要使用继承，使用继承是为了减少重复写方法，什么意思，例如我们写个类名叫DOG,我们想想狗能做什么，能跑，能叫，能吃饭，能睡觉，然后我们再创建一个CAT类，猫能做什么，猫是不是也是能跑，能叫，能吃饭，能睡觉。如...
C#继承(二)——实现继承
wuzhanwen的博客
11-19 3392
如果要声明派生自另一个类的一个类，就可以使用下面的语法： class MyClass: MyBaseClass { //成员 } 如果类（或结构）也派生自接口，则用逗号分隔列表中的基类和接口： public class MyClass: MyBaseClass, IInterface1, IInterface2 { //成员 } 　 如果类和接口都用于派生，则类总
C#构造函数继承
热门推荐
wangsen2235068的专栏
10-14 1万+
//继承的类，子类会调用父类无参的构造函数。从底层开始，一个父类，一个父类的调用. public class MyClass { public MyClass() { Console.WriteLine("MyClass:默认构造函数"); } public MyClass(int a,

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

暄踽

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

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

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

打赏作者

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

抵扣说明：

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

余额充值