详解c# 多态

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

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

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

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

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

现实中,比如我们按下 F1 键这个动作:

  • 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;
  • 如果当前在 Word 下弹出的就是 Word 帮助;
  • 在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

静态多态性

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

  • 函数重载
  • 运算符重载

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

函数重载

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

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

using System;
namespace PolymorphismApplication
{
 public 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 Program
 {
 static void Main(string[] args)
 {
  TestData dataClass = new TestData();
  int add1 = dataClass.Add(1, 2);
  int add2 = dataClass.Add(1, 2, 3);

  Console.WriteLine("add1 :" + add1);
  Console.WriteLine("add2 :" + add2);
 }
 }
}

下面的实例演示了几个相同的函数 print(),用于打印不同的数据类型:

using System;
namespace PolymorphismApplication
{
 class Printdata
 {
 void print(int i)
 {
  Console.WriteLine("输出整型: {0}", i );
 }

 void print(double f)
 {
  Console.WriteLine("输出浮点型: {0}" , f);
 }

 void print(string s)
 {
  Console.WriteLine("输出字符串: {0}", s);
 }
 static void Main(string[] args)
 {
  Printdata p = new Printdata();
  // 调用 print 来打印整数
  p.print(1);
  // 调用 print 来打印浮点数
  p.print(1.23);
  // 调用 print 来打印字符串
  p.print("Hello Runoob");
  Console.ReadKey();
 }
 }
}

当上面的代码被编译和执行时,它会产生下列结果:

输出整型: 1
输出浮点型: 1.23
输出字符串: Hello Runoob

动态多态性

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

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

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

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

using System;
namespace PolymorphismApplication
{
 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;

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
{
 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 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();
 }

}

当上面的代码被编译和执行时,它会产生下列结果:

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

下面的程序演示通过虚方法 area() 来计算不同形状图像的面积:

using System;
namespace PolymorphismApplication
{
 class Shape
 {
 protected int width, height;
 public Shape( int a=0, int b=0)
 {
  width = a;
  height = b;
 }
 public virtual int area()
 {
  Console.WriteLine("父类的面积:");
  return 0;
 }
 }
 class Rectangle: Shape
 {
 public Rectangle( int a=0, int b=0): base(a, b)
 {

 }
 public override int area ()
 {
  Console.WriteLine("Rectangle 类的面积:");
  return (width * height);
 }
 }
 class Triangle: Shape
 {
 public Triangle(int a = 0, int b = 0): base(a, b)
 {

 }
 public override int area()
 {
  Console.WriteLine("Triangle 类的面积:");
  return (width * height / 2);
 }
 }
 class Caller
 {
 public void CallArea(Shape sh)
 {
  int a;
  a = sh.area();
  Console.WriteLine("面积: {0}", a);
 }
 }
 class Tester
 {

 static void Main(string[] args)
 {
  Caller c = new Caller();
  Rectangle r = new Rectangle(10, 7);
  Triangle t = new Triangle(10, 5);
  c.CallArea(r);
  c.CallArea(t);
  Console.ReadKey();
 }
 }
}

当上面的代码被编译和执行时,它会产生下列结果:

Rectangle 类的面积:
面积:70
Triangle 类的面积:
面积:25

以上就是详解c# 多态的详细内容,更多关于c# 多态的资料请关注我们其它相关文章!

(0)

