English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Le polymorphisme est la capacité d'avoir plusieurs formes ou expressions différentes pour le même comportement.
Le polymorphismeCela signifie qu'il y a plusieurs formes. Dans le paradigme de programmation orientée objet, le polymorphisme se manifeste souvent sous la forme de "une interface, plusieurs fonctions".
Le polymorphisme peut être statique ou dynamique. DansLe polymorphisme statiqueDans, la réponse de la fonction se produit lors de la compilation. Dans动态多态性Dans, la réponse de la fonction se produit au moment de l'exécution.
Dans C#, chaque type est polymorphique, car tous les types, y compris les types définis par l'utilisateur, héritent de Object.
Le polymorphisme est une interface la même, utilisant différents exemples pour exécuter différentes opérations, comme le montre la figure :
Dans la vie réelle, par exemple,当我们按下 F1 Cette action de touche :
Sous l'interface Flash, ce qui apparaît est AS 3 Aide documentaire ;
Si l'assistant de Word apparaît sous Word ;
Sous Windows, ce qui s'affiche est l'aide et le support de Windows.
Le même événement produit des résultats différents sur des objets différents.
Au moment de la compilation, le mécanisme de liaison entre les fonctions et les objets est appelé liaison précoce, ou liaison statique. C# fournit deux techniques pour réaliser la polymorphisme statique. Ce sont :
函数重载
L'overloading des opérateurs
L'overloading des opérateurs sera discuté dans le prochain chapitre, nous allons ensuite discuter de l'overloading des fonctions.
您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。
下面的示例演示了几个相同的函数 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 w3codebox");
Console.ReadKey();
}
}
}Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :
输出整型: 1 输出浮点型: 1.23 输出字符串: Hello w3codebox
C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。Classe abstraite包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。
请注意，下面是有关抽象类的一些规则：
您不能创建一个抽象类的示例。
您不能在一个抽象类外部声明一个抽象方法。
通过在类定义前面放置关键字 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("Surface of Rectangle class : ");
return (width * length);
}
}
class RectangleTester
{}}
static void Main(string[] args)
{}}
Rectangle r = new Rectangle(10, 7);
double a = r.area();
Console.WriteLine("Surface : {0}", a);
Console.ReadKey();
}
}
}Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :
Surface de la classe Rectangle : Surface : 70
Lorsqu'il y a une fonction définie dans une classe qui doit être implémentée dans la classe héritée, on peut utiliserMéthode virtuelle.
Les méthodes virtuelles sont définies en utilisant le mot-clé virtual déclaré.
Les méthodes virtuelles peuvent avoir des implémentations différentes dans des classes héritées différentes.
l'appel de méthode virtuelle se produit au moment de l'exécution.
La polymorphisme dynamique est réalisé par Classe abstraite et Méthode virtuelle implémenté.
Le exemple suivant crée la classe de base Shape, et crée les classes dérivées Circle, Rectangle, Triangle, la classe Shape fournissant une méthode virtuelle nommée Draw, cette méthode est redéfinie dans chaque classe dérivée pour dessiner la forme spécifique de la classe.
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; }
// Méthode virtuelle
public virtual void Draw()
{}}
Console.WriteLine("Exécuter la tâche de dessin de la classe mère");
}
}
class Circle : Shape
{}}
public override void Draw()
{}}
Console.WriteLine("Dessiner un cercle");
base.Draw();
}
}
class Rectangle : Shape
{}}
public override void Draw()
{}}
Console.WriteLine("Dessiner un rectangle");
base.Draw();
}
}
class Triangle : Shape
{}}
public override void Draw()
{}}
Console.WriteLine("Dessiner un triangle");
base.Draw();
}
}
class Program
{}}
static void Main(string[] args)
{}}
// Créer un objet List<Shape> et ajouter Circle, Triangle et Rectangle à cet objet
var shapes = new List<Shape>
{}}
new Rectangle(),
new Triangle(),
new Circle(),
};
// Use the foreach loop to iterate over the derived classes in the list and call the Draw method on each Shape object
foreach (var shape in shapes)
{}}
shape.Draw();
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :
Draw a rectangle Execute the base class drawing task Draw a triangle Execute the base class drawing task Draw a circle Execute the base class drawing task Press any key to exit.
The following program demonstrates how to calculate the area of different shapes by using the virtual method 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("Surface of parent class : ");
return 0;
}
}
class Rectangle: Shape
{}}
public Rectangle(int a = 0, int b = 0): base(a, b)
{}}
}
public override int area()
{}}
Console.WriteLine("Surface of Rectangle class : ");
return (width * height);
}
}
class Triangle: Shape
{}}
public Triangle(int a = 0, int b = 0): base(a, b)
{}}
}
public override int area()
{}}
Console.WriteLine("Surface of Triangle class : ");
return (width * height / 2);
}
}
class Caller
{}}
public void CallArea(Shape sh)
{}}
int a;
a = sh.area();
Console.WriteLine("Surface : {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();
}
}
}Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :
Surface de la classe Rectangle : Surface :70 Surface de la classe Triangle : Surface :25