学步园

   最近总是很懒，看书的时候不想动手。明知道编程这东西只是看是不行的，所以，还是要坚持把Demo进行到底~
   之前知道，构造函数在继承关系中的执行顺序是这样的：首先执行基类的构造函数，而后才是要实例化的类本身。当然这里的基类是个递归的过程，也就是说只要存在继承关系，那就会一直递归到System.Object为止.
   其实这层关系，写两个具有继承关系的类，再写这个构造函数，实例化这个继承类，单步调试就可以很清晰的看到构造函数的执行过程.这里，如果两个类都采用默认的构造函数，那这个关系自然是看不到的.
   这里我要说的是具有参数的构造函数的执行。比如说，我们会把一些共有的属性写进基类中去,而在实例化继承类的时候，往往会在构造函数中初始化这些属性（基类），这个时候，就要用到Base关键字,除此之外，构造函数的执行顺序依然遵循上述顺序.
  Demo:

using System;
using System.Collections.Generic;
using System.Text;

namespace ConstructorDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            LittleBird lb = new LittleBird("lbname",4);
            Console.WriteLine(lb.Name+"---"+lb.Num);
            lb.showName();

            Animal ain = new bird("birdname");
            Console.WriteLine(ain.Name);
            ain.showName();
            
        }
    }

   abstract class Animal
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public Animal(string name)
        {
            this.name = name;
        }

       public abstract void showName();

    }
    class bird : Animal
    {
        public bird(string bird_name)
            : base(bird_name)    //给基类构造函数传参
        {
 
        }

        public override void showName()
        {
            Console.WriteLine("hi,this is bird :{0}",Name);
        }
    }
    class LittleBird : bird
    {
        private int num;
        public int Num
        {
            get
            {
                return num;
            }
            set
            {
                num = value;
            }
        }

        public LittleBird(string lb_name,int lb_num)
            : base(lb_name)   //给基类构造函数传参
        {
            this.num = lb_num;   //执行本身构造函数
        }

        public override void showName()
        {
            base.showName();               //调用基类方法
            Console.WriteLine("hi,this is little bird :{0}",Name);
        }
    }
}

同时注意到Base关键字的用法:
1.调用基类构造函数，并传参。
2.调用基类方法（当然是在重写的方法中调用）