面向对象--3

继承
一、什么继承？
1.父类的相关成员，会自动派生到子类去。public protected
2.子类可以扩展父类的相关成员。
3.子类可以替代父类来使用，但父类不能替代子类来使用。
二、继承的语法：
class 子类名:父类名
{
    
}
三、继承的规则：
（一）成员变量的继承
1.public protected
2.如果同名就隐藏。子类与父类各自用各自的成员。
（二）属性的继承
1.属性一般只有public
2.如果同名就隐藏。子类与父类各自用各自的成员。
（三）方法的继承
1.public protected
2.如果同名就隐藏。子类与父类各自用各自的成员。
3.重写：
    a.把父类的方法设为虚方法，virtual。——父类说：这个方法可以被重写。
    b.在子类中，使用override来重写父类中的方法。——子类确认我重写这个方法。

注意：    1.如果父类方法中没有声明virtual，子类中有override重写它。会报错。
    2.如果父类中声明了virtual,子类中没有override去重写它，不会报名，但会被隐藏。
    3.虚方法一虚到底。子类即使override父类的虚方法，子类的这个方法依然还是虚方法。

（四）构造函数的继承
1.如果父类没有写构造函数，或者父类构造函数没有参数。子类的构造函数没有特殊要求。
2.如果父类的构造函数都有参数，子类构造函数必须向父类构造函数中传递值。base();

注：在子类中调用父类的方法时，可以使用base.xxxx来调用。一般用调用父类被重写的方法。

base--父类对象。
this--当前对象。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Ren
    {
        private string _Name;

        public string Name
        {
            get { return _Name; }
            set { _Name = value; }
        }
        private int _Age;

        public int Age
        {
            get { return _Age; }
            set { _Age = value; }
        }
        public virtual void Speak()
        {
            Console.WriteLine("我的名字叫："+Name+",   今年已经"+Age+"岁了！");
        }
    }
    class Nvren:Ren
    {
        private readonly bool _Sex = false;

        public bool Sex
        {
            get { return _Sex; }
        }
        public Nvren(string name, int age)
        {
            Name = name;
            Age = age;
        }
        public override void Speak()
        {
            Console.WriteLine("我是一名女士，我的名字叫：" + Name + ",   今年已经" + Age + "岁了！");
        }
        public void Born()
        {
            Console.WriteLine("生小孩了！");
        }
    }
    class Girl : Nvren
    {
        private string _School;

        public string School
        {
            get { return _School; }
            set { _School = value; }
        }
        public Girl(string name, int age, string school):base(name,age)
        {
            //this.Name = name;
            //this.Age = age;
            this.School = school;
        }
        public override void Speak()
        {
            Console.WriteLine("我是一名女孩，正在"+School+"   读书，我的名字叫：" + Name + ",   今年已经" + Age + "岁了！");
            //base.Speak();
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Nvren nv = new Nvren("徐丽", 22);
            nv.Speak();
            Ren r = new Ren();
            r.Speak();

            //r = nv;
            //r.Speak();
            Girl g = new Girl("徐丽",22,"江州大学");
            r = g;
            r.Speak();
            Console.ReadLine();
        }
    }
}

多态：不是一个新东西。主要是在继承的基础上实现出来的。
多态分类：静态多态（编译多态），动态多态（运行多态）。
静态多态（编译多态）：方法重载来实现的。
动态多态（运行多态）：继承和重写来实现的。

多态的实现是：父类的引用指向子类的实例。当指向不同子类的时候，父类引用调用子类方法的时候，呈现出不同的形态。

例子：
1.喂动物
2.中国人、美国人、野人一起吃饭

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Human
    {
        public virtual void Eat()
        {

            Console.Write("正在吃饭：");
        }
    }
    class Chinese:Human
    {
        public override void Eat()
        {
            base.Eat();
            Console.WriteLine("在使用筷子吃饭");
        }
    }
    class American : Human
    {
        public override void Eat()
        {
            base.Eat();
            Console.WriteLine("在使用刀叉吃饭");
        }
    }
    
    class Class1
    {
        public static void Main(string[] args)
        {
            Chinese c = new Chinese();
            American a = new American();

            QingKe(c);

            
        }
        public static void QingKe(Human pengyou)
        {
            pengyou.Eat();
        }
    }
}

抽象类：
对事物进行高度的抽象，抽象到一定程度，无法去具体描述。
抽象方法：只有方法的声明，没有方法的实现。只有函数名、输入形参、返回类型，没有函数体。
关键词：abstract
抽象类与抽象方法的关系：
1.含有抽象方法的类一定是抽象类
2.抽象类不一定包括抽象方法。



抽象类是无法被实例化的类。不能new出来。
遇到抽象类一般来说就是两种处理思路：1.找该抽象类的派生类，使用其派生类。2.自己继承此抽象类，实现其派生类。

对于抽象方法，子类也必须使用override来实现父类中的抽象方法。