C#学习笔记（10）：多态性和重载

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

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

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

多态就是同一个接口，使用不同的实例而执行不同操作。举例来说，生物链中大鱼吃小鱼，小鱼吃虾米，同样是吃，但吃的东西却不同。

静态多态性在函数重载和运算符重载中体现。

1. 函数重载

可以在同一个范围内对相同的函数名有多个定义。以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。

2.运算符重载

可以重定义或重载 C# 中内置的运算符，重载运算符是具有特殊名称的函数，是通过关键字 operator 后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表

//直接拷贝的例句
namespace InheritTest
{
	class Box
	{
		private double length;
		private double width;
		private double height;

		public double getVolume()
		{
			return length*width*height;
		}

		public void setLength(double len)
		{
			length = len;
		}

		public void setWidth(double wid)
		{
			width = wid;
		}

		public void setHeigh(double hei)
		{
			height = hei;
		}

		public static Box operator+ (Box b, Box c)//运算符+重载
		{
		   Box box = new Box();
		   box.length = b.length + c.length;
		   box.width = b.width + c.width;
		   box.height = b.height + c.height;
		   return box;
		}
		static void Main(string[] args)
		{
			Box Box1 = new Box();         // 声明 Box1，类型为 Box
	        Box Box2 = new Box();         // 声明 Box2，类型为 Box
	        Box Box3 = new Box();         // 声明 Box3，类型为 Box
	        double volume = 0.0;          // 体积

	         // Box1 详述
	        Box1.setLength(6.0);
	        Box1.setWidth(7.0);
	        Box1.setHeigh(5.0);

	         // Box2 详述
	        Box2.setLength(12.0);
	        Box2.setWidth(13.0);
	        Box2.setHeigh(10.0);

	         // Box1 的体积
	        volume = Box1.getVolume();
	        Console.WriteLine("Box1 的体积： {0}", volume);

	         // Box2 的体积
	        volume = Box2.getVolume();
	        Console.WriteLine("Box2 的体积： {0}", volume);

	         // 把两个对象相加
	        Box3 = Box1 + Box2;

	         // Box3 的体积
	        volume = Box3.getVolume();
	        Console.WriteLine("Box3 的体积： {0}", volume);
			Console.ReadKey();
		}
	}
	
}

说实话运算符重载用处没太了解...

可重载和不可重载运算符

运算符	描述
+, -, !, ~, ++, --	这些一元运算符只有一个操作数，且可以被重载。
+, -, *, /, %	这些二元运算符带有两个操作数，且可以被重载。
==, !=, <, >, <=, >=	这些比较运算符可以被重载。
&&, ||	这些条件逻辑运算符不能被直接重载。
+=, -=, *=, /=, %=	这些赋值运算符不能被重载。
=, ., ?:, ->, new, is, sizeof, typeof	这些运算符不能被重载。

3.动态多态性

C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。抽象类包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。

a.抽象类不能被实例化

b.不能在抽象类外部声明抽象方法

c.sealed关键字声明为密封类，密封类不能被继承。抽象类不能被sealed。

namespace InheritTest
{
	//定义抽象类
	abstract class Animal
	{
		//声明抽象类的抽象方法
		abstract public void eat();
	}
	//派生类-继承类
	class Dog: Animal
	{
		public double weigh;
		public override void eat()//继承类中实现抽象类的方法
		//要扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现，必须使用 override 修饰符。
		{
			Console.WriteLine("weigh={0}",weigh);
		}
		public void setWeigh(double w)
		{
			weigh = w;
		}
	}
	class ExecuteTest
	{
		static void Main(string[] args)
		{
			Dog d = new Dog();
			d.setWeigh(34.2);
			d.eat();
			Console.ReadKey();
		}
	}
}

当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。

虚方法是使用关键字 virtual 声明的。

虚方法可以在不同的继承类中有不同的实现。

对虚方法的调用是在运行时发生的。

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

namespace InheritTest
{
	//定义抽象类
	abstract class Animal
	{
		//声明虚函数
		public virtual void fly(){
			Console.WriteLine("基类的虚函数");
		}
	}
	//派生类-继承类
	class Dog: Animal
	{
		public double weigh;
		public void setWeigh(double w)
		{
			weigh = w;
		}
		public override void fly(){
			Console.WriteLine("继承类Dog 实现");
			base.fly();
		}
	}
	//派生类
	class cat: Animal
	{
		public override void fly()
		{
			Console.WriteLine("继承类Cat 实现");
			base.fly();
		}
	}

	class ExecuteTest
	{
		static void Main(string[] args)
		{
			Dog d = new Dog();
			d.setWeigh(34.2);
			d.fly();
			Console.ReadKey();
		}
	}
}