C#类的继承、里氏替换原则、继承类的构造函数、子类访问父类、访问修饰符

原创于 2025-11-10 14:19:23 发布 · 398 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#c# #开发语言 #里氏替换原则 #visual studio #算法

ModelEngine·创作计划征文活动 10w+人浏览 1.7k人参与

•类的继承：

继承：根据现有的类，生成一个新的类

当创建一个类的时候，可以不需要重新编写成员方法和成员变量，而是继承现有的类

这个被继承的类我们称之为 “父类”(基类)，这个新的类我们称之为"子类"(派生类)

如果一个类没有继承任何类，那么他默认继承的就是object类，c#中所有的类，都直接或者间接继承object，object是所有类的“终极基类"

internal class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student()
            {
                name = "Test",
                age = 18,
                studentId = "888888",
                school = "传鼎"
            };
            student.eat();
            student.study();
            Student1 student1 = new Student1()
            {
                name = "abc",
                sex = 'a'
            };
            student1.study();
        }
    }
    // 基类  父类
    class People
    {
        public string name { get; set; }
        public int age { get; set; }
        public char sex { get; set; }
        public void eat()
        { Console.WriteLine("吃饭"); }
    }
    // 派生类  子类
    // 在定义一个类的时候 使用 ":" 基类  实现继承
    // 格式:  class 子类名 : 父类名
    // 当一个 类 继承 另一个类 的时候，子类 将自动拥有 父类的成员(成员变量和成员方法)
    class Student : People
    {
        public string studentId { get; set; }
        public string school { get; set; }
        public void study()
        { Console.WriteLine($"我是{name},在{school}学习"); }
    }
    //基类 和 派生类 并不是一个绝对的概念，是相对的，一个类可以是 基类 也可以是 派生类
    //一个父类 可以有 多个子类，一个类 可以同时是 子类 也是 父类
    class Student1 : People
    {
        public void study()
        { Console.WriteLine("这是Student1 的study方法"); }
    }
}

•里氏替换原则：

概念: 任何父类出现的地方，子类都可以替代

重点: 语法表现父类容器装子类对象 ,因为子类对象包含了父类的所有内容,不能用子类容器装父类对象

作用: 方便进行对象存储和管理

namespace 里氏替换原则
{
    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攻击"); }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            //里氏替换原则 用父类容器 装载子类对象
            GameObject player = new Player();
            GameObject monster = new Monster();
            GameObject boss = new Boss();
            GameObject[] objects = new GameObject[] { new Player(), new Monster(), new Boss() };
            // is和as

            //基本概念
            // is:判断一个对象是否是指定类对象
            //返回值:boo1 是为真 不是为假      

            // as:将一个对象转换为指定类对象
            //返回值:指定类型对象
            //成功返回指定类型对象，失败返回nu11

            //基本语法
            // 类对象 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.父类的无参构造很重要 2.子类可以通过base关键字代表父类调用父类构造

internal class Program
{
    static void Main(string[] args)
    {
        Student student = new Student();
        Console.WriteLine(student.id);
        Console.WriteLine(student.sex);
        Console.WriteLine(student.name);//郝
        student.Test();
        Console.WriteLine(student.name);//瑞
        People people = new People();
        Console.WriteLine(people.name);//郝
    }
}
class People
{
    public string name { get; set; }
    public char sex { get; set; }
    public readonly int id;
    public People()
    {
        Console.WriteLine("父类的构造函数");
        id = 12345;
        name = "郝文涌";
    }
}
class Student : People
{
    //当 new 一个类的时候，这个 子类 创建之前 父类就应该先存在了，因此会 先执行父类的 构造函数，然后再 执行子类的 构造函数
    public Student(string name)
    { name = "马"; }
    public Student()
    {
        Console.WriteLine("子类的构造函数");
        sex = '男';
    }
    public void Test()       
    {
        //子类可以直接操作定义在父类的属性和字段
        name = "瑞瑞";
    }
}

•子类访问父类：

internal class Program
{
    static void Main(string[] args)
    {
        Student student1 = new Student();
        Console.WriteLine(student1.Name);
        Console.WriteLine(student1.Sex);
        Student student2 = new Student("郝文涌");
        Console.WriteLine(student2.Name);
        Console.WriteLine(student2.Sex);
    }
}
class People
{
    public string Name { get; set; }
    public char Sex { get; set; }
    //类里面可以拥有多个同名但不同参数的方法,
    public People()
    { Console.WriteLine("Peopl的无参构造"); }

    public People(string name, char sex)
    {
        Console.WriteLine("Peopl的有参构造");
        Name = name;
        Sex = sex;
    }
}
class Student : People
{
    // 子类 被创建 的时候，会默认 执行父类的 无参构造方法，不会执行 有参构造方法
    //public Student():base()  自动生成 这样的代码，等价与 直接执行的是 父类的 无参构造方法
    public Student() : base()
    { Console.WriteLine("Student的无参构造"); }
    //子类中使用 base 表示父类
    //this  表示当前类
    //在子类的 构造函数后面添加 :base() 可以 直接执行父类的构造方法  
    public Student(string name) : base(name, '男')
    { Console.WriteLine("Student的有参构造"); }
}

•访问修饰符：

public :公共的公开的，当前类，子类，实例都可以访问

internal：只能在当前项目访问

protected:只有该类及子类可以访问，实例不能访问

private：私有的，仅能在当前类的内部访问，子类和实例都不能访问

protected internal：访问范围是当前程序集或继承该类的子类，满足任一条件即可访问

private protected：仅允许当前程序集内的子类访问，限制范围更严格

internal class Program
{
    static void Main(string[] args)
    {
        Student student = new Student();
        Console.WriteLine(student.a);
        //Console.WriteLine(student.b);
        Console.WriteLine(student.c);
       //Console.WriteLine(student.e);
        Console.WriteLine(student.e);
        student.Test();
    }      
}
public class People
{
    public int a = 111;
    private int b = 222;
    internal int c = 333;
    protected int d = 444;
    protected internal int e = 555;
    public void Test()
    {
        Console.WriteLine(a);
        Console.WriteLine(b);
        Console.WriteLine(c);
        Console.WriteLine(d);
        Console.WriteLine(e);
    }
}
class Student : People
{
    public void Test()
    {
        Console.WriteLine(a);
        //Console.WriteLine(b);
        Console.WriteLine(c);
        Console.WriteLine(d);
        Console.WriteLine(e);
    }
}