继承

类的继承性

子类隐式继承所有，包括，字段，属性，方法，事件，但私有成员，构造函数看，析构函数除外

同时为了防止类被继承，使用sealed 关键字  public scaled class Father {},也用于方法重写

构造函数

基类构造函数不能继承：基类构造函数，只负责初始化基类成员字段，

创建派生类对象时，派生类构造函数，只负责初始化派生类成员

派生类成员初始化，系统会先调用基类函数的初始化，之后再调用派生类构造函数完成全部

初始化

1. 系统自动调用父亲类无参数构造函初始化

2. 想使用带参数的构造函数，需要使用Base 关键字指定

     class Father
    {
        public string name;
        public Father(){
           name = "默认";
        }
        public Father(string name){
            this.name = name; 
        }
    }
    class Son :Father
    {
        public    int age ;
        //调用父亲的  name = "默认";
        public Son(int age)
        {
            this.age = age;
        }
        // 有：base(name)  调用父亲的  this.name = name; 
        // 或者可以不使用Base 关键字，把父亲类的所以字段重新写一遍（多的时候会多写）
        public Son (string name, int age ):base(name)   
        {
            this.age = age;
        }
    }
     class MainClass
        {
            public static void Main (string[] args)
          {  
            Son s1= new Son("呵呵",1);
            Console.WriteLine("名字:{0},年龄:{1}",s1.age,s1.name);   // 1   hehe

            Son s2 = new Son (1);
            Console.WriteLine("名字:{0},年龄:{1}",s2.age,s2.name);   // 1  默认

        }
    }
} 

 

类的多态

1 一般 public 方法 会直接全部继承 ,private 方法会不继承；

   子类默认继承，但子类中对然隐藏看不见但是却拥有这些方法

2 子类中用 new 关键字替换父类方法；

new 关键字定义与基类同名成员，即可替换基类成员

替换时对基类中相应代码的彻底废除，如同一个人通过器官移植手术把器官换掉一样，

并不能达到真正多态；

  当基类对象指向派生类时，系统默认会进行隐式转换，把数据转化化为基类（虽然本质时派生类），此时通过基类调用一个派生类，和基类都有的同名方法，系统会默认调用基类中的方法而不会调用派生类的方法

3  父亲类使用vituar /abstract 修饰的方法，子类使用override 重写的方法

覆盖和替换时不一样的，

      餐桌上有一张新的台布，撤下这张台布再铺上新的台布叫替换，而不撤下原来台布，直接 在上面铺上新的台布叫重写

      替换发生在程序编译之前，覆盖发生在程序运行之时

使用覆盖的方法中，系统会根据基类的实例是基类还是派生类，从而自动来调用是覆盖只后的还是覆盖之前的方法；

派生类覆盖基类方法后，想在派生类只中调用基类同名方法可以使用Base关键字

class Animal
    {
        public int age;
        //【方法替换】    

    public void Eat(){
        Console.WriteLine ("CHI");
        } 
        //【方法重写】 

     public virtual void Sleep(){
            Console.WriteLine ("\"【这是基类中的方法】睡觉(～﹃～)~zZ\"");
        }

// 【一般方法】
   public void Run(){

    Console.WriteLine ("run");

}
    }
    class Dog:Animal {
        //【方法替换】       

public new void Eat()
        {
            Console.WriteLine ("哼，老子要吃屎");   //(取下之前的，换的新台布)
        }

        //【方法重写】            

public  override  void Sleep(){
             base.Sleep ();           // 调用父亲类里面 的方法,可以不写,   (被覆盖的台布)

     Console.WriteLine ("【这是子类中的方法】dog在睡觉");    // (覆盖的台布)
        }
    }
    class MainClass
    {
        public static void Main (string[] args)
        {  
            
            Dog dog = new Dog ();
             dog.Eat ();                      // "哼哼，老子要吃shit~"

    dog.Sleep ();                  //"【这是基类中的方法】睡觉(～﹃～)~zZ")
                                                 //"【这是子类中的方法】dog在睡觉"
      dog.run();           // “ run”

            Animal ani = new Dog ();
             //【方法替换】
                     ani.Eat ();             //"吃好吃的~"

 // 【方法重写】

        ani.Sleep ();     //"【这是基类中的方法】睡觉(～﹃～)~zZ")
                                               //"【这是子类中的方法】dog在睡觉"
          //【一般方法】
               ani.run();        // “run”

        }
    }
}