c#中的多态学习总结

c#的多台方法，大体上和c++的类似，但是有点区别的，我这里刚刚初学，因此把重点记录下。

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

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

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

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

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

1、静态多态性

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

函数重载和运算符重载，运算符重载后续讨论，这里讨论函数重载。英文是overload，和c++的基本类似。

重载有一点是特别注意：不能通过返回值来重载，只能通过函数的参数进行重载。记得在侯捷的视频中，大师提到过，函数名是一样的，但是编译器其实已经做了标记，在底层函数名称是不一样。

函数重载和c++类似，这里不细谈了。总之一点就通过函数参数来重载的。2、动态多态性

2.1抽象类之abstract

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

c++也有抽象类，只要定义了纯虚函数的都成为抽象类，纯虚函数：virtual void area() = 0;     //定义纯虚函数，用来某形状计算面积而且不能实例化，只能被继承后，由派生类来实例化。

c#中，也有类似的特性，并且也更加多的特性，有关抽象类的一些规则：

a、您不能创建一个抽象类的实例。

b、您不能在一个抽象类外部声明一个抽象方法。

c、通过在类定义前面放置关键字sealed，可以将类声明为密封类。当一个类被声明为 sealed时，它不能被继承。抽象类不能被声明为 sealed。

抽象类的实例：

using System;
namespace PolymorphismApplication
{
   abstract class Shape        //abstract关键字来定义抽象类
   {
       abstract public int area();
   }
   class Rectangle:  Shape    //继承shape抽象类
   {
      private int length;
      private int width;
      public Rectangle( int a=0, int b=0)
      {
         length = a;
         width = b;
      }
      //public int area() //编译错误
      public override int area ()        //重新做派生类中实现area方法，但要是用override“重写”，否则编译错误
      { 
         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();
      }
   }
}

2.2虚方法之virtual

当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。虚方法是使用关键字 virtual声明的。虚方法可以在不同的继承类中有不同的实现。对虚方法的调用是在运行时发生的。

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

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

虚方法的实例如下：

#define OV      //宏定义一定要放在using前面
/*如果注释掉上面的宏定义，那么程序输出的结果是：

 执行基类的画图任务
 执行基类的画图任务
 执行基类的画图任务
 说明，使用new的方法是错误的，与设想的功能偏离了。
 * 说白了，子类调用Draw()的使用是调用了基类的Draw().并没有实现多态的功能
 如果使用上面的宏定义
 输出是
画一个长方形
执行基类的画图任务
画一个三角形
执行基类的画图任务
画一个圆形
执行基类的画图任务
请按任意键继续. . .
 这样就实现了多态。
 * 
 * 这里强调一次：
 * 在子类中用 override 重写父类中用 virtual 申明的虚方法时，
 * 实例化父类调用该方法，执行时调用的是子类中重写的方法；

    如果在子类中用 new 覆盖父类中用 virtual 申明的虚方法时，
 * 实例化父类调用该方法，执行时调用的是父类中的虚方法
 * 
 *  override是重写，即将基类的方法在派生类里直接抹去重新写，故而调用的方法就是子类方法；
 *  而new只是将基类的方法在派生类里隐藏起来，故而调用的仍旧是基类方法。
 */

using System;
using System.Collections.Generic;

public class Shape
{
    //四个语句没用到
    //public int X { get; private set; }
    //public int Y { get; private set; }
    //public int Height { get; set; }
    //public int Width { get; set; }

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

class Circle : Shape
{
#if (OV)
    public override void Draw()     //使用override重写
#else
    public new void Draw()
#endif
    {
        Console.WriteLine("画一个圆形");
        base.Draw();        //调用基类的放大，使用base
    }
}
class Rectangle : Shape
{
#if (OV)
    public override void Draw()     //使用override重写
#else
    public new void Draw()
#endif  
    {
        Console.WriteLine("画一个长方形");
        base.Draw();        //调用基类的放大，使用base
    }
}
class Triangle : Shape
{
#if (OV)
    public override void Draw()     //使用override重写
#else
    public new void Draw()
#endif
    {
        Console.WriteLine("画一个三角形");
        base.Draw();        //调用基类的放大，使用base
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建一个 List<Shape> 对象，并向该对象添加 Circle、Triangle 和 Rectangle
        var shapes = new List<Shape>
        {
            new Rectangle(),
            new Triangle(),
            new Circle()
        };

        // 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法 
        foreach (var shape in shapes)
        {
            shape.Draw();
        }

        //Console.WriteLine("按下任意键退出。");
        //Console.ReadKey();
    }
}

在来一个实例：

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

namespace PolymorphismApplication
{
    abstract class Shape        //抽象类
    {
        public abstract 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("计算长方形类的面积：");
            return (width * length);
        }
    }

    class triangle : Shape      //继承抽象类
    {
        private int baseLine;
        private int height;
        public triangle(int a = 0, int b = 0)
        {
            baseLine = a;
            height = b;
        }
        public override int area()  //重写抽象类的方法
        {
            Console.WriteLine("计算三角形类的面积：");
            return (2 * baseLine * height / 4);
        }
    }

    class RectangleTester
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle(10, 7); //实例化长方形
            double a = r.area();    //计算长方形的面积
            triangle t = new triangle(10, 7);   //实例化三角形
            double b = t.area();    //计算三角形的面积
            Console.WriteLine("长方形面积： {0}, 三角形面积：{1}", a, b);
            //Console.ReadKey();
        }
    }
}

/*

 运行结果：

 计算长方形类的面积：

计算三角形类的面积：

长方形面积： 70, 三角形面积：35

请按任意键继续. . .

 */

3、总结：

C# 多态性

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

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

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

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

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

运算符重载，这个后续在讨论。

3.3、关键字 abstract 声明抽象类：用于接口部分类的实现（派生类继承抽象类时，实现完成）。抽象类包含抽象方法，抽象方法可被派生类实现。

抽象类规则：

1.不能创建抽象类的实例

2.不能在抽象类外定义抽象方法

3.不能把抽象类声明为sealed（类前带关键字sealed代表该类是密封类，不能被继承）

4.关键字virtual声明虚方法:用于方法在继承类中的实现（在不同的继承类中有不同的实现）。虚方法也可以被直接调用。

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

注：继承类中的重写虚函数需要声明关键字 override，在方法参数传入中写（类名 形参名）例如 public void CallArea(Shape sh)，意思是传入一个 shape 类型的类。

3.4、virtual 和 abstract区别

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

1.virtual修饰的方法必须有实现（哪怕是仅仅添加一对大括号),而abstract修饰的方法一定不能实现。

2.virtual可以被子类重写，而abstract必须被子类重写。

 3.如果类成员被abstract修饰，则该类前必须添加abstract，因为只有抽象类才可以有抽象方法。

4.无法创建abstract类的实例，只能被继承无法实例化。

5.虚方法也可以被直接调用

3.5、重载和重写区别

重载(overload)是提供了一种机制,相同函数名通过不同的返回值类型以及参数来表来区分的机制。重载在同一个作用域(一般指一个类)的两个或多个方法函数名相同，参数列表不同的方法叫做重载，它们有三个特点(俗称两必须一可以):

a.方法名必须相同

b.参数列表必须不相同

c.返回值类型可以不相同

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

子类中为满足自己的需要来重复定义某个方法的不同实现，需要用 override 关键字，被重写的方法必须是虚方法，用的是 virtual 关键字。它的特点是(三个相同):

相同的方法名

相同的参数列表

相同的返回值

3.6、抽象方法和虚方法的区别

1.虚方法必须有实现部分，抽象方法没有提供实现部分，抽象方法是一种强制派生类覆盖的方法，否则派生类将不能被实例化。这个是特别需要注意的！

 2.抽象方法只能在抽象类中声明，虚方法不是。如果类包含抽象方法，那么该类也是抽象的，也必须声明类是抽象的。这一点好c++是一样的。

 3.抽象方法必须在派生类中重写，这一点和接口类似，虚方法不需要再派生类中重写。简单说，抽象方法是需要子类去实现的。虚方法是已经实现了的，可以被子类覆盖，也可以不覆盖，取决于需求。

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