Qu'est-ce que la classe abstraite en C #?
Le mot abstrait signifie une pensée ou une idée qui n'a pas de forme physique propre mais qui sert de base à d'autres choses. Le même concept se trouve derrière la classe abstraite. Dans cet article, nous discuterons des classes abstraites en C #. Une classe abstraite est une classe spéciale en C # qui ne peut pas être instanciée, c'est-à-dire que vous ne pouvez pas créer d'objets d'une classe abstraite. Le but d'une classe abstraite est de fournir une structure squelettique à partir de laquelle d'autres classes peuvent dériver. Les classes abstraites n'ont pas leur propre implémentation. Ils demandent aux développeurs et aux programmeurs de dériver de la classe abstraite et de s'appuyer sur la structure squelettique, c'est-à-dire d'écrire leur implémentation. Une classe abstraite peut également contenir des déclarations de méthode abstraite. Encore une fois, ces méthodes ne peuvent pas avoir de définitions.
La syntaxe de déclaration des classes et méthodes abstraites implique de placer le mot-clé abstract avant la déclaration. Aussi simple que cela.
Syntaxe:
abstract class ClassName
(
public abstract void MethodName();
)
N'oubliez pas que les méthodes abstraites ne peuvent pas avoir de définitions. Ainsi, les déclarations de la méthode abstraite se terminent par un point-virgule. Ils ne peuvent être déclarés. Les définitions doivent être fournies dans des classes dérivées non abstraites.
Comment fonctionne la classe abstraite en C #?
Le mot clé abstrait indique au compilateur que la classe est une structure squelettique de classe de base à implémenter dans des classes dérivées. Si le compilateur trouve une classe dérivant la classe de base abstraite, il vérifie si toutes les méthodes et propriétés abstraites sont remplacées et implémentées dans la classe dérivée.
Classe abstraite vs interface
Maintenant, vous vous demandez peut-être ce que sont tout cela et quelle interface fait. Alors, en quoi une classe abstraite est-elle différente d'une interface?
Comprenons cela avec un exemple. Disons que nous dirigeons une société d'édition et avons embauché quelques éditeurs pour rédiger des colonnes pour notre magazine. Supposons qu'ils soient des experts dans différents genres, écrivons des articles à publier un jour spécifique de la semaine et qu'ils soient tous embauchés au même salaire.
Définissons la classe abstraite Employee pour nos éditeurs.
Code:
abstract class EmployeeEditors
(
public abstract void Genre();
public abstract string PublishDay();
public int Payment()
(
Console.Write(“Monthly salary is (0)$.”, 1000);
)
)
Nous pourrions facilement mettre en œuvre le mode de paiement sachant qu'il serait le même pour tous. Les deux autres méthodes ont été déclarées abstraites pour être implémentées par la classe dérivée. On pourrait déclarer une classe normale pour chaque éditeur dérivant de la classe abstraite et ensuite implémenter les méthodes abstraites pour définir les genres et les jours. Supposons maintenant que le salaire de chaque éditeur soit également différent. Une façon de modifier notre code consiste à déclarer le mode de paiement comme abstrait. L'autre façon serait de déclarer l'intégralité de EmployeeEditor en tant qu'interface et de donner toute liberté aux classes héritées.
Public interface EmployeeEditors
(
public abstract void Genre();
public abstract string PublishDay();
public abstract int Payment();
)
Ainsi, une classe abstraite est une classe de base sur laquelle d'autres classes peuvent s'appuyer. Tandis que, une interface est un modèle pour les autres classes auxquelles se référer et construire à partir de zéro.
Règles de classe abstraite en C #
Il y a certaines règles à suivre lorsque vous travaillez avec des classes abstraites.
- Étant donné que les classes abstraites ont des définitions de méthode incomplètes, elles ne peuvent donc pas être instanciées. Toute tentative de création d'un objet d'une classe abstraite entraînerait une erreur de compilation.
- Les méthodes abstraites ne peuvent pas être définies dans des classes abstraites, mais seulement déclarées. Le corps de la méthode doit être défini dans des classes dérivées.
- Les classes dérivées doivent implémenter toutes les méthodes abstraites.
- Les méthodes abstraites ne peuvent pas être statiques ou virtuelles.
Exemple de classe abstraite en C #
Énoncé du problème: Prenons un autre exemple du monde réel. Supposons que l'on vous demande d'automatiser le processus de génération de lettres d'offre pour une certaine organisation. Le processus actuel est entièrement manuel et nécessite la modification des lettres d'offre existantes, ce qui est sujet à erreur. Il y a certaines choses qui seraient communes à toutes les lettres d'offre, comme le lieu de travail, les horaires de travail, le titre de l'entreprise, l'image de marque de l'entreprise, etc. D'autres choses telles que le nom de l'employé, le poste, le salaire, la date d'adhésion, etc. lettre.
Solution : vous concevriez une classe abstraite dans le but ci-dessus. Voyons comment.
Code:
ode: using System;
abstract class OfferLetter
(
public abstract string Name(string name);
public abstract string Designation(string designation);
public abstract int Payment(int pay);
public abstract string DOJ(string doj);
public string CompanyName()
(
return "XYZ Corporation Pvt. Ltd.";
)
public string OfficeAddress()
(
return "512, Manhattan, NY";
)
public string CompanyBranding()
(
return this.CompanyName() + " is a privately owned regsitered corporation operating \n under the license provided by the state of New York.";
)
public string Disclaimer()
(
return "This letter and its contents are confidential in nature and are intended only \n for the recipient."+
"\nIf you are not the correct recipient, kindly return it immediately \n to " + this.CompanyName() + " " + this.OfficeAddress() + ".";
)
)
class PrintOfferLetter : OfferLetter
(
public override string Name(string name)
(
return name;
)
public override string Designation(string designation)
(
return designation;
)
public override int Payment(int pay)
(
return pay;
)
public override string DOJ(string doj)
(
return doj;
)
)
public class Program
(
public static void Main()
(
PrintOfferLetter ltr = new PrintOfferLetter();
string empName = "Mr. ABC", designation = "Senior Consultant", doj = "20-02-2020";
int pay = 50000;
Console.WriteLine(ltr.CompanyName() + " is very happy to extend this offer letter to \n" + ltr.Name(empName)
+ " at the designation of " + ltr.Designation(designation) + " with an annual pay of " + ltr.Payment(pay) + "$.");
Console.WriteLine("\nYou are required to report at " + ltr.OfficeAddress() + " from " + ltr.DOJ(doj) + " (dd-mm-yyyy).");
Console.WriteLine("\n\n" + ltr.CompanyBranding());
Console.WriteLine("\n\n" + ltr.Disclaimer());
)
)
Production:
Conclusion
En résumé, une classe abstraite est simplement une classe incomplète ou partiellement complète que d'autres classes peuvent dériver et construire leur logique par-dessus. Dans cet article, nous avons vu comment une classe abstraite est déclarée et fonctionne. Nous avons vu des exemples concrets d'utilisation des classes abstraites et comment elles sont différentes des interfaces. Il est recommandé d'essayer d'utiliser autant que possible des classes abstraites dans votre code. Il s'agit d'une pratique cruciale d'une bonne programmation.
Articles recommandés
Ceci est un guide de classe abstraite en C #. Nous discutons ici de la définition et du fonctionnement de la classe abstraite en C # avec des règles et un exemple. Vous pouvez également consulter nos autres articles connexes pour en savoir plus -
- Que sont les classes abstraites en JavaScript?
- Classe abstraite en C ++? (Exemples)
- Qu'est-ce que la classe abstraite en PHP?
- Présentation de la classe abstraite en Python