C#核心6——面向对象继承

1.继承的基本规则

1.基本概念

一个类A继承一个类B

类A将会继承类B的所有成员

A类将拥有B类的所有特征和行为

被继承的类称为 父类、基类、超类

继承的类称为子类、派生类

子类可以有自己的特征和行为    

特点：

1. 单根性 子类只能有一个父类
2. 传递性 子类可以间接继承父类的父类  

2.基本语法

class 类名 : 被继承的类名
{

}

3.实例 

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

4.访问修饰符的影响

public——公共 内外部访问

private——私有 内部访问

protected——保护 内部和子类访问

之后讲命名空间的时候讲

intternal——内部的 只有在同一个程序集的文件中，内部类型或者是成员才可以访问

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

概念：C#中允许子类存在和父类同名的成员

但是 极不建议使用

    class Program
    {
        static void Main(string[] args)
        {
            TeachingTeacher tt = new TeachingTeacher();
            tt.name = "张三";
            tt.number = 1;
            tt.SpeakName();
 
            tt.subject = "Unity";
            tt.SpeakSubject();
 
            ChineseTeacher ct = new ChineseTeacher();
            ct.name = "李四";
            ct.number = 2;
            ct.subject = "语文";
            ct.SpeakName();
            ct.SpeakSubject();
            ct.Skill();
        }
    }

6.总结

继承基本语法

class 类名:父类名

1. 单根性：只能继承一个父类
2. 传递性：子类可以继承父类的父类。。。的所有内容
3. 访问修饰符 对于成员的影响
4. 极不建议使用 在子类中申明和父类同名的成员（以后学习了多态再来解决这个问题）

2.里氏替换原则 

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

3.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();
                }
            }

 4.总结

概念：父类容器装子类对象

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

使用：is和as

        is 用于判断

        as 用于转换

注意：不能用子类装父类对象