大专生从零开始学习c#的第十一天

今天我们学习c#的多态性，这是c#里非常重要的一个部分，而且对于我来说是一个完全没有接触到过的知识，如果出现了理解的错误希望大家提出来。

c#的多态性，理论上来说就是我有一个接口可以有多种实现的功能，他们属于同一个接口里但作用并不相同，如同我们家里的洗衣机，他可以是洗衣服，但有可以根据你的要求来甩干衣服，他都是洗衣机的功能，但是实现的功能完全不一样，

c#的多态也分为两种，1是静态多态性 2是动态多态性，我们的静态多态性是在我们的代码编译的时候就开始运行，而我们动态的多样性是在运行的时候发生的

静态多样性：也有两种的不同的重载 1是函数重载 2是运算符重载这里我们根据菜鸟教程上面的教学内容学习，函数重载，

函数重载比较的好理解，就是我们一种函数方法，同样的方法，不同的条件，不同的参数实，可以实现不同的功能

using System;

namespace _2022_7_13_duotaixing
{
    public class Duotai
    {
        public int Fangfa(int a,int b ,int c)

        {
            return a + b + c;
        }
        public int Fangfa(int a,int b)
        {
            return a * b;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Duotai duotai = new Duotai();
            int a1 = duotai.Fangfa(1, 2, 3);
            int A2 = duotai.Fangfa(2, 3);
            Console.WriteLine("第一个方法输出数{0}", a1);
            Console.WriteLine("第二个方法输出数{0}", A2);
        }
    }
}

这里我们就可以看我们的方法同样的名字但是给参数的不同实现了不一样的功能，这个就是函数的重载，这里是比较简单一个例子，但是可以实现很多的功能，

动态的多样性：动态里吗包括了抽象类，和虚方法，

抽象类我们在类的前面加上abstract来创建一个抽象类，这种创建出来的类，被派生继承下来，我们抽象类里面的抽象方法，也可以被继承的派生类来使用，当然我们不能在抽象类外面创建抽象方法，我们在类的前面加上sealed可以把这个类密封起来，具体有什么作用暂时没有体现出来，如果有机会再来介绍，

abstract class Cxl
    {
        abstract public int cxl();
    }
    class Cxlpai: Cxl
    {
        private int length;
        private int width;
        public Cxlpai(int a=0,int b=0)
        {
            length = a;
            width = b;
        }
        public override int cxl()
        {
            Console.WriteLine("该派生类的面积为");
            return (length * width);
        }
    }
 class Program
    {
        static void Main(string[] args)
        {
            Cxlpai cxlpai = new Cxlpai(4, 5);
            int a = cxlpai.cxl();
            Console.WriteLine("{0}", a);
            Console.ReadKey();
}

这里我们可以看到我们用abstract创建的抽象类。和里面的抽象方法，都可以被继承并且使用，在这里有一个比较重要的东西那就是，override 重写，如果我们创建了抽象类，并在里面创建了抽象方法，我们就必须在其派生的class里重写这个抽象的方法，不然我们的的派生类是不能继承我们的抽象类的，

虚方法：我们可以在我们创建的类里面，创建的方法前面加上virtual来创建虚方法，他一样可以被派生类继承重写并使用，虚方法是在代码运行的时候发生的，动态多态性加上由抽象和虚方法实现的

 class Xu
    {
        public virtual void Xua()
        {
            Console.WriteLine("这是虚方法a");
        }
    }
    class Xub : Xu
    {
        public override void Xua()
        {
            Console.WriteLine("这是虚方法a的重写");
          
        }
    }
    class Xuc : Xu
    {
        public override void Xua()
        {
            Console.WriteLine("这是虚方法a的第二次重写");
          
        }
    }
    class Xud:Xu
    {
        public override void Xua()
        {
            Console.WriteLine("这是虚方法的a的第三次重写");
          
        }
    }
class Program
    {
        static void Main(string[] args)
        {
           Xub xub = new Xub();
            Xuc xuc = new Xuc();
            Xud xud = new Xud();
            xub.Xua();
            xuc.Xua();
            xud.Xua();
            Console.ReadKey();
}

这里我们就可以看到我们在多个继承的派生类里面重写了我们的虚方法，达到了一个方法，多个功能的效果，

大专生从零开始学习c#的第十一天

猜你喜欢