详解C#中多态性学习/虚方法/抽象方法和接口的用法

1. 多态性定义

C#中的多态性是OOP(面向对象编程)的一个基本概念,它允许一个对象在不同情况下表现出不同的行为,以增强代码的可重用性和灵活性。

根据网上的教程,我们得知C#多态性分为两类,静态和动态。但实际上,C#没有严格的静态和动态多态性的分法。之所以这么分,还是为了我们便于理解,我们沿用这个思维来大概分类:

采用函数重载或运算符重载方法的,属于静态多态性;

采用虚方法、抽象方法、接口等方式,属于动态多态性。

拓展:

在静态多态性中,函数的响应是在编译时发生的。在动态多态性中,函数的响应是在运行时发生的。什么意思呢?

在静态语言中,许多多态性的特性可以在编译时确定,编译器可以根据数据类型的信息来确定方法的调用方式。

而在动态语言中,数据类型的确定通常是在运行时进行的,这种行为被称为动态多态性。

2. 函数重载示例

函数重载是指在同一个类中,定义多个方法,它们的方法名相同,但是参数类型、参数数量、参数顺序不同。以下是一个函数重载的例子:

  1. public class Calculator
  2. {
  3.      public int Add(int a, int b)
  4.      {
  5.          return a + b;
  6.      }
  7.      public int Add(int a, int b, int c)
  8.      {
  9.          return a + b + c;
  10.      }
  11.      public float Add(float a, float b)
  12.      {
  13.          return a + b;
  14.      }
  15.      public double Add(double a, double b)
  16.      {
  17.          return a + b;
  18.      }
  19. }

在这个例子中,Calculator类定义了4个Add()方法,它们的方法名相同但是参数列表不同(分别有2个整型参数、3个整型参数、2个浮点型参数、2个双精度浮点型参数)。这些方法根据声明的参数类型和数量而得到不同的签名,因此构成函数重载,当调用Add()方法时,编译器会根据参数的类型和数量来选择正确的方法重载进行调用。

3. 虚方法示例

虚方法和重写(override)方法:在父类中声明一个虚方法,子类可以重写该方法并实现自己的行为。在运行时,程序根据对象的实际类型调用相应的方法。这种方式也称为“消除静态绑定”。

注意事项:虚方法是使用关键字 virtual 声明的。同时继承类中的重写虚函数需要声明关键字 override 。下面是一个示例:

  1. // 定义一个Animal类和其子类
  2. class Animal
  3. {
  4.      public virtual void Speak()
  5.      {
  6.          Console.WriteLine(“I am an animal.”);
  7.      }
  8. }
  9.  
  10. class Dog : Animal
  11. {
  12.      public override void Speak()
  13.      {
  14.          Console.WriteLine(“Woof!”);
  15.      }
  16. }
  17.  
  18. class Cat : Animal
  19. {
  20.      public override void Speak()
  21.      {
  22.          Console.WriteLine(“Meow!”);
  23.      }
  24. }
  25.  
  26. // 示例程序
  27. class Program
  28. {
  29.      static void Main(string[] args)
  30.      {
  31.          Animal[] animals = new Animal[2];
  32.          animals[0] = new Dog();
  33.          animals[1] = new Cat();
  34.  
  35.          foreach (Animal animal in animals)
  36.          {
  37.              animal.Speak();
  38.          }
  39.  
  40.          Console.ReadKey();
  41.      }
  42. }

在这个例子中,Animal类中声明了一个虚方法Speak(),它的子类 Dog 和 Cat 分别对该方法进行了重写。在Main 方法中,创建了一个 Animal 数组,其中存放了 Dog 和 Cat 的实例。在foreach循环中,程序根据实际对象类型调用了不同的Speak()方法,实现了多态性的效果。

小拓展:关键字重写 override 与覆盖 new 较为容易搞混,有关两者区别可移步:C#中重写(override)及覆盖(new)的区别详解。

4. 抽象方法示例

抽象方法是在抽象类中定义的,它没有具体实现的代码,而只是定义了方法的名称、参数和返回值类型等信息。抽象方法必须在子类中进行完整的实现,否则子类本身也必须定义为抽象类。使用abstract关键字来定义抽象类和抽象方法。

下面的示例演示了如何定义并使用抽象方法:

  1. abstract class Shape
  2. {
  3.      public abstract double Area(); // 定义抽象方法Area()
  4. }
  5. // 派生类Rectangle继承抽象类Shape
  6. class Rectangle : Shape
  7. {
  8.      double width, height;
  9.  
  10.      public Rectangle(double w, double h)
  11.      {
  12.      width = w;
  13.      height = h;
  14.      }
  15.      public override double Area() // 实现抽象方法Area()
  16.      {
  17.      return width * height;
  18.      }
  19. }
  20.  
  21. class Triangle : Shape
  22. {
  23.      double baseValue, height;
  24.  
  25.      public Triangle(double bv, double h)
  26.      {
  27.      baseValue = bv;
  28.      height = h;
  29.      }
  30.      public override double Area() // 实现抽象方法Area()
  31.      {
  32.      return baseValue * height * 0.5;
  33.      }
  34. }
  35.  
  36. class Program
  37. {
  38.      static void Main(string[] args)
  39.      {
  40.      Rectangle r = new Rectangle(5, 8);
  41.      Console.WriteLine(“矩形的面积 = {0}”, r.Area());
  42.  
  43.      Triangle t = new Triangle(5, 8);
  44.      Console.WriteLine(“三角形的面积 = {0}”, t.Area());
  45.      }
  46. }