相关推荐

  • 深入理解c#多态

    继承概念 多态:即一个接口,多个功能 同一种操作作用于不同的对象,可以有不同的解释,产生不同的执行结果 多态性可以是静态的或动态的.在静态多态性中,函数的响应是在编译时发生的.在动态多态性中,函数的响应是在运行时发生的 静态多态性 在静态多态性中,函数的响应是在编译时发生的 父类中如果有方法需要子类重写,可以将该方法标记为虚方法 虚方法必须在父类中有实现,空实现也可以 虚方法子类可以重写,也可以不重写 实现静态多态性有两种方法; 函数重载 运算符重载 函数重载 即在同一范围中对同一函数名的多重定

  • C#中多态、重载、重写区别分析

    本文实例总结了C#中多态.重载与重写的概念与区别.对于初学C#的朋友来说有不错的参考价值.分享给大家供大家参考.具体分析如下: 重写:是指重写基类的方法,在基类中的方法必须有修饰符virtual,而在子类的方法中必须指明override. 格式如下: 1.在基类中: public virtual void myMethod() { } 2.在子类中: public override void myMethod() { } 重写以后,用基类对象和子类对象访问myMethod()方法,结果都是访问在

  • C#中多态性的实现

    C#语言三大特性:继承,封装,多态 一:多态性 多态是指一个行为具有多个不同表现形式的能力,在C#中通过多态性的检测时机可以分为静态多态性和动态多态性 静态多态性:函数重载和运算符重载 动态多态性:抽象方法.重写方法.隐藏方法 二:函数重载(overlode) --函数名必须相同 --函数参数类型不同 --函数参数个数不同 --函数参数顺序不同 三:抽象(abstract) --包含抽象函数的类,类也必须定义为抽象的 --抽象函数只有定义没有函数体,并且必须定义为public --抽象类中可以包

  • C#中多态现象和多态的实现方法

    本文实例讲述了C#中多态现象和多态的实现方法.分享给大家供大家参考.具体分析如下: 面向对象的特征封装.继承和多态.Polymorphism(多态性)来源于希腊单词,指"多种形态".多态性的一个重要特征是方法的调用是在运行时确定而不是编译时.在.NET中用于实现多态性的关键词有virtual.override.abstract.interface. 一.virtual实现多态   shape类是通用的基类,draw是一个虚方法,每个派生类都可以有自己的override版本,在运行时可以

  • C#类的多态性详解

    第一种:编译时的多态性,直接这样说不知道说啥?程序执行过程主要分为三步:编译,链接,运行.在编译时体现的多态性是通过方法的重载来实现的.方法的重载我们听过,就是一个类对象调用若干同名,但参数类型.个数不同.类对象是根据参数类型,个数来决定调用哪个同名方法,实现何种操作.C#语言的方法重载与C++.java基本是一样的,但是C#还包含C++的运算符重载,java里面没有这个概念. 第二种:运行时的多态性,是在系统运行时,调用一个名字相同,参数类型也相同以及个数也完全一样的方法,但会完成不同的操作.

  • 深入浅析c#静态多态性与动态多态性

    C# 多态性 多态性意味着有多重形式.在面向对象编程范式中,多态性往往表现为"一个接口,多个功能". 多态性可以是静态的或动态的.在静态多态性中,函数的响应是在编译时发生的.在动态多态性中,函数的响应是在运行时发生的. 静态多态性 在编译时,函数和对象的连接机制被称为早期绑定,也被称为静态绑定.C# 提供了两种技术来实现静态多态性.分别为: •函数重载 •运算符重载 运算符重载将在下一章节讨论,接下来我们将讨论函数重载. 函数重载 您可以在同一个范围内对相同的函数名有多个定义.函数的定

  • C# 面向对象三大特性:封装、继承、多态

    面向对象有封装.继承.多态这三个特性,面向对象编程按照现实世界的特点来管理复杂的事物,把它们抽象为对象,具有自己的状态和行为,通过对消息的反应来完成任务.这种编程方法提供了非常强大的多样性,大大增加了代码的重用机会,增加了程序开发的速度,将具备独立性特制的程序代码包装起来,修改部分程序代码时不至于会影响到程序的其他部分. 1.封装 每个对象都包含它进行操作所需要的所有信息,封装只公开代码单元的对外接口,而隐藏其具体实现,尽量不对外公开代码.使用封装有很多好处,从设计角度来讲,封装可以对外屏蔽一些

  • C#中的多态深入理解

    封装.继承.多态,面向对象的三大特性,前两项理解相对容易,但要理解多态,特别是深入的了解,对于初学者而言可能就会有一定困难了.我一直认为学习OO的最好方法就是结合实践,封装.继承在实际工作中的应用随处可见,但多态呢?也许未必,可能不经意间用到也不会把它跟"多态"这个词对应起来.在此抛砖引玉,大家讨论,个人能力有限,不足之处还请指正. 之前看到过类似的问题:如果面试时主考官要求你用一句话来描述多态,尽可能的精炼,你会怎么回答?当然答案有很多,每个人的理解和表达不尽相同,但我比较趋向这样描

  • 详解c# 多态

    多态是同一个行为具有多个不同表现形式或形态的能力. 多态性意味着有多重形式.在面向对象编程范式中,多态性往往表现为"一个接口,多个功能". 多态性可以是静态的或动态的.在静态多态性中,函数的响应是在编译时发生的.在动态多态性中,函数的响应是在运行时发生的. 在 C# 中,每个类型都是多态的,因为包括用户定义类型在内的所有类型都继承自 Object. 多态就是同一个接口,使用不同的实例而执行不同操作,如图所示: 现实中,比如我们按下 F1 键这个动作: 如果当前在 Flash 界面下弹出

  • 详解C++ 多态的两种形式(静态、动态)

    1.多态的概念与分类 多态(Polymorphisn)是面向对象程序设计(OOP)的一个重要特征.多态字面意思为多种状态.在面向对象语言中,一个接口,多种实现即为多态.C++中的多态性具体体现在编译和运行两个阶段.编译时多态是静态多态,在编译时就可以确定使用的接口.运行时多态是动态多态,具体引用的接口在运行时才能确定. 静态多态和动态多态的区别其实只是在什么时候将函数实现和函数调用关联起来,是在编译时期还是运行时期,即函数地址是早绑定还是晚绑定的.静态多态是指在编译期间就可以确定函数的调用地址,

  • 详解Java多态对象的类型转换与动态绑定

    Java多态对象的类型转换 这里所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象.当对不存在继承关系的对象进行强制类型转换时,java 运行时将抛出 java.lang.ClassCastException 异常. 在继承链中,我们将子类向父类转换称为"向上转型",将父类向子类转换称为"向下转型". 很多时候,我们会将变量定义为父类的类型,却引用子类的对象,这个过程就是向上转型.程序运行时通过动态绑定来实现对子类方法的调用,也就是多态性. 然而有些时候

  • 详解C++ 多态的实现及原理

    C++的多态性用一句话概括就是:在基类的函数前加上virtual关键字,在派生类中重写该函数,运行时将会根据对象的实际类型来调用相应的函数.如果对象类型是派生类,就调用派生类的函数:如果对象类型是基类,就调用基类的函数 1:用virtual关键字申明的函数叫做虚函数,虚函数肯定是类的成员函数. 2:存在虚函数的类都有一个一维的虚函数表叫做虚表,类的对象有一个指向虚表开始的虚指针.虚表是和类对应的,虚表指针是和对象对应的. 3:多态性是一个接口多种实现,是面向对象的核心,分为类的多态性和函数的多态

  • 从汇编看c++中的多态详解

    在c++中,当一个类含有虚函数的时候,类就具有了多态性.构造函数的一项重要功能就是初始化vptr指针,这是保证多态性的关键步骤. 构造函数初始化vptr指针 下面是c++源码: class X { private: int i; public: X(int ii) { i = ii; } virtual void set(int ii) {//虚函数 i = ii; } }; int main() { X x(1); } 下面是对应的main函数汇编码: _main PROC ; 16 : in

  • C++ 通过指针实现多态实例详解

     C++ 通过指针实现多态实例详解 1.父类(DBConnector) 1)DBConnector.h #include <string> using namespace std; class DBConnector { private: string name; public: DBConnector(); DBConnector(string _name); ~DBConnector(); void show(); }; 2)DBConnector.cpp #include "D

  • C++/java 继承类的多态详解及实例代码

    C++/java 继承类的多态详解 学过C++和Java的人都知道,他们二者由于都可以进行面向对象编程,而面向对象编程的三大特性就是封装.继承.多态,所有今天我们就来简单了解一下C++和Java在多态这方面的不同. 首先我们各看一个案例. C++ //测试继承与多态 class Animal { public: char name[128]; char behavior[128]; void outPut() { cout << "Animal" << endl

  • Python类的继承和多态代码详解

    Python类的继承 在OOP(ObjectOrientedProgramming)程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类.父类或超类(Baseclass.Superclass). 我们先来定义一个classPerson,表示人,定义属性变量name及sex(姓名和性别): 定义一个方法print_title():当sex是male时,printman:当sex是female时,prin

  • Python面向对象编程之继承与多态详解

    本文实例讲述了Python面向对象编程之继承与多态.分享给大家供大家参考,具体如下: Python 类的继承 在OOP(Object Oriented Programming)程序设计中,当我们定义一个class的时候,可以从某个现有的class 继承,新的class称为子类(Subclass),而被继承的class称为基类.父类或超类(Base class.Super class). 我们先来定义一个class Person,表示人,定义属性变量 name 及 sex (姓名和性别): 定义一

  • 基于多态之虚方法、抽象类、接口详解

    虚方法: 1.在父类方法的返回值前加 virtual 关键字,标记为虚方法,表示这个方法可以被子类重写. 2.虚方法必须有方法体,方法体中可以没有任何内容. 3.子类可以根据需求选择性的是否重写虚方法.如果需要重写,在子类方法的返回值前加 override 关键字. 4.子类在重写虚方法时,可以根据需求选择性的是否使用 base 关键字调用父类中的该方法. 虚方法语法格式如下: public class Father { public virtual void Do() { //..... }

随机推荐