C# 中多态和重载的区别

一、多态性意味着有多重形式。

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

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

 namespace PolymorphismApplication
 {
     /// <summary>
     /// 几何图形，抽象基类
     /// </summary>
     abstract class Geometric
     {
         public abstract double Area();
     }

     /// <summary>
     /// 正方形
     /// </summary>
     class Square : Geometric
     {
         private double side;
         public Square(double a = )
         {
             side = a;
         }
         public override double Area()
         {
             Console.WriteLine("Square 类的面积：");
             return (side * side);
         }
     }
     /// <summary>
     /// 长方形
     /// </summary>
     class Rectangle : Geometric
     {
         private double length;
         private double width;
         public Rectangle(double a = , double b = )
         {
             length = a;
             width = b;
         }
         public override double Area()
         {
             Console.WriteLine("Rectangle 类的面积：");
             return (width * length);
         }
     }
     /// <summary>
     /// 圆型
     /// </summary>
     class Circle : Geometric
     {
         private double r;
         public Circle(double a = )
         {
             r = a;
         }
         public override double Area()
         {
             Console.WriteLine("Circle 类的面积：");
             return (3.14*r*r);
         }
     }

     class Program
     {
         static void Main(string[] args)
         {
             Square s = new Square();
             double sa = s.Area();
             Console.WriteLine("面积： {0}", sa);
             Rectangle r = new Rectangle(, );
             double ra = r.Area();
             Console.WriteLine("面积： {0}", ra);
             Circle c = new Circle();
             double ca = c.Area();
             Console.WriteLine("面积： {0}", ca);
             Console.ReadKey();
         }
     }
 }

抽象基类Geometric中定义了抽象方法Area public abstract double Area();

不同的子类继承了基类Geometric，分别实现了Area()，但是正方形和长方形和圆型的Area()又不相同。这就是多态性。

二、重载

重载是指具有相同的函数名词，但是参数类型，个数不相同。

举个例子

编程实现两个整数相加

public static int IntPlusInt(int a, int b)
{
    return a + b;
}

没有问题，再写个double类型和double类型相加

public static double DoublePlusDouble(double a, double b)
{
    return a + b;
}

doub 和int相加：

public static double DoublePlusInt(double a, int b)
{
    return a + b;
}

public static double IntPlusDouble(int a, double b)
{
    return a + b;
}

就这样，简单的int和double类型的相加就需要4个方法。

你在计算时还得想一下，int类型相加的方法名称是什么。

重载，可以使得上面的事情变得简单：

public static int Plus(int a, int b)
{
    return a + b;
}

public static double Plus(double a, double b)
{
    return a + b;
}

public static double Plus(double a, int b)
{
    return a + b;
}

public static double Plus(int a, double b)
{
    return a + b;
}

方法名称全都是Plus，不需要起很多名字，方便使用。调用时，vs会根据变量类型自动匹配到相应的方法。

附全部代码

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

 namespace Overload
 {
     class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("1+2=" + IntPlusInt(, ));
             Console.WriteLine("1.1+2.2=" + DoublePlusDouble(1.1, 2.2));
             Console.WriteLine("1.1+2=" + DoublePlusInt(1.1, ));
             Console.WriteLine("1+2.2=" + IntPlusDouble(, 2.2));

             Console.WriteLine("1+2=" + Plus(, ));
             Console.WriteLine("1.1+2.2=" + Plus(1.1, 2.2));
             Console.WriteLine("1.1+2=" + Plus(1.1, ));
             Console.WriteLine("1+2.2=" + Plus(, 2.2));

             Console.ReadKey();
         }

         #region 不使用重载
         public static int IntPlusInt(int a, int b)
         {
             return a + b;
         }

         public static double DoublePlusDouble(double a, double b)
         {
             return a + b;
         }

         public static double DoublePlusInt(double a, int b)
         {
             return a + b;
         }

         public static double IntPlusDouble(int a, double b)
         {
             return a + b;
         }
         #endregion

         #region 使用重载
         public static int Plus(int a, int b)
         {
             return a + b;
         }

         public static double Plus(double a, double b)
         {
             return a + b;
         }

         public static double Plus(double a, int b)
         {
             return a + b;
         }

         public static double Plus(int a, double b)
         {
             return a + b;
         }
         #endregion
     }
 }