c#多态性

C# 多态性

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

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

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

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

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

  静态多态性

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

• 函数重载
• 运算符重载

运算符重载将在下一章节讨论，接下来我们将讨论函数重载。

函数重载

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

下面的实例演示了几个相同的函数 Add()，用于对不同个数参数进行相加处理：

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

namespace week2._1
{
    class TestData
    {
        
        public int Add(int a, int b, int c)
        {
            return a + b + c;
        }
        //函数重载
        public int Add(int a,int b)
        {
            return a + b;
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
            TestData data = new TestData();
            int add1 = data.Add(1, 2, 3);
            int add2 = data.Add(1, 2);

            Console.WriteLine("三个值的和" + add1);
            Console.WriteLine("两个值的和" + add2);
            Console.ReadKey();
        }
    }
}

 结果：

三个值的和6
两个值的和3

 动态多态性

抽象类：

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

请注意，下面是有关抽象类的一些规则：

• 您不能创建一个抽象类的实例。
• 您不能在一个抽象类外部声明一个抽象方法。
• 通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。

下面的程序演示了一个抽象类：

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

namespace week2._1
{
    abstract class Shape
    {
        abstract public int area();
    }
    class Rectangle : Shape
    {
        private int length;
        private int width;
        public Rectangle(int a = 0, int b = 0)
        {
            length = a;
            width = b;
        }
        public override int area()
        {
            Console.WriteLine("Rectangle 类的面积：");
            return (width * length);
        }
    }

    class RectangleTester
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle(10, 7);
            double a = r.area();
            Console.WriteLine("面积： {0}", a);
            Console.ReadKey();
        }
    }
}

 

结果：

Rectangle 类的面积：
面积： 70

 虚方法：

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

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

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

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

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

以下实例创建了 Shape 基类，并创建派生类 Circle、 Rectangle、Triangle， Shape 类提供一个名为 Draw 的虚拟方法，在每个派生类中重写该方法以绘制该类的指定形状。

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

namespace week2._1
{
    public class Shape
    {
        public int X { get; private set; }
        public int Y { get; private set; }
        public int Width { get; set; }
        public int Height { get; set; }

        //虚方法
        public virtual void Draw()
        {
            Console.WriteLine("执行基类的画图方法");
        }
    }

    class Circle : Shape
    {
        public override void Draw()
        {
            Console.WriteLine("画一个圆形");
            base.Draw();
        }
    }

    class Rectangle : Shape
    {
        public override void Draw()
        {
            Console.WriteLine("画一个长方形");
            base.Draw();
        }
    }

    class Triangle : Shape
    {
        public override void Draw()
        {
            Console.WriteLine("画一个三角形");
            base.Draw();
        }
    }

    class Test
    {
        static void Main(string[] args)
        {
            //创建一个list<shape>对象，并往该对象添加circle、rectangle、triangle
            var shapes = new List<Shape>
            {
                new Circle(),
                new Rectangle(),
                new Triangle()
            };
            //使用foreach循环对该列表的派生类进行循环访问，并对每个shape调用draw方法
            foreach(var shape in shapes)
            {
                shape.Draw();
            }
            Console.WriteLine("按任意键退出");
            Console.ReadKey();
        }
    }
}

 结果：

画一个圆形
执行基类的画图方法
画一个长方形
执行基类的画图方法
画一个三角形
执行基类的画图方法
按任意键退出

多态：一个接口多个功能。

静态多态性：编译时发生函数响应（调用）；

动态多态性：运行时发生函数响应。

静态绑定（早期绑定）：编译时函数和对象的连接机制。 两种技术实现静态多态性：函数重载/运算符重载。

函数重载：在同一范围内对相同函数名有多个定义，可以是参数类型或参数个数的不同，但不许只有返回值类型不同。

运算符重载：

virtual和abstract都是用来修饰父类的，通过覆盖父类的定义，让子类重新定义。

•  1.virtual修饰的方法必须有实现（哪怕是仅仅添加一对大括号),而abstract修饰的方法一定不能实现。
•  2.virtual可以被子类重写，而abstract必须被子类重写。
•  3.如果类成员被abstract修饰，则该类前必须添加abstract，因为只有抽象类才可以有抽象方法。
•  4.无法创建abstract类的实例，只能被继承无法实例化。

抽象类和虚方法共同实现动态多态性。

重写(override)是用于重写基类的虚方法,这样在派生类中提供一个新的方法

重载(overload)是提供了一种机制, 相同函数名通过不同的返回值类型以及参数来表来区分的机制。

抽象方法和虚方法的区别

•  1.虚方法必须有实现部分，抽象方法没有提供实现部分，抽象方法是一种强制派生类覆盖的方法，否则派生类将不能被实例化。
•  2.抽象方法只能在抽象类中声明，虚方法不是。如果类包含抽象方法，那么该类也是抽象的，也必须声明类是抽象的。
•  3.抽象方法必须在派生类中重写，这一点和接口类似，虚方法不需要再派生类中重写。

简单说，抽象方法是需要子类去实现的。虚方法是已经实现了的，可以被子类覆盖，也可以不覆盖，取决于需求。

抽象方法和虚方法都可以供派生类重写。