上面的代码定义了Shape类和两个派生类Rectangle和Triangle。Shape类中定义了一个抽象方法Area(),并在Rectangle和Triangle中实现了这个抽象方法。在Main方法中,创建了一个Rectangle对象 r 和一个Triangle对象 t,并分别调用它们的Area()方法计算出它们的面积。

5. 接口示例

C#接口是一种约定,是一个抽象的类型,它定义了一组公共的方法、属性、索引器和事件,这些成员没有实现细节和实现代码,只定义了接口的行为。

5.1 接口语法

定义接口的语法如下:

interface 接口名称
{
方法1
方法2
属性1
索引器1
事件1
}

其中,方法、属性、索引器和事件都是接口的成员,它们都没有实现,只是定义了行为的名称和参数。

方法定义的语法如下:返回类型 方法名称(参数列表);

属性定义的语法如下:属性类型 属性名称 { get; set; }

索引器定义的语法如下:索引器类型 this[索引器参数] { get; set; }

事件定义的语法如下:event 事件委托类型 事件名称;

其中,事件委托类型是一个Delegate类型。

5.2 接口使用示例

定义一个接口之后,可以通过继承或实现来使用接口。接口的继承使用“:”符号,需要注意的是,如果一个类实现了一个接口,那么它必须实现接口中所有的方法和属性。下面是接口示例:

  1. interface IShape
  2. {
  3.      double Perimeter();
  4.      double Area();
  5. }
  6.  
  7. interface ICircle : IShape
  8. {
  9.      double Radius { get; set; }
  10. }
  11.  
  12. interface IRectangle : IShape
  13. {
  14.      double Width { get; set; }
  15.      double Height { get; set; }
  16. }
  17.  
  18. class Circle : ICircle
  19. {
  20.      public double Radius { get; set; }
  21.  
  22.      public double Perimeter()
  23.      {
  24.      return 2 * Math.PI * Radius;
  25.      }
  26.  
  27.      public double Area()
  28.      {
  29.      return Math.PI * Radius * Radius;
  30.      }
  31. }
  32.  
  33. class Rectangle : IRectangle
  34. {
  35.      public double Width { get; set; }
  36.      public double Height { get; set; }
  37.  
  38.      public double Perimeter()
  39.      {
  40.      return 2 * (Width + Height);
  41.      }
  42.  
  43.      public double Area()
  44.      {
  45.      return Width * Height;
  46.      }
  47. }
  48.  
  49. class Program
  50. {
  51.      static void Main(string[] args)
  52.      {
  53.      Circle c = new Circle();
  54.      c.Radius = 1;
  55.      Console.WriteLine(“Circle: Perimeter = {0}, Area = {1}”, c.Perimeter(), c.Area());
  56.  
  57.      Rectangle r = new Rectangle();
  58.      r.Width = 2;
  59.      r.Height = 3;
  60.      Console.WriteLine(“Rectangle: Perimeter = {0}, Area = {1}”, r.Perimeter(), r.Area());
  61.      }
  62. }

上面的代码定义了IShape、ICircle和IRectangle三个接口、以及Circle和Rectangle两个类。其中,Circle类实现了ICircle接口,Rectangle类实现了IRectangle接口。在Main方法中,创建了一个Circle对象和一个Rectangle对象,并给它们的属性赋值。然后分别调用了Circle和Rectangle对象的Perimeter()和Area()方法输出结果。

运行程序,输出以下结果:

Circle:  Perimeter = 6.28318530717959, Area = 3.14159265358979
Rectangle:  Perimeter = 10, Area = 6

可以看到,通过使用接口,我们可以很方便地定义出不同的形状,然后计算出它们的周长和面积。这就展示了接口在C#编程中的重要地位。

想必大家看到这里对于多态性的实现方式已经有了一定的了解,不知大家是否发现,这些方式中,抽象方法和虚方法是如此的相似,那么我们就有了新的疑问:两者有何区别?使用场景是否有所不同?

在下面这篇随笔中,我针对这个问题进行了深入学习:C#中抽象方法与虚方法的区别。

以上就是详解C#中多态性学习/虚方法/抽象方法和接口的用法的详细内容,更多关于C# 多态性 虚方法 抽象方法 接口的资料请关注我们其它相关文章!

标签

发表评论