【C#核心】面向对象三特性之继承 (全面总结,建议收藏)

原创于 2024-08-12 18:45:00 发布 · 566 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#c# #开发语言 #面向对象 #继承

技术进阶专栏收录该内容

6 篇文章

订阅专栏

引言

继承是C#面向对象编程中的核心概念之一，它提供了一种强大的方式，允许开发者构建层次化的类结构，实现代码复用和功能扩展。然而，合理使用继承也很重要，以避免过度耦合和脆弱性问题。理解继承的力量与艺术，将使你能够更有效地应用面向对象的原则来解决实际问题。

一、继承的基本规则

1.基本概念

一个类 A 继承一个类 B
类 A 将会继承类 B 的所有成员
A 类将拥有 B 类的所有特征和行为
被继承的类
称为父类基类超类
继承的类
称为子类派生类
子类可以有自己的特征和行为
特点
1.单根性子类只能有一个父类
2.传递性子类可以间接继承父类的父类

2.基本语法

class 类名 : 被继承的类名
{

}

3.实例

    class Test
    {

    }
    class Teacher
    {
        // 姓名
        public string name;
        // 职工号
        protected int number;
        // 介绍名字
        public void SpeakName()
        {
            number = 10;
            Console.WriteLine(name);
        }
    }
    class TeachingTeacher : Teacher
    {
        // 科目
        public string subject;
        // 介绍科目
        public void SpeakSubject()
        {
            number = 11;
            Console.WriteLine(subject + "老师");
        }
    }
    class ChineseTeacher : TeachingTeacher
    {
        public void Skill()
        {
            Console.WriteLine("一行白鹭上青天");
        }
    }

4.使用

            Console.WriteLine("继承的基本规则");
            TeachingTeacher tt = new TeachingTeacher();
            tt.name = "Unity打怪升级";
            // tt.number = 1;
            tt.SpeakName();
            tt.subject = "Unity";
            tt.SpeakSubject();
            ChineseTeacher ct = new ChineseTeacher();
            ct.name = "Unity";
            // ct.number = 2;
            ct.subject = "语文";
            ct.SpeakName();
            ct.SpeakSubject();
            ct.Skill();

5.访问修饰符的影响

public - 公共内外部访问
private - 私有内部访问
protected - 保护内部和子类访问
之后讲命名空间的时候讲
internal - 内部的只有在同一个程序集的文件中内部类型或者是成员才可以访问

6.子类和父类的同名成员

概念
C# 中允许子类存在和父类同名的成员
但是极不建议适用

二、里氏替换原则

1.基本概念

里氏替换原则是面向对象七大原则中最重要的原则
概念:
任何父类出现的地方子类都可以代替
重点:
语法表现 – 父类容器装子类对象因为子类对象包含了父类所有内容
作用:
方便进行对象的存储和管理

2.基本实现

    class GameObject
    {

    }
    class Player : GameObject
    {
        public void PlayerAtk()
        {
            Console.WriteLine("玩家攻击");
        }
    }
    class Monster : GameObject
    {
        public void MonsterAtk()
        {
            Console.WriteLine("怪物攻击");
        }
    }
    class Boss : GameObject
    {
        public void BossAtk()
        {
            Console.WriteLine("Boss攻击");
        }
    }

3.使用

            Console.WriteLine("里氏替换原则");
            // 里氏替换原则 用父类容器 装载子类对象
            GameObject player = new Player();
            GameObject monster = new Monster();
            GameObject boss = new Boss();
            GameObject[] objects = new GameObject[] { new Player(), new Monster(), new Boss() };

4.is 和 as

            // 基本概念
            // is:判断一个对象是否是指定类对象
            // 返回值:bool 是为真 不是为假
            // as:将一个对象转换为指定类对象
            // 返回值:指定类对象
            // 成功返回指定类对象 失败返回 null
            // 基本语法
            // 类对象 is 类名 该语句块 会有一个 bool 返回值 true 和 false
            // 类对象 as 类名 该语句块 会有一个对象返回值对象和 null
            if(player is Player)
            {
                Player p = player as Player;
                p.PlayerAtk();
                (player as Player).PlayerAtk();
            }
            for(int i = 0; i < objects.Length; i++)
            {
                if(objects[i] is Player)
                {
                    (objects[i] as Player).PlayerAtk();
                }
                else if (objects[i] is Monster)
                {
                    (objects[i] as Monster).MonsterAtk();
                }
                else if (objects[i] is Boss)
                {
                    (objects[i] as Boss).BossAtk();
                }
            }

三、继承中的构造函数

1.知识回顾

    // 构造函数
    // 实例化对象时调用的函数
    // 主要用来初始化成员变量
    // 每个类都会有一个默认的无参构造函数
    // 语法
    // 访问修饰符 类名()
    // {

    // }
    // 不写返回值
    // 函数名和类名相同
    // 访问修饰符根据需求而定 一般为 public
    // 构造函数可以重载
    // 可以用 this 语法重用代码
    // 注意
    // 有参构造会定调默认的无参构造
    // 如想保留无参构造需重载出来
    class Test
    {
        public int testI;
        public string testStr;
        public Test()
        {

        }
        public Test(int i)
        {
            this.testI = i;
        }
        public Test(int i, string str) : this(i)
        {
            this.testStr = str;
        }
    }

2.继承中的构造函数基本概念

特点
当申明一个子类对象时
先执行父类的构造函数
再执行子类的构造函数
注意:
1.父类的无参构造很重要
2.子类可以通过 base 关键字代表父类调用父类构造

3.继承中的构造函数的执行顺序

    // 父类的父类的构造-->......父类构造-->...子类构造
    class GameObject
    {
        public GameObject()
        {
            Console.WriteLine("GameObject的构造函数");
        }
    }
    class Player : GameObject
    {
        public Player()
        {
            Console.WriteLine("Player的构造函数");
        }
    }
    class MainPlayer : Player
    {
        public MainPlayer()
        {
            Console.WriteLine("MainPlayer的构造函数");
        }
    }

4.父类的无参构造函数很重要

    // 子类实例化时 默认调用的是父类的无参构造 所以如果父类无参构造被顶掉 会报错
    class Father
    {
        public Father()
        {

        }
        public Father(int i)
        {
            Console.WriteLine("Father构造");
        }
    }

4.1.通过 base 调用指定父类构造

    class Son : Father
    {
        public Son(int i) : base(i)
        {
            Console.WriteLine("Son的一个参数的构造构造");
        }
        public Son(int i,string str) : this(i)
        {
            Console.WriteLine("Son的两个参数的构造构造");
        }
    }

5.使用

            MainPlayer mp = new MainPlayer();
            Son s = new Son(1, "123");

四、万物之父和装箱拆箱

1.里氏替换知识点回顾

    // 概念:父类容器装子类对象
    // 作用:方便进行对象存储和管理
    // 使用
    // is 和 as
    // is 用于判断
    // as 用于转换
    class Father
    {

    }
    class Son : Father
    {
        public void Speak()
        {

        }
    }

2.万物之父

万物之父
关键字:object
概念:
object 是所有类型的基类他是一个类(引用类型)
作用:
1.可以利用里氏替换原则用 object 容器装所有对象
2.可以用来表示不确定类型作为函数参数类型

3.万物之父的使用

            Father f = new Son();
            if (f is Son)
            {
                (f as Son).Speak();
            }
            // 引用类型
            object o = new Son();
            // 用 is as 来判断转换即可
            if (o is Son)
            {
                (o as Son).Speak();
            }
            // 值类型
            object o2 = 1f;
            // 用强转
            float f1 = (float)o2;
            // 特殊的 string 类型
            object str = "123123";
            string str2 = str as string;
            object arr = new int[10];
            int[] ar = arr as int[];

4.装箱拆箱

    // 发生条件
    // 用 object 存值类型(装箱)
    // 再把 object 转为值类型(拆箱)
    // 装箱
    // 把值类型用引用类型存储
    // 栈内存会迁移到堆内存中
    // 拆箱
    // 把引用类型存储的值类型取出来
    // 堆内存会迁移到栈内存中
    // 好处:不确定类型时可以方便参数的存储和传递
    // 坏处:存在内存迁移 增加性能消耗
    // 装箱
    object v = 3;
    // 拆箱
    int intValue = (int)v;
    TestFun(1, 2, 3, 4f, 34.5, "123123", new Son());
    #endregion
static void TestFun(params object[] array)
{

}

五、密封类

1.基本概念

密封类:是使用 sealed 密封关键字修饰的类
作用:让类无法再被继承

2.实例

    class Father
    {

    }
    sealed class Son : Father
    {

    }

3.作用

在面向对象程序的设计中密封类的主要作用就是不允许最底层子类被继承
可以保证程序的规范性安全性
目前对于大家来说可能用处不大
随着大家的成长以后制作复杂系统或者程序框架时便能慢慢体会密封的作用