C#——多态详情

多态

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

多态分为两种 :

静态性多态: 函数重载，符号重载动态性多态: 虚方法，抽象类，接口

静态多态

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

•函数重载
•运算符重载

静态多态之函数重载

函数重载: 在同一个范围内对相同的函数名有多个定义，必须保持函数名一样但参数类型或者参数的个数或者方法的返回值不一样

静态函数之符号重载

运算符重载是指允许用户使用自己定义的类型编写运算符号，同时还允许用户定义的类型与预定义的类型具有相同的功能。符号重载就是把已经定义的、有一定功能的操作符进行重新定义,来完成更为细致具体的运算等功能。(比如两个类相加)因此，在C#语言中，允许用户定义的类型通过使用operator关键字定义成静态成员函数的形式来重载运算符。

符号重载:// +(正)一（负）!~++—-一元运算符号可以重载/ /+―*/%// =! > < >= <= / / = !> <>=<=// && || 不能直接重载// += -= *= /= %= 不能重载// =?: new is 不能重载

符号重载是一个方法，可以有返回值的方法，关键字operator符号进行重载时，参数必须是包含类型本类类型

接下来变为大家分享一下如何封装符号重载

     封装符号重载的类
        //符号重载的多态
        class Rect
        {
            public double Length;
            public double Width;
            public double Height;
            public double Volume;
    
            public Rect()
            {
    
            }
            //有参数的构造函数
            public Rect(double l, double w, double h)
            {
                Length = l;
                Width = w;
                Height = h;
            }
            ~Rect()
            {
                Console.WriteLine("析构函数,当对象被释放的时候出发构习函数把一个对象null 然后通过Gc垃圾回收之后触发");
            }
            //计算体积的方法
            public double GetV()
            {
                return Length * Width * Height;
            }
    
            // ====================符号重载方法=========================
            //符号重载: 是一个方法，有返回值的方法，关键字operator符号
            public static Rect operator +(Rect r1, Rect r2)// 使用+重载方法传递两个Rect对象
            {
                Rect r3 = new Rect();
                r3.Length = r1.Length + r2.Length;
                r3.Width = r1.Width + r2.Width;
                r3.Height = r1.Height + r2.Height;
                r3.Volume = r3.GetV();
    
                return r3;
            }
    
            // 进行重载时，参数必须是包含类型 本类类型
            public static int operator -(Rect r1, Rect r2)
            {
                // r1的面积-r2的面积
                int a = Convert.ToInt16((r1.Length * r1.Width + r1.Length * r1.Height + r1.Width * r1.Height)-(r2.Length * r2.Width + r2.Length * r2.Height + r2.Width * r2.Height));
    
                return a;
            }
    
            // 重载==和!=需要一起写
            // 重载==
            public static bool operator == (Rect r1, Rect r2)
            {
                bool b = r1.GetV() == r2.GetV()?true:false;
                return b;
            }
            // 重载!=
            public static bool operator !=(Rect r1, Rect r2)
            {
                bool b = r1.GetV() != r2.GetV() ? true : false;
                return b;
            }
        }

调用该方法

        // 创建第一个rect对象
        Rect r1 = new Rect(2,5,4);
        // 创建第二个rect对象
        Rect r2 = new Rect(3, 6, 9);
        // 使用加号把r1+r2进行相加
        Rect r3 = r1 + r2;
        Console.WriteLine(r3.Height);
        Console.WriteLine(r1 - r2);
        Console.Read();

密封类

密封类使用sealed关键字定义，它不能被继承

继承的话会报错

动态性多态

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

动态性多态之虚方法

当父类有一个方法,子类使用继承可以把父类方法继承过去.如果在子类想定义继承过来方法重名的方法,需要在父类把这个方法定义后的方法,在子类的方法定义使用重写方法

1 当父类有一个方法需要在继承的类实现时候，可以使用虚方法2 使用virtual()进行定义虚方法3 虚方法可以在子类进行添加overrider进行重写

实例 :

动态性多态之抽象类

抽象类

抽象类使用 abstract定义抽象类

抽象类只是用来举例一个类所具备的行为，不能通过new 创建对象

抽象类可以有抽象方法，只有声明部分没有实现部分

抽象类里面也可以有普通方法

抽象类不能是static(静态) 也不能是scaled(密封)

抽象方法:

1 只能定义在抽象类里面，在方法前面添加abstract进行修饰

2 只有声明没有实现部分

3 抽象方法在子类被实现需要再子类的方法前面添加overrier关键字

4 子类必须重写所有的父类的抽象方法，除非子类也是抽象方法

实例:

动态性多态之接口

接口:

使用interface关键字定义接口以后一般以I开头进行命名

接口中的属性方法等只做一个声明，没有任何实现。

接口当中的属性和方法默认都是public的。

接口的特点:

1 接口具有强制性，必须对接口里面属性和方法进行实现

2 接口可以实现(:)另外一个接口，类可以实现一个接口或者多个接口

实例:

当子类同时继承接口和基类时，接口需要写在最后面

接口和抽象类的区别

不同点：

        1 抽象类关键字abstract(爱步丝拽个它)，接口的关键字interface (int肥死)
        2 一个类只能继承一个抽象类，一个类可以实现多个接口
        3 抽象类可以定义抽象方法，非抽象子类必须实现父类的抽象方法；
4 接口必须实现接口里面所有属性和方法
5 实现抽象方法需要关键字overrider (哦哇ruai的)，接口直接实现就行