Lession08 继承和多态

多态：

 /*
     * 多态：多种形态的意思，重载也是多态的一种，今天讲解的多态的另一种形式，重写
     * 重写有两个关键字，virtual（虚拟的） 和 override(覆盖)
     * 重写：就是在子类中对父类的方法进行修改或者说在子类中对它进行重新编写
     * 使用方法：
     * 1.virtual关键字用于将父类的方法定义为虚方法
     * 2.在子类中使用override关键字重写父类的虚方法
     */

using System;

namespace ConsoleApp1
{
    /*
    * 多态：多种形态的意思，重载也是多态的一种，今天讲解的多态的另一种形式，重写
    * 重写有两个关键字，virtual（虚拟的） 和 override(覆盖)
    * 重写：就是在子类中对父类的方法进行修改或者说在子类中对它进行重新编写
    * 使用方法：
    * 1.virtual关键字用于将父类的方法定义为虚方法
    * 2.在子类中使用override关键字重写父类的虚方法
    */
    class Person
    {
        public int age; 
        public string name;
        public virtual void Speak()
        {
            Console.WriteLine("你好，我是{0},还是学生，我要好好学习，天天向上", this.name);
        }
    }
    class Student : Person
    {
         
    }
    class Teacher : Person
    {
        public override void Speak()
        {
            Console.WriteLine("你好，我是{0},还是老师，我要好好学习，天天向上", this.name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Student s = new Student();
            s.name = "屈增辉";
            s.Speak();
            Teacher t = new Teacher();
            t.name = "付亚东";
            t.Speak();
            Console.ReadKey();
        }
    }
}

 继承：

 /*
     * 我们可能会在一些类中，写一些重复的成员，我们可以将这些重复的成员单独封装到一个类中
     * 作为这些类的父类
     * 一.继承的语法：
     * 只需要吧父类的类名写在类名的后面，加上“：”号即可
     * class 类名：父类{
     * 
     * 
     * }
     * 
     * 二.一旦继承了某个类，那么就会拥有那个类的特征（成员变量）和行为（成员方法）
     * 被继承的类称之为父类或者基类，继承了其他类的类叫做子类或者派生类
     * 
     * 总结：
     * 1.继承单根性：一个类只能有一个父类，单继承
     * 2.继承的传递性：A类被B类继承，B类被C类继承，那么C类就拥有A类和B类的所有成员变量和方法
     * 
     * 三.继承中的构造方法
     * 构造方法不能被继承，但子类会自动调用父类的构造方法，以帮助子类初始化成员变量
     * 
     * 四.通过使用base关键字，派生类的构造方法可以显式调用基类的构造方法，运行是，首先执行的是基类的构造方法，
     * 然后执行子类的构造方法
     * 
     * 五.使用base来访问父类的成员
     * this:代表当前类的对象
     * base:就是在子类中调用父类的成员时使用
     * 
     * 六.protected访问修饰符。保护的意思，如果使用protected修饰的成员允许被子类访问，其他类不能访问
     * 
     * 七：Object类：
     * 在.net中所有的类都派生自一个名了Object的类，如果类定义时，没有指定父类，那么编译是，编译器会自动设定这个类直接派生自object类
     * 
     * 八：密封类
     * 定义密封类需要使用sealed关键字
     * 语法：sealed class 类名{}
     * 不允许继承这个类的时候，就可以写为密封类
     * 
     */

using System;

namespace ConsoleApp1
{
    /*
   * 我们可能会在一些类中，写一些重复的成员，我们可以将这些重复的成员单独封装到一个类中
   * 作为这些类的父类
   * 一.继承的语法：
   * 只需要吧父类的类名写在类名的后面，加上“：”号即可
   * class 类名：父类{
   * 
   * 
   * }
   * 
   * 二.一旦继承了某个类，那么就会拥有那个类的特征（成员变量）和行为（成员方法）
   * 被继承的类称之为父类或者基类，继承了其他类的类叫做子类或者派生类
   * 
   * 总结：
   * 1.继承单根性：一个类只能有一个父类，单继承
   * 2.继承的传递性：A类被B类继承，B类被C类继承，那么C类就拥有A类和B类的所有成员变量和方法
   * 
   * 三.继承中的构造方法
   * 构造方法不能被继承，但子类会自动调用父类的构造方法，以帮助子类初始化成员变量
   * 
   * 四.通过使用base关键字，派生类的构造方法可以显式调用基类的构造方法，运行是，首先执行的是基类的构造方法，
   * 然后执行子类的构造方法
   * 
   * 五.使用base来访问父类的成员
   * this:代表当前类的对象
   * base:就是在子类中调用父类的成员时使用
   * 
   * 六.protected访问修饰符。保护的意思，如果使用protected修饰的成员允许被子类访问，其他类不能访问
   * 
   * 七：Object类：
   * 在.net中所有的类都派生自一个名了Object的类，如果类定义时，没有指定父类，那么编译是，编译器会自动设定这个类直接派生自object类
   * 
   * 八：密封类
   * 定义密封类需要使用sealed关键字
   * 语法：sealed class 类名{}
   * 不允许继承这个类的时候，就可以写为密封类
   * 
   */
   class Person
    {
        public Person()
        {
            Console.WriteLine("我是父类的无参数的构造方法");
        }
        public Person(string Name,int Age)
        { 
            this.name = Name;
            this.age = Age;
            Console.WriteLine("我是父类的有参数的构造方法");
        }
        public int age;
        public string name;
        public void Speak()
        {
            Console.WriteLine("你好，我是{0}", name);
        }
    }
    //继承自Person类
    class Student:Person
    {
        public Student()
        {
            Console.WriteLine("我是子类的无参数的构造方法");
        }
        public Student(string Name, int Age, int StuId) : base(Name,Age)
        {
            this.stuID = StuId;
            Console.WriteLine("我是一个有参数的子类构造方法");
        }
        public int stuID;
        public void Study()
        {
            base.Speak();
            Console.WriteLine("我是一个好学习的学生，我不瞌睡，我爱写代码，我一写代码，我就精神了");
        }
    }
    //写一个密封类
    sealed class Circle
    {
        public int radius;//半径
        public double GetInfo()
        {
            return 2 * Math.PI * radius;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Student s = new Student();
            s.name = "屈增辉";
            s.age = 20;
            s.stuID = 1002;
            s.Study();
            s.Speak();
            Console.WriteLine("---------------------------");
            Student s2 = new Student("何帅", 19, 1002);
            Person p = new Person();
            Console.ReadKey();
        }
    }
}

 继承练习：

using System;

namespace ConsoleApp1     //继承练习
{
    class Program
    {
        static void Main(string[] args)
        {

            Console.ReadKey();
        }
    }
    public class Person
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        private char gender;
        public char Gender
        {
            get { return gender; }
            set { gender = value; }
        }
        public void CHLSS()
        {
            Console.WriteLine("吃喝拉撒睡");
        }
        public Person(string name, int age, char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }

    }
    public class student : Person
    {
        public student(string name, int age, char gender, int id):base(name, age, gender)
        {
            this.Id = id;
        }
        private int id;
        public int Id
        {
            get { return id; }
            set { id = value; }
        }
        public void Study()
        {
            Console.WriteLine("学生会学习");
        }
    }
}