C#base关键字

base关键字用于从派生类中访问基类的成员（方法，属性和构造函数）：

• 调用基类上已被其他方法重写的方法。
• 指定创建派生类实例时应调用的基类构造方法。
  （注①：静态方法中使用base是错误的。②：所访问的基类是类声明中指定的基类。例如：class B：A，则从class B类中访问class A类的成员而不考虑class A的基类。）

---

在进行代码示例前先了解一下：重写
重写含义：在子类中重新定义父类中的方法，子类中的方法和父类的方法是一样的。
父类方法：virtual
子类方法：override
代码：

        static void Main(string[] args)
        {
            A a = new A();//声明父类对象
            a.Print();
            B b = new B();//声明子类对象
            b.Print();
            Console.ReadKey();
        }
        class A//父类
        {
            public virtual void Print()//Print()方法是虚方法【virtual】
            {
                Console.WriteLine("父类virtual方法输出：A");
            }
        }
        class B:A//子类继承父类
        {
            public override  void Print()//子类重写父类Print()方法
            {
                Console.WriteLine("子类override方法输出：B");
            }
        }

---

调用父类的字段和方法

字段示例代码：

       static void Main(string[] args)
        {
            Student s1 = new Student();//声明子类对象
            s1.Name="Aucl";
            s1.Id=1;
            s1.Print();
            Console.ReadKey();
		}
        class Person//声明父类
        {
            private string name;
            private int id;
            public string Name//Name赋值
            {
                get;
                set;
            }
            public int Id//Id赋值
            {
                get;
                set;
            }
        }
        class Student:Person
        {
            public void Print()
            {
                Console.WriteLine("我叫：{0}，学号：{1}",base.Name,base.Id);//子类方法直接调用父类的字段
            }
        }

方法示例代码：通过base关键字在派生类中调用基类的Speak()方法。

        static void Main(string[] args)
        {
            B b = new B();//创建派生类
            b.Speak();    //调用派生类中的方法
            Console.ReadKey();
        }
        class A//声明父类
        {
            private string name = "Aucl";
            private int age = 20;
            public virtual void Speak()
            //★Speak()方法为虚方法
            {
                Console.WriteLine("父类输出virtual方法：Speak方法：");
                Console.WriteLine("name={0}",name);
                Console.WriteLine("age={0}",age);
            }
        }
        class B:A//派生类继承父类
        {
            private string Id = "001";
            public override void Speak()
            //★重写父类方法
            {
                base.Speak();//★通过base关键字调用基类方法★
                Console.WriteLine("\n派生类输出override方法：Speak方法：");
                Console.WriteLine("Id:{0}",Id);
            }
        }
/*
Output
父类输出virtual方法：Speak方法：
name=Aucl
age=20

派生类输出override方法：Speak方法：
Id:001

*/

调用父类的构造方法

构造方法示例代码：示例中显示如何创建派生类实例对象时指定调用基类构造函数

如何实现指定？
方法重载指定：方法名相同，数据类型和数据个数不同来调用不同的方法；
base()指定：同样我们可以通过参数类型，参数个数来实现对构造方法的指定访问。

未使用base关键字

        static void Main(string[] args)
        {
            B b = new B();//创建无参的实例对象
            B b1 = new B("Aucl", "001");//创建有参的实例对象
            Console.ReadKey();
        }
        class A//基类
        {
            private string Name;
           public A()//定义无参构造函数
            {
                Console.WriteLine("基类输出无参：A");
            }
            public A(string name)//定义有参数构造函数
            {
                Name = name;
                Console.WriteLine("基类输出：Name={0}", Name);
            }
        }
        class B:A//派生类
        {
            public  string Id;
            public B():base()//定义无参构造函数
            {
                Console.WriteLine("派生类输出无参：B");
            }
            public B(string name, string id)//★★★★★
                //定义有参数的构造函数
            {
                Id = id;
                Console.WriteLine("派生类输出：Id:{1}",name,Id);
            }
        }

结果：

---

解析：
根据构造方法的继承特点，当创建子类对象时，子类构造方法会先访问父类的构造方法，然后再访问子类的构造方法！
①：子类无参的构造函数指定访问的是base()无参的父类构造方法
②：子类有参的构造方法未指定，所以默认访问的是无参的构造方法

---

使用base关键字

        static void Main(string[] args)
        {
            B b = new B();//创建无参的实例对象，然后base访问父类无参的构造函数
            B b1 = new B("Aucl", "001");//创建有参的实例对象，然后base访问父类有参的构造函数
            Console.ReadKey();
        }
        class A//基类
        {
            private string Name;
            public A()//定义无参构造函数
            {
                Console.WriteLine("无参：");
                Console.WriteLine("基类输出无参构造方法：A");
            }
            public A(string name)//定义有参数构造函数
            {
                Console.WriteLine("\n有参：");
                Name = name;
                Console.WriteLine("基类输出有参构造方法：Name={0}", Name);
            }
        }
        class B : A//派生类
        {
            public string Id;
            public B(): base()
            //★★★★★访问父类无参的构造函数
            {
                Console.WriteLine("派生类输出无参构造方法：B");
            }
            public B(string name, string id): base(name)
            //★★★★★访问父类有参的构造函数
            {
                Id = id;
                Console.WriteLine("派生类输出有参构造方法：Id:{1}", name, Id);
            }
        }

结果：

每天进步一点点。