多态详细介绍

多态

定义

why?

 public class Master
    {
        public void Feed(Dog dog)
        {
            dog.eat();
        }
        public void Feed(Cat cat)
        {
            cat.eat();
        }
        /*
        public void Feed(XXX xxx)    //XXX代表父类
        {
            xxx.eat();
        }
        */
}

 假设有一个主人类。喂食不同的动物。不同动物对象调用方法的时候，对重复的代码频繁的修改。代码的可展拓展性，可维护性差。

所以我们可以用一个Animal类作为参数，让不同的动物继承这个动物类，这就是多态。

what?

​ 多态是同一个行为具有多个不同表现形式或形态的能力。就比如说是给上面的动物喂食。不同的动物喂不同的食物。

    多人做一件事，结果不一样。就比如说老鹰会飞。杜鹃会飞。喜鹊会飞。他们都会飞。但是他们飞行的能力是不同的。有的飞的高飞有的飞的低

​

     多态性：

            多态性可以是静态的或动态的。在静态多态性中，方法的响应是在编译时发生的。在动态多态性中，方法的响应是在运行时发生的。

       静态多态性：在编译时，方法和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为：方法重载、运算符重载

            方法重载：在同一个类中。允许同名方法。他们的参数个数，或参数类型不同即可。

            运算符重载:就是定义一个函数。在函数体内实现想要的功能。当用到该运算符时，编译器会自动调用这个函数。也就是说，运算符重载是通过函数实现的，它本质上是函数重载。

           运算符重载_Simon的博客-CSDN博客

    动态多态性：是通过 抽象类 和 虚方法 实现的。

实现多态的两个要素（How）

• 1）子类重写父类方法

• 2）使用父类的类型（子类转换为父类：向上转型）

class Animal
{
 	public virtual void call() {
        Console.WriteLine("无声的叫唤"); 
      }
}
class Dog : Animal
 {
        // new的作用是隐藏父类的同名方法
        //public new void call() { 
            //Console.WriteLine("叫声：汪～汪～汪～"); 
      //}  	
        public override  void call() { 
            Console.WriteLine("叫声：汪～汪～汪～"); 
        }
        public void smell() { 
            Console.WriteLine("嗅觉相当不错！");
        }
 }
class Cat:Animal{
      public override  void call() { 
            Console.WriteLine("叫声：秒秒买哦～"); 
        }
}

 class Program
    {
        static void Main(string[] args)
        {         
            Animal animal = new Dog(); //向上转型 
            animal.call();
        }
    }

向上转型：将子类对象转为父类对象。此处父类对象可以是接口或抽象类。

转化后的父类对象具有父类所有方法，若方法被子类重写override，那么实际调用时，调用的是重写后的实现

通过多层继承链，理解"父类型引用永远调用的是继承链中最新版本的重写函数"

特别注意：使用new关键字后会破坏多态性！

int a=(int)3.5;
Dog dog = (Dog)animal;//向下转型
dog.call();                 
dog.smell(); 

向下转型：把父类对象转为子类对象

>

转化后的子类对象，跟一般的继承子类对象一样。具有子类所有方法(包括重写方法)+父类所有方法(被重写的方法，按重写的算。)

class Animals
    {
        public virtual void Eat()
        {
            Console.WriteLine("吃");
        }
    }
 
     class Dog : Animals
    {
        public override void Eat()
        {
            Console.WriteLine("狗吃骨头");
        }
    }
    
    class Cat:Animals
    {
        public override void Eat()
        {
            Console.WriteLine("猫吃鱼");
        }
        
    }
    
    class Master
    {
        public void Feed(Animals a) //父类作为参数
        {
            a.Eat();
        }
    }
 
    
    class Program
    {
        static void Main(string[] args)
        {
            //匿名对象，调用一次方法
            Animals a = new Animals();
            Dog b = new Dog();
            Cat c = new Cat();
            
            a = b; //向上转型
            new Master().Feed(b);
 
        }
    }
    
// 输出：狗吃骨头

父类做返回值

 public Animals Feed(int i)  //父类作为参数
        {
            Animals a = null;    //默认赋空
            if (i==0)
            {
                a = new Dog();
            }
            else if (i == 1)
            {
                a = new Cat();
            }
            return a;
        } 
 
 
        static void Main(string[] args)
        {
            //匿名对象，调用一次方法
            Animals a = new Animals();
            Dog d = new Dog();
            Cat c = new Cat();
            
            a = d; //向上转型
            //new Master().Feed(d);
 
            a = new Master().Feed(1);
            a.Eat();    //调用方法
        }
输出：猫吃鱼

父类做参数优化

public void Feed(Animals a) //父类作为参数
        {
            //a.Eat();    
            /*这样写不能直接判断传入的是猫还是狗？
            因此我们要对传进来的　a　进行判断。*/
                
            if (a is Dog)   //使用　ｉｓ　关键字
            {
                a.Eat();
            }
            if (a is Cat)
            {
                a.Eat();
            }
        }
 
static void Main(string[] args)
        {
            //匿名对象，调用一次方法
            Animals a = new Animals();
            Dog d = new Dog();
            Cat c = new Cat();
            
            a = d; //向上转型
            new Master().Feed(d);
 
            //a = new Master().Feed(1);
            //a.Eat();
// 输出：狗吃骨头