Interface C#
Interface C#
Dans ce tutoriel, nous allons découvrir l'interface C# à l'aide d'exemples.
En C#, une interface est similaire à une classe abstraite. Cependant, contrairement aux classes abstraites, toutes les méthodes d'une interface sont entièrement abstraites (méthode sans corps).
Nous utilisons le interface mot-clé pour créer une interface. Par exemple,
interface IPolygon {
// method without body
void calculateArea();
} Ici,
- IPolygon est le nom de l'interface.
- Par convention, l'interface commence par I afin que nous puissions l'identifier simplement en voyant son nom.
- Nous ne pouvons pas utiliser de modificateurs d'accès dans une interface.
- Tous les membres d'une interface sont publics par défaut.
- Une interface n'autorise pas les champs.
Implémentation d'une interface
On ne peut pas créer les objets d'une interface. Pour utiliser une interface, d'autres classes doivent l'implémenter. Identique à l'héritage C#, nous utilisons : symbole pour implémenter une interface. Par exemple,
using System;
namespace CsharpInterface {
interface IPolygon {
// method without body
void calculateArea(int l, int b);
}
class Rectangle : IPolygon {
// implementation of methods inside interface
public void calculateArea(int l, int b) {
int area = l * b;
Console.WriteLine("Area of Rectangle: " + area);
}
}
class Program {
static void Main (string [] args) {
Rectangle r1 = new Rectangle();
r1.calculateArea(100, 200);
}
}
} Sortie
Area of Rectangle: 20000
Dans l'exemple ci-dessus, nous avons créé une interface nommée IPolygon . L'interface contient une méthode calculateArea(int a, int b) sans implémentation.
Ici, le Rectangle la classe implémente IPolygon . Et, fournit l'implémentation du calculateArea(int a, int b) méthode.
Remarque :Nous devons fournir l'implémentation de toutes les méthodes d'interface à l'intérieur de la classe qui l'implémente.
Implémentation de plusieurs interfaces
Contrairement à l'héritage, une classe peut implémenter plusieurs interfaces. Par exemple,
using System;
namespace CsharpInterface {
interface IPolygon {
// method without body
void calculateArea(int a, int b);
}
interface IColor {
void getColor();
}
// implements two interface
class Rectangle : IPolygon, IColor {
// implementation of IPolygon interface
public void calculateArea(int a, int b) {
int area = a * b;
Console.WriteLine("Area of Rectangle: " + area);
}
// implementation of IColor interface
public void getColor() {
Console.WriteLine("Red Rectangle");
}
}
class Program {
static void Main (string [] args) {
Rectangle r1 = new Rectangle();
r1.calculateArea(100, 200);
r1.getColor();
}
}
} Sortie
Area of Rectangle: 20000 Red Rectangle
Dans l'exemple ci-dessus, nous avons deux interfaces, IPolygon et ICouleur .
class Rectangle : IPolygon, IColor {
…
}
Nous avons implémenté les deux interfaces dans le Rectangle classe séparée par , .
Maintenant, Rectangle doit implémenter la méthode des deux interfaces.
Utiliser la variable de référence d'une interface
On peut utiliser la variable de référence d'une interface. Par exemple,
using System;
namespace CsharpInterface {
interface IPolygon {
// method without body
void calculateArea(int l, int b);
}
class Rectangle : IPolygon {
// implementation of methods inside interface
public void calculateArea(int l, int b) {
int area = l * b;
Console.WriteLine("Area of Rectangle: " + area);
}
}
class Program {
static void Main (string [] args) {
// using reference variable of interface
IPolygon r1 = new Rectangle();
r1.calculateArea(100, 200);
}
}
}
Sortie
Area of Rectangle: 20000
Dans l'exemple ci-dessus, nous avons créé une interface nommée IPolygon . L'interface contient une méthode calculateArea(int l, int b) sans implémentation.
IPolygon r1 = new Rectangle(); Remarquez, nous avons utilisé la variable de référence de l'interface IPolygon . Il pointe vers la classe Rectangle qui l'implémente.
Bien que nous ne puissions pas créer d'objets d'une interface, nous pouvons toujours utiliser la variable de référence de l'interface qui pointe vers sa classe implémentée.
Exemple pratique d'interface
Voyons un exemple plus pratique d'interface C#.
using System;
namespace CsharpInterface {
interface IPolygon {
// method without body
void calculateArea();
}
// implements interface
class Rectangle : IPolygon {
// implementation of IPolygon interface
public void calculateArea() {
int l = 30;
int b = 90;
int area = l * b;
Console.WriteLine("Area of Rectangle: " + area);
}
}
class Square : IPolygon {
// implementation of IPolygon interface
public void calculateArea() {
int l = 30;
int area = l * l;
Console.WriteLine("Area of Square: " + area);
}
}
class Program {
static void Main (string [] args) {
Rectangle r1 = new Rectangle();
r1.calculateArea();
Square s1 = new Square();
s1.calculateArea();
}
}
} Sortie
Area of Rectangle: 2700 Area of Square: 900
Dans le programme ci-dessus, nous avons créé une interface nommée IPolygon . Il a une méthode abstraite calculateArea() .
Nous avons deux classes Carré et Rectangle qui implémentent IPolygon interface.
La règle de calcul de la surface est différente pour chaque polygone. Par conséquent, calculateArea() est inclus sans implémentation.
Toute classe qui implémente IPolygon doit fournir une implémentation de calculateArea() . Par conséquent, implémentation de la méthode dans la classe Rectangle est indépendant de la méthode dans la classe Square .
Avantages de l'interface C#
Maintenant que nous savons ce que sont les interfaces, découvrons pourquoi les interfaces sont utilisées en C#.
- Semblables aux classes abstraites, les interfaces nous aident à réaliser l'abstraction en C# .
Ici, la méthodecalculateArea()à l'intérieur de l'interface, n'a pas de corps. Ainsi, il masque les détails d'implémentation de la méthode.
- Les interfaces fournissent des spécifications qu'une classe (qui l'implémente) doit suivre.
Dans notre exemple précédent, nous avons utilisécalculateArea()comme spécification à l'intérieur de l'interface IPolygon . C'est comme établir une règle selon laquelle nous devrions calculer la surface de chaque polygone.
Désormais, toute classe qui implémente IPolygon l'interface doit fournir une implémentation pour calculateArea() méthode.
- Les interfaces sont utilisées pour réaliser l'héritage multiple en C#.
- Les interfaces fournissent un couplage lâche (n'ayant aucun ou moins d'effet sur les autres parties du code lorsque nous modifions une partie d'un code).
Dans notre exemple précédent, si nous modifions l'implémentation decalculateArea()dans le Carré classe, il n'affecte pas le Rectangle classe.
Langue C