继承相关的关键字：Virtual,new,base,abstract,sealed....

1.C#中的继承分为实现继承，接口继承。 c#类可以派生于另一个类和任意多个接口。

2.关键字

 Virtual: 虚方法

 虚方法与面向对象的多态性有很大的关系。

 在基类中定义虚方法用virtual,方法有实现部分。

 派生类可以重写该虚方法，也可以不重写。重写用关键字override.

 重写override也叫覆盖：

•    不同的范围（基类和派生类）
•    函数名和参数相同
•    重写的函数必须是基类的虚函数。

 New：显示隐藏

如果基类中的函数没有用virtual修饰，派生类想重写基类的方法，那么不用Override,叫隐藏。用关键字new显示隐藏。 hide

•    不同的范围
•    相同的函数名
•    参数可相同，也可不同

 Base:在派生类中调用基类被隐藏的函数

举例：

 class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            stu.setHA(158, 20);
            Console.WriteLine(stu.getHeight());
            Console.WriteLine(stu.getAge());
            Console.WriteLine(stu.getAge(20));

            People pe = new Student();
            pe.setHA(170, 25);
            Console.WriteLine("height={0},age={1}", pe.getHeight(), pe.getAge());
        }
    }
    class People
    {
        public int height;
        public int age;
        public void setHA(int h, int a)
        {
            height = h;
            age = a;
        }
        public virtual int getHeight()
        {
            return height;
        }
        public int getAge()
        {
            return age;
        }
    }
    class Student : People
    {
        public override int getHeight()  //重写
        {
            return height + 5;
        }
        public new int getAge()  //隐藏
        {
            return age + 5;
        }
        public int getAge(int a) //重载
        {
            return age + a;
        }
    }

输出： http://s6/middle/66770c85gc7736ce13205&690

为什么People pe=new Student();  ==> height=175, age=25 ??

 http://s12/middle/66770c85gc7aa614ecbab&690
举例二：

 class A
    {
        public void F()
        {
            Console.WriteLine("父类的方法");
        }
        public virtual void FF()
        {
            Console.WriteLine("父类的虚方法");
        }
    }
    class B : A
    {
        public new void F()
        {
            Console.WriteLine("子类隐藏了父类的方法");
        }
        public override void FF()
        {
            Console.WriteLine("子类重写了父类的方法");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            A a = new B();
            a.F();
            a.FF();
        }
    }
http://s1/middle/66770c85gc7aa79b89180&690
多态性：多个不同类的对象，对同一消息做出不同的反应。

例如：公司里，经理听到StartWork命令就开始下达命令；销售听到StartWork命令就开始销售产品....

 class Emplyee
    {
        public string name;
        public Emplyee() { }
        public Emplyee(string name)
        {
            this.name = name;
        }
        public virtual void StartWork()
        {
            Console.Write(name + "开始：");
        }
    }
    class Manager : Emplyee
    {
        public Manager(string name)
        {
            this.name = name;
        }
        public override void StartWork()
        {
            base.StartWork();
            Console.WriteLine("下达任务");
        }
    }
    class Saler: Emplyee
    {
            public Saler(string name)
        {
            this.name = name;
        }
        public override void StartWork()
        {
            base.StartWork();
            Console.WriteLine("销售产品");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Emplyee[] emp = new Emplyee[2];
            emp[0] = new Manager("经理");
            emp[1] = new Saler("销售");
            foreach (Emplyee e in emp)
            {
                e.StartWork();
            }
        }
    }

http://s5/middle/66770c85gc7ac9f6e6574&690
Abstract

抽象类：不能实例化

抽象函数：没有执行代码

         必须在非抽象的派生类中重写

          只能存在于抽象类中

          不用virtual,private, static修饰符

          派生类中重写用关键字override

举例：

namespace ConsoleApplication4
{
   abstract public class A
       //抽象类A中可以包括抽象方法，具体方法，虚方法
   {
       abstract public void Abs1();
       abstract public void Abs2();
       public void Data()
       {
           Console.WriteLine("抽象类A的函数A.Data()");
       }
       virtual public void Invoke()
       {
           Console.WriteLine("抽象类A的虚方法A.Invoke()");
       }
   }
    abstract public class B:A
        //B没有实现A中的所有抽象方法，所以B应该为abstract
   {
       override public void Abs1()
       {
           Console.WriteLine("抽象类B的重写方法B.Abs1()");
       }
       new public void Data()
       {
           Console.WriteLine("抽象类B的隐藏函数B.Data()");
       }
       override public void Invoke()
       {
           Console.WriteLine("抽象类B的重写方法B.Invoke()");
       }
   }
    public class C: A
        //C重写了抽象类A的所有抽象方法
    {
        override public void Abs1()
        {
            Console.WriteLine("类C的重写方法C.Abs1()");
        }
        override public void Abs2()
        {
            Console.WriteLine("类C的重写方法C.Abs2()");
        }
    }
    public class D:B
    {
        override public void Abs2()
        {
            Console.WriteLine("类D的重写方法D.Abs2()");
        }
    }
    public class Test
    {
        public static void Main()
        {
            A a = new D();
            a.Abs1();
            a.Abs2();
            a.Data();
            a.Invoke();
            Console.WriteLine();
            A a1 = new C();
            a1.Abs1();
            a1.Abs2();
            a1.Data();
            a1.Invoke();
        }
    }
}

输出：

  http://s16/middle/66770c85gc7fa84f8963f&690

Sealed

密封类：sealed class, 不能继承该类

密封方法：不能重写该方法。

说明：除了实例成员能够被继承外，静态成员也能被继承。