C#里有个东东叫继承

学C#的时候，学到很多没在别的语言里见过的继承手段。比如用Base方法调用基类构造函数。这个好神奇，只要在子类构造函数后面加个base（）就能调用基类的不同构造函数。话不多说，贴代码！

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

namespace BaseClass_test
{
    public class BaseClass
    {
        int number;
       public  BaseClass()
        {
            Console.WriteLine("子类调基类第一个构造函数");
        }
        public  BaseClass(int i){
            number =i;
            Console.WriteLine("子类调用基类第二个构造函数");
        }
        public int getnumber()
        {
            return number;
        }
    }
   public class sonclass:BaseClass
   {
       public sonclass() : base() { }
       public sonclass(int i) : base(i) { }
        static void Main(string[] args)
        {
            sonclass bs1 = new sonclass();
            sonclass bs2 = new sonclass(1);
        }
    }
}
上面代码的运行结果是：

大家可以看到，通过base方法我轻易调用了两个基类构造函数，但是用base的时候同样陷阱重重。base方法只局限在构造函数，实例方法和实例属性访问器中，而且静态方法中是不可以使用base方法的。

 

接下来讲一个大家很熟悉的关键字--new，它能创造心得类方法，达到隐藏基类成员的目的。看看代码吧

namespace new_test
{
   public  class BCclass
    {
      public void Dowork()
      {
          Console.WriteLine("调用的是基类方法");
      }
        public int work1;


        }
        public class sonclass:BCclass
        {
           public new void Dowork()
           {
               Console.WriteLine("调用的是新类的方法");
           }
            public new int work1;
            static void Main(string []src)
            {
               sonclass b = new sonclass();
                b.Dowork();                          //调用新方法
                BCclass a = (BCclass)b;
                a.Dowork();                          //调用老方法

            }
        }
    }实现如下：

 

使用new关键字时，调用的是新的类成员而不是已被替换的基类成员，这些基类成员称为隐藏成员，如果将派生类的实例强制转换为基类的实例，仍然可以调用隐藏类成员。

 

最后来看下老生常谈的override方法，下面是一个示例

namespace override_test
{
    class testoverride
    {
        public class em
        {
            public string name;
            protected decimal basepay;
            public em(string name, decimal pay)
            {
                this.name = name;
                this.basepay = pay;
            }
            public virtual decimal calculate()
            {
                return basepay;
            }


        }
        public class saleem :em
        {
            private decimal sale;
            public saleem(string name, decimal basepay, decimal sale): base(name, basepay){//实现继承
                this.sale = sale;
            }
            public override decimal calculate()//重写方法
            {
                return basepay+sale;
            }

            static void Main()
            {
                saleem e1 = new saleem("luikai", 1000, 500);
                em e2 = new em("bob", 1200);
                Console.WriteLine("Person "+e1.name+" earned； "+e1.calculate());
                Console.WriteLine("Person " + e2.name + " earned: " + e2.calculate());
            }
        }
    }
 
}代码运行结果：

很简单的例子，员工分正常员工和销售人员，销售人员要拿回扣咯，所以两类人的工资计算方法当然不能一样了，所以销售人员类里重写这个方法。

同时要注意的是：override申明不能更改virtual方法的可访问性，不能使用修饰符new,static,virtual或abstract来修饰override方法。不能重写非虚方法或静态方法。