【C#】多态

多态

多态分为静态多态性和动态多态性

静态多态性

静态多态性通过函数重载和运算符重载实现

函数重载：函数重载就是同一个函数名称，但是函数的参数不一样，我们简单举一个例子

using System;

namespace 函数重载实现静态多态
{
    class Program
    {
        static int Add(int a, int b)
        {
            return a + b;
        }
        static double Add(double a, double b)
        {
            return a + b;
        }
        static void Main(string[] args)
        {
            Console.WriteLine("{0}", Add(1,2));
            Console.WriteLine("{0}", Add(1.2, 3.2));
        }
    }
}

运算符重载：运算符重载就是自己重新定义运算符的计算结果，例如两个箱子相加要得到一个新的箱子，使用普通的+号运算符中是不会计算出来的结果的，但是我们可以通过使用operator关键字，来对+号运算符进行重载。我们举一个简单的例子来实现两个箱子相加来计算箱子的体积。

using System;

namespace 运算符重载实现多态
{
    class Box
    {
        double length;//长
        double height;//宽
        double breadth;//高

        public Box(double a, double b, double c)
        {
            length = a;
            height = b;
            breadth = c;
        }

        public void Show()
        {
            Console.WriteLine("体积={0}", length*height*breadth);
        }
        
        public static Box operator +(Box a, Box b)
        {
            Box c = new Box(a.length+b.length, a.height+b.height, a.breadth+b.breadth);

            return c;
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            Box a = new Box(1, 1, 1);
            Box b = new Box(2, 2, 2);

            Box c = a + b;
            c.Show();
        }
    }
}

动态多态性

动态多态性通过抽象类和虚方法实现

抽象类：抽象类使用abstract关键字进行创建，抽象类里面包含抽象方法，抽象方法只进行定义而不实现，实现的事情交给该抽象类的子类进行，不同的子类对同一个抽象方法实现不同的功能，这样就可以实现多态。要实现多态，需要使用子类实例指向父类对象。我们来看下面这个例子。

例子定义一个动物抽象类，动物的一个功能是叫，因此给他定义一个抽象方法speak。子类狗和猫继承动物这个抽象类，重写speak功能，来实现多态。特别地，要使用多态，需要子类实例指向父类对象，例如定义一个动物，但是它的示例是狗，这样就会产生多态。

	//抽象类实现多态的例子
	abstract class Animal//定义一个动物的抽象类
	{
		abstract public void speak();
	}

	class Dog : Animal//定义一个狗类，它继承了动物类
	{
		public override void speak()//对动物类的speak方法进行重写，以此实现多态
		{
			Console.WriteLine("汪汪");
		}
	}

	class Cat : Animal
	{
		public override void speak()
		{
			Console.WriteLine("喵喵");
		}
	}

	class Program
    {
        static void Main(string[] args)
        {
			Animal animal1 = new Dog();//子类的示例指向父类对象，因此会造成多态
			Animal animal2 = new Cat();//子类的示例指向父类对象，因此会造成多态

			animal1.speak();
			animal2.speak();
		}
    }

执行结果如下，对于是狗的实例，就是汪汪，对于猫的实例，就是喵喵：

虚方法：虚方法关键字使用virtual进行创建，我们还是以上面动物的例子，通过虚方法来实现多态。

//虚方法实现多态的例子
using System;

namespace 虚方法实现多态
{
    class Animal
    {
        public virtual void speak()
        {
            Console.WriteLine("Animal Speak");
        }

    }

    class Dog : Animal
    {
        public override void speak()
        {
            Console.WriteLine("汪汪");
        }
    }

    class Cat : Animal
    {
        public override void speak()
        {
            Console.WriteLine("喵喵");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Animal animal1 = new Dog();
            Animal animal2 = new Cat();

            animal1.speak();
            animal2.speak();
        }
    }
}