C#面向对象——多态

5.3 多态
由于子类（派生类）可以继承基类的成员，子类就有了相同的行为，但是有时候子类的某些行为需要相互区别。
子类需要覆盖父类中的方法来实现子类特有的行为，这就是多态。
多态即相同类型的对象调用相同的方法却表现出不同行为的现象。
5.3.1 使用virtual和override关键字实现方法重写
只有基类成员声明为 virtual和abstract时，才能被派生类重写；
而子类想改变虚方法的实现行为，则必须使用override关键字。

            //重写

            /*多态：
             * 实现方法重写需要注意：
             * 父类中的成员要用virtual或者abstract关键字修饰，
             * 子类在进行重写的过程中要使用override关键字来修饰需要重写的父类成员
             * 
             
             */


            Horse horse = new Horse();
            horse.Voice();


            Sheep sheep = new Sheep();
            sheep.Voice();

            //或
            Animal horse_ = new Horse();
            horse_.Voice();

            Animal sheep_ = new Animal();
            sheep_.Voice();

        //如下代码示例
        public class Animal
        {
            private int _age;
            public int Age
            {
                get { return _age; }
                set
                {
                    if (value < 0 || value > 120)
                    {
                        _age = 80;

                        throw (new ArgumentOutOfRangeException("AgeIntProperty", value, "年龄超出范围"));
                    }
                    _age = value;

                }
            }

            public virtual void Voice()
            {
                Console.WriteLine("动物开始发出声音");
            }
        }

        public class Horse : Animal
        {
            public override void Voice()
            {
                base.Voice();
                Console.WriteLine("马发出嘶嘶的声音");
            }
        }

        public class Sheep : Animal
        {
            public override void Voice()
            {
                base.Voice();
                Console.WriteLine("羊发出咩咩的声音");
            }
        }

Animal 基类的作用是为所有的子类提供公共成员，他是一个抽象的概念。如果希望它不能创建实例，可以使用 abstract 关键字防止在代码中直接创建这样的实例

public abstract class Animal
{
}

5.3.2 阻止派生类重写虚成员

   //用sealed可以防止一个类被其他类继承，同样也可以使用sealed关键字来阻止派生类重写虚成员。
   //例如：如果希望 Horse的继承类不再扩展Voice方法，则可以使用sealed关键字来停止虚拟继承，如下
 public class Horse : Animal
 {
    public sealed override void Voice()
    {
        base.Voice();
       Console.WriteLine("马发出嘶嘶的声音");
    }
 }

        /// <summary>
        /// 私有类
        /// </summary>
        private class a { }

        /// <summary>
        /// 密封类
        /// 密封类是指不能被继承的类，强行继承会产生编译错误
        /// </summary>
        public sealed class SealedClass
        {

        }

        /// <summary>
        /// 密封类不能作为其他类的基类
        /// </summary>
        //public class test : SealedClass
        //{

        //}

5.3.3 使用新成员隐藏基类成员

       //    如果想在派生类中定义与基类同名的成员，
       //    则可以使用new关键字吧基类成员隐藏起来。
       //    如果不使用new关键字，在派生类中定义一个与基类同名的成员，编译器将产生警告

       public class Animal1
       {
           public void Eat()
           {
               Console.WriteLine("动物吃的方法");
           }

           public void Eat1()
           {
               Console.WriteLine("动物吃的方法");
           }
       }

       public class Horse1 : Animal1
       {
           //在派生类定义同名方法，收到警告信息
           public void Eat()
           {
               Console.WriteLine("马吃的方法");
           }

           //使用new修饰，从而隐藏了基类中的同名成员
           public new void Eat1()
           {
               Console.WriteLine("马吃的方法");
           }
       }

            //隐藏基类成员

            Horse1 hor = new ConsoleApplication1.Program.Horse1();
            hor.Eat();//调用自己的方法


            //如果仍然想访问基类成员，则可以使用强制类型转换，把子类强制转换为基类，从而访问隐藏的基类成员
            ((Animal1)hor).Eat();

5.4 所有类的父类 System.Object
C#中，所有的类都派生自System.Object ，如果定义的类没有制定任何基类，编译器就会自动把Object当做基类