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 = 0)
        {
            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 = 0, double b = 0)
        {
            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 = 0)
        {
            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(5);
            double sa = s.Area();
            Console.WriteLine("面积： {0}", sa);
            Rectangle r = new Rectangle(10, 7);
            double ra = r.Area();
            Console.WriteLine("面积： {0}", ra);
            Circle c = new Circle(1);
            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(1, 2));
            Console.WriteLine("1.1+2.2=" + DoublePlusDouble(1.1, 2.2));
            Console.WriteLine("1.1+2=" + DoublePlusInt(1.1, 2));
            Console.WriteLine("1+2.2=" + IntPlusDouble(1, 2.2));


            Console.WriteLine("1+2=" + Plus(1, 2));
            Console.WriteLine("1.1+2.2=" + Plus(1.1, 2.2));
            Console.WriteLine("1.1+2=" + Plus(1.1, 2));
            Console.WriteLine("1+2.2=" + Plus(1, 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
    }
}