C#多态

1：重写父类方法

1：重写父类方法
父类方法：virtual
子类方法：override
示例：

       static void Main(string[] args)
        {
            Dog a1 = new Dog ();
            a1.Shot();
            Console.ReadKey();
        }
        class Animal//父类方法
        {
            public virtual void Shot()//★virtual
            {
                Console.WriteLine("动物可以叫！");
            }
        }
        class Dog:Animal//Dog类继承父类
        {
            public override void Shot()//★override
            //★子类重写父类方法：数据类型-个数-返回值类型完全和父类相同★
            {
                Console.WriteLine("狗可以叫！");
            }
        }

①：子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限
②：重写父类方法要求子类方法名，参数类型和参数个数必须与父类相同

2：多态实现

2：多态实现（目的：程序更加灵活）
同一个操作，作用于不同的对象，会产生不同现象
示例：

        static void Main(string[] args)
        {
            //方法1：
            A a=new B();//子类可以new一个父类对象
            //★分析：Dog属于动物，但是动物不一定全是Dog
            Console.WriteLine("方法1：");
            a.Print();
            //★new谁
            //方法2：
            A a1 = new A();
            //同类进行new
            B b = new B();
            Console.WriteLine("方法2：");
            a1.Print();
            b.Print();
            Console.ReadKey();
        }
        class A//父类
        {
            public virtual void Print()//virtual
            {
                Console.WriteLine("父类输出：A");
            }
        }
        class B:A//子类
        {
            public override void Print()//override
            {
                 Console.WriteLine("子类输出：B");
            }
        }

①：通过子类new一个父类对象
②：同类new对象

3：里氏转换原则

3：里氏转换原则（子类与父类之间的转换）
①：子类作为父类——>直接赋值（例如：狗一定是动物，但是动物不一定全是狗）
示例：

        static void Main(string[] args)
        {
            Animal a1 = new Dog();//★Dog类作为父类，按照原则直接赋值操作！
            a1.Shout();
            //谁new，调谁
            Animal a2 = new Cat();//★Cat类作为父类，按照原则直接赋值操作！
            a2.Shout();
            //谁new，调谁
            Console.ReadKey();
        }
        class Animal//父类
        {
            public virtual void Shout()
            {
                Console.WriteLine("动物有自己的叫声！");
            }
        }
        class Dog:Animal//子类
        {
            public override void Shout()
            {
                Console.WriteLine("小狗：旺旺...");
            }
        }
        class Cat:Animal//子类
        {
            public override void Shout()
            {
                Console.WriteLine("小猫：喵喵...");
            }
        }

②：父类作为子类——>强制转换。
（注：强制转换易报错，建议使用is/as操作。①：is只能判断bool类型②：as判断同时可以转换）
示例强制转换：

        static void Main(string[] args)
        {
            Animal a = new Dog();
            //Animal类中不单单有Dog类
            Dog dog = (Dog)a;
            //为了转换更加准确，对a进行限制，将Dog类的a全部实例化dog对象
            dog.Shout();
            Console.ReadKey();
        }
        class Animal//父类
        {
            public virtual void Shout()
            {
                Console.WriteLine("动物有自己的叫声！");
            }
        }
        class Dog : Animal//子类
        {
            public override void Shout()
            {
                Console.WriteLine("小狗：旺旺...");
            }
        }

示例is操作：

         static void Main(string[] args)
        {
            Animal a = new Dog();
             bool result =a is Dog;//判断a是否为Dog类
             if(result)
             {
                 Console.WriteLine("可以进行强制转换！");
             }
             else
             {
                 Console.WriteLine("强制转换出错！");
             }
             Console.ReadKey();
        }
        class Animal//父类
        {
             public virtual void Shout()
             {
                 Console.WriteLine("动物有自己的叫声！");
             }
         }
         class Dog : Animal//子类
         {
             public override void Shout()
             {
                 Console.WriteLine("小狗：旺旺...");
             }
         }

示例as操作：

         static void Main(string[] args)
        {
            Animal a = new Dog();//子类new父类对象
             Dog dog=a as Dog;
             //使用as关键字判断a对象是否可以转换为Dog类型，如果可以进行转换，如果不可以则为null
             if(dog!=null)
             {
                 Console.WriteLine("可以转换！");
                 dog.Shout();
             }
             else
             {
                 Console.WriteLine("无法转换！");
             }
             Console.ReadKey();
        }
         class Animal//父类
         {
             public virtual void Shout()
             {
                 Console.WriteLine("动物有自己的叫声！");
             }
         }
         class Dog : Animal//子类
         {
             public override void Shout()
             {
                 Console.WriteLine("小狗：旺旺...");
             }
         }

4：Object类

4：Object类（所有类的父类，每一个类直接或者间接继承该类）
①：子类可以调用Object类内的方法。

        static void Main(string[] args)
        {
            A a = new A();
            Console.WriteLine("Object：" + a.ToString());
            //Object类是任何类的父类  
            //对象可以直接调用Object类内方法
            Console.ReadKey();
        }
        class A
        {
            public void Print()
            {
                Console.WriteLine("Print:A");
            }
        }

常用Object方法：

②：重写Object类方法
对比（new重写和override重写）
重写两种方法：
①new操作：对父类方法进行隐藏，其他类同样无法访问父类中方法。
②override操作：在子类内部对父类方法进行操作，其他类同样可以操作父类中方法。*
示例：

        static void Main(string[] args)
        {
            A a = new A();
            Console.WriteLine("重写Object类方法Tostring成功："+a.ToString());
            Console.ReadKey();
        }
        class A
        {
            public override string ToString()
            //★public override void ToString()  如果直接这样写会报错
            //★报错内容为：Tostring重写需要为string返回类型★
            {
                return "重写Object类中Tostring方法.";
            }
        }

每天进步一点点！