C#学习笔记（十三）：继承

继承

object是引用类型

public：最高权限，公开的

Protected：外部不可以访问

Internal：类的默认访问是什么作用域

Private：类成员默认

 

基类实例：可以通过base调用父类的指定方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace m1w3d4_inherit
{
    #region 继承
    //
    class Person
    {
        protected String name;
        protected string sex;
        protected int age;
        protected String hobby;
        public Person(string name, string sex, int age, string hobby)
        {
            this.name = name;
            this.sex = sex;
            this.age = age;
            this.hobby = hobby;
        }
        public Person()//没有无参构造，派生类会报错，派生类是根据基函数的默认构造构造的，如果已有base指定的构造函数，可以删除但不建议
        {
        }
        public void SayHello()
        {
            Console.WriteLine("你好，我是{0}，{1}，我今年{2}岁了，爱好是{3}", name, sex, age, hobby);
        }
    }
    class Teacher : Person //之类:父类 只能直接继承一个父类
    {
        public Teacher(string name, string sex, int age, string hobby) : base(name, sex, age, hobby)
        {
            Console.WriteLine("我是Person的基类");
        }
        public void Teach()
        {
            Console.WriteLine("我在教书");
        }
    }
    //如果我们定义了若干类，这些类都有一些共有的属性和方法
    //我们可以把这些共有部分抽象建立一个新的类，作为基类
    //已解决我们代码重复的问题，以便于管理
    //如果继承关系建立，子类的构造函数将会默认指向父类的无参构造
    //我们可以通过this调用自身的另一个构造函数
    //我们可以通过base调用父级的构造函数
    //继承：子类继承的是父类所有成员
    //但是你只能访问父类成员作用域允许的成员，除了private
    //如果你的成员需要外部访问，只能是public
    //如果你在子类里写一个和父类的同名同参数列表的方法，你可以使用new
    //当你new
    //记者（reporter）：我是一个男性狗仔 我今年34了 。爱好是偷拍。
    //有两个方法 偷拍 和 自我介绍
    //
    //司机（driver）：我叫张三 男 我43岁了 ，爱好打蓝球。
    //有两个方法 打蓝球 和 自我介绍
    //
    //程序员(programmer)：我叫李四 我23 ，喜欢看电影。
    //有两个方法 看电影 和 自我介绍
    //
    //抽象出上面三个类的基类，并在其构造函数中打印我是基类
    class Reporter : Person
    {
        string name;
        public Reporter(string name, string sex, int age, string hobby) : base(name, sex, age, hobby)
        {
            Console.WriteLine("我是Person的基类");
        }
        public void SetName(string name)
        {
            this.name = name;
        }
        public void Photo()
        {
            base.SayHello();//可以通过base调用父类的隐藏成员
            Console.WriteLine("我在偷拍");
        }
        public void SayHello()//子类声明的成员，与父类的成员重名，父类的成员被隐藏
        {
            Console.WriteLine("我是{0}，我{1}岁，我的爱好是{2}", name, age, hobby);
        }
    }
    class Driver : Person
    {
        public Driver(string name, string sex, int age, string hobby) : base(name, sex, age, hobby)
        {
            Console.WriteLine("我是Person的基类");
        }
        public void PlayBasketball()
        {
            Console.WriteLine("我在打篮球");
        }
    }
    class Programmer : Person
    {
        public Programmer(string name, string sex, int age, string hobby) : base(name, sex, age, hobby)
        {
            Console.WriteLine("我是Person的基类");
        }
        public void Movie()
        {
            Console.WriteLine("我在看电影");
        }
    }
    #endregion
    #region 里氏转换练习
    //如果你定义了一个类，不希望别人继承，你可以将其密封 使用sealed关键字放在最前边
    class Monster
    {
        protected string name;
        public Monster(string name)
        {
            this.name = name;
        }
        protected int attack;
        public void Attack()
        {
            Console.WriteLine("我是{0}，我的攻击力{1}，怕不怕", name, attack);
        }
    }
    class Goblin : Monster
    {
        public Goblin(string name) : base("哥布林" + name)
        {
            attack = Program.roll.Next(5, 16);
        }
    }
    class Boss : Monster
    {
        public Boss(string name) : base("哥布林" + name)
        {
            attack = Program.roll.Next(35, 56);
        }
        public void Skill()
        {
            Console.WriteLine("在我{0}面前颤抖吧，凡人，我的攻击力是{1}", name, attack);
        }
    }
    #endregion
    class Program
    {
        public static Random roll = new Random();
        static void Main(string[] args)
        {
            #region 继承
            //
            Person p1 = new Person("老刘", "男", 33, "呵呵");
            p1.SayHello();
            Teacher t = new Teacher("老王", "男", 35, "教书");
            t.SayHello();
            t.Teach();
            Console.WriteLine();
            Reporter r = new Reporter("男性狗仔", "", 34, "偷拍");
            r.SayHello();
            r.Photo();
            r.SetName("奥巴马");
            r.SayHello();
            Console.WriteLine();
            Driver d = new Driver("张三", "男", 43, "打篮球");
            d.SayHello();
            d.PlayBasketball();
            Programmer p = new Programmer("李四", "", 23, "看电影");
            p.SayHello();
            p.Movie();
            //1、子类（Reporter）可以当父类（Person）用
            //一个对象的实际类型是指他被构造出来时的类型
            //2、如果父类中的实际对象是子类，我们可以将其转成子类
            Reporter reporter = new Reporter("张三", "男", 43, "打篮球");//会退去子类所有的特性
            Person reporterPerson = reporter;
            reporterPerson.SayHello();
            Reporter reporterPersonConvert = (Reporter)reporterPerson;
            reporterPersonConvert.SayHello();
            Person person = new Person("李四", "", 23, "看电影");
            //Reporter personConvert = (Reporter)person;// 实际对象不是子类，强转会报错
            //personConvert.SayHello();
            //is关键字 可以帮助我们判定一个对象中是否包含另一个对象类型
            //对象 is 包含的类型
            if (reporterPersonConvert is Reporter)
            {
                Console.WriteLine("可以转换");
            }
            else
            {
                Console.WriteLine("不可以转换");
            }
            if (person is Reporter)
            {
                Console.WriteLine("可以转换");
            }
            else
            {
                Console.WriteLine("不可以转换");
            }
            //as关键字 尝试性转换，如果转换成功则返回对应类，不成功则返回null
            //对象 as 尝试转换的类型
            Person check = reporterPersonConvert;
            Reporter reporterAS = check as Reporter;
            reporterAS.SayHello();
            #endregion
            #region 里氏转换练习
            Monster[] monsters = new Monster[10];
            for (int i = 0; i < monsters.Length; i++)
            {
                if (i == 0)
                {
                    //里氏转换第一原则 把子类当父类用
                    monsters[i] = new Boss("阿布");
                }
                else
                {
                    monsters[i] = new Goblin(i + "号");
                }
            }
            for (int i = 0; i < monsters.Length; i++)
            {
                monsters[i].Attack();
                if (monsters[i] is Boss)
                {
                    ((Boss)monsters[i]).Skill();
                }
            }
            #endregion
        }
    }
}