继承中的隐藏（hide）重写（Override）和多态（Polymorphism）

继承中的隐藏：（不要使用隐藏，语法没有错误但是开发项目时会被视为错误）

在继承类中完全保留基类中的函数名

//基类，交通工具
    class Vehicle
    {
        public void Run()
        {
            Console.WriteLine("Vehicle Run");
        }
    }
//派生类，汽车
    class Car : Vehicle
    {
        public void Run()
        {
            Console.WriteLine("Car RunRun");
        }
    }

隐藏之后，Car中的Run()有两个版本，一个是继承来的Run() 被隐藏，另一个是Car中新写的Run()。

两个版本共存，

如果引用类型是父类，实例类型是子类，调用隐藏方法，

如果引用类型是子类，实例类型也是子类，调用新写的方法，

继承中的重写：

基类中Run（）函数前加”virtual “，virtual 在这里翻译为形式上的，名存实亡的，其实就是为以后override重写做铺垫

派生类中的Run（）函数前加”override“。

//基类，交通工具
    class Vehicle
    {
        public void virtual Run()
        {
            Console.WriteLine("Vehicle Run");
        }
    }
//派生类，汽车
    class Car : Vehicle
    {
        public void override Run()
        {
            Console.WriteLine("Car Run");
        }
    }

重写之后，Car中的Run()方法只有一个版本，原来继承的Run()已经被新写的Run()覆盖。

在子类中仅存在一个版本，所以无论引用类型是父类还是子类，只要实例类型是子类，则调用的就是新写的方法。

举例说明：

hide：

Car类中更新Run()的新版本和旧版本共存，

但是我们用父类类型Vehicle作为引用的类型，

子类类型Car类做实例类型

就调用旧的版本(I‘m running.)

    class Program
    {
        static void Main(string[] args)
        {
            Vehicle car = new Car();//C#支持父类类型变量引用一个子类类型实例，is a. 一辆car是一个Vehicle
            car.Run();
        }
    }

    class Vehicle
    {
        public  void Run()
        {
            Console.WriteLine("I'm running");
        }
    }

    class Car : Vehicle
    {
        public  void Run()
        {
            Console.WriteLine("Car is running");
        }
    }

结果是：

I‘m running.

直接Car car = new Car();才返回Car类中的新版本！

override:

重写一次Run()方法，即在Car类中更新Run()的新版本(Car is running.)，旧的版本(I‘m running.)被重写(覆盖)

我们用父类类型Vehicle作为引用的类型，Car类做实例类型，

就调用新的版本(Car is running.)

    class Program
    {
        static void Main(string[] args)
        {
            Vehicle car = new Car();
            car.Run();
        }
    }

    class Vehicle
    {
        public virtual void Run()
        {
            Console.WriteLine("I'm running");
        }
    }

    class Car : Vehicle
    {
        public override void Run()
        {
            Console.WriteLine("Car is running");
        }
    }

结果是：

Car is running.

override：

添加RaceCar类再重写一次Run()方法，即在RaceCar类中更新Run()的新版本(RaceCar is running.)

我们用父类类型Car作为引用的类型，RaceCar类做实例类型，(我们用父类类型Vehicle作为引用的类型，RaceCar类做实例类型，结果也相同)

就调用新的版本(RaceCar is running.)

    class Program
    {
        static void Main(string[] args)
        {
            Car car = new RaceCar();//C#支持父类类型变量引用一个子类类型实例，is a. 一辆car是一个Vehicle
            car.Run();
        }
    }

    class Vehicle
    {
        public virtual void Run()
        {
            Console.WriteLine("I'm running");
        }
    }

    class Car : Vehicle
    {
        public override void Run()
        {
            Console.WriteLine("Car is running");
        }
    }

    class RaceCar : Car
    {
        public override void Run()
        {
            Console.WriteLine("RaceCar is running");
        }
    }

结果是：

RaceCar is running.

以上代码回答了一个问题——什么是多态？

多态就是当我们用一个父类的变量，引用一个子类的实例，调用被重写的成员的时候，总是会调用到最新的版本（与实例类型相关联的版本）

为什么会出现多态的现象？

因为C#语言中，变量的类型和实例对象的类型，是可以不同的。比如：

Car car = new RaceCar();

变量car的类型是Car，实例类型是RaceCar。这样就有代差，可以用基类类型的变量引用子类类型实例，反之不可