C # Classe abstraite

Une classe abstraite traite du processus d'abstraction. C'est un phénomène dans lequel les détails de toute méthode sont cachés, et seule la fonctionnalité est affichée. Ce n'est pas une implémentation complète. Nous ne pouvons pas instancier directement une classe abstraite; il peut être créé sans utiliser de méthode abstraite. Le but élémentaire d'une classe abstrait est d'offrir un guide pour toutes les classes dérivées héritées par elle.

La syntaxe pour la classe abstraite:

Échantillon de classe abstrait

Un mot-clé «abstrait» est utilisé pour générer une classe abstraite. Alors que dans le cas d'une fonction abstraite, il ne contient personne seulement déclaré à l'intérieur de la classe. Une méthode abstraite est utilisée à l'intérieur du dérivé, ou vous pouvez dire dans toutes les classes non abstraites en utilisant un mot-clé «remplacer». En utilisant ce mot-clé, une méthode abstraite n'est pas dans l'état d'abstraction; il peut être utilisé comme fonction régulière. Une classe dérivée qui est l'enfant de la classe abstraite peut remplacer les mêmes méthodes abstraites.

La syntaxe pour une méthode abstraite:

Résumé public void SMP ();

Structure d'une classe abstraite

Une classe abstraite est utilisée principalement dans le processus d'héritage. Les structures ne peuvent pas remplacer aucune classe abstraite. Une classe abstraite n'est pas en faveur de multiples héritages. De même, une classe abstraite ne peut pas être déclarée comme une classe statique, car une classe statique ne peut pas être dérivée.

Exemple 1

Pour mettre en œuvre le concept d'une classe abstraite, nous avons créé un échantillon de programme. Dans lequel nous avons utilisé un échantillon de classe avec le résumé des mots clés. À l'intérieur de la classe, une méthode abstraite est indiquée. La classe abstraite a toujours une méthode abstraite.

Échantillon de classe abstrait public ()
Abstract public void SMP] ();

Comme nous ne définissons que la fonctionnalité des méthodes abstraites à l'intérieur de la classe abstraite, au lieu d'expliquer le fonctionnement des fonctions, donc seul l'en-tête de la fonction est déclaré ici.

Une classe abstraite ne peut pas être accessible directement car nous n'en créons pas un objet; il est dit qu'il s'agit d'une classe factice ou d'une classe non active jusqu'à ce qu'elle devienne active en créant un objet de la classe en dérivé. Nous allons donc conduire l'échantillon de classe 1 à partir de l'échantillon de classe abstrait de base. Cette classe n'est pas abstraite. La classe d'échantillons est héritée dans l'échantillon de classe d'enfants1. La façon de représenter une classe inhérente de la classe de base est d'utiliser le nom de la classe parent avec un signe de côlon devant la classe dérivée. Ici échantillon1 est une classe dérivée.

# Public Class Sample1: Exemple

Lorsque nous héritons d'une classe de la classe abstraite, il peut utiliser les fonctionnalités et les méthodes présentes à l'intérieur de la classe abstraite. Par exemple, la méthode SMP () peut être déclarée dans la classe Sample1, mais pas avec le nom de Résumé car ce n'est plus une classe abstraite. Il est écrit avec le mot-clé «remplacer» pour représenter qu'il est hérité d'une classe abstraite. Une déclaration simple est affichée à l'intérieur du programme.

# Public Override void SMP ()

De même, un autre échantillon de classe2 est hérité de l'échantillon de classe. Et il utilise également la méthode de remplacement SMP (). Pour initialiser la classe abstraite, nous ne créerons pas d'objet pour cela. Mais l'instance de la classe dérivée ou de la classe d'enfants sera instanciée. La classe abstraite deviendra automatiquement active et peut être accessible facilement en créant l'objet.

# Échantillon s;

«S» est l'objet de la classe d'échantillons; il est créé, mais il n'est pas instancié.

# S = nouveau sampon1 ()

Cette création dynamique instanciera l'échantillon de classe1 en utilisant un «nouvel» opérateur. Nous allons maintenant accéder à la fonction déclarée à l'intérieur de la classe abstraite via cet objet.

De même, le même objet pour la classe Sample2 sera créé. Et puis, nous appellerons la fonction de la classe parentale. Lorsque nous instancions l'objet pour la classe, nous l'utiliserons pour l'appel de fonction à l'étape suivante, ce qui le rend immédiatement spécifié pour la fonction utilisée à l'intérieur de la classe.

Enregistrer le code; Nous allons l'exécuter dans le terminal Ubuntu, utiliser le compilateur MCS pour compiler le code et mono pour l'exécuter.

Fichier $ MCS.CS
$ mono fichier.exe

En exécution, vous pouvez voir que les deux valeurs à l'intérieur des fonctions sont affichées.

Exemple 2

En utilisant une classe abstraite, nous allons maintenant calculer la zone. Ainsi, une classe abstraite pour la zone est créée, dans laquelle une méthode abstraite pour la zone sera définie.

Classe abstraite AreaClass
Résumé du public public Int ();

Un carré de classe dérivé sera hérité de la classe de base. Cela calculera la zone en utilisant la méthode abstraite à l'intérieur. Premièrement, une variable est déclarée obtenir le numéro du programme principal.

# Class Square: AreaClass

Un constructeur est créé pour attribuer la valeur envoyée du programme principal. Alors la fonction sera remplacée par la classe abstraite. Cette méthode calculera la zone du carré en multipliant les deux côtés.

Créer une autre classe pour déclarer le programme principal. Ici, l'objet de la classe enfant est créé et sera instancié car nous devons envoyer le numéro au constructeur de la classe carrée pour créer l'objet.

# Carré s = nouveau carré (15);

En utilisant le même objet, la fonction sera appelée.

s.Zone ();

La console imprimera la zone calculée par la fonction.

Exemple 3

La classe abstraite n'a pas besoin de contenir toutes les méthodes abstraites. Mais aussi, les méthodes non abstraites peuvent être énoncées dans une classe abstraite. Nous avons utilisé l'exemple ci-dessous pour développer ce concept. Créer une classe abstraite. Une fonction simple est créée et est dans un état entièrement fonctionné, car il accepte les paramètres qui lui sont envoyés à partir de l'appel de fonction et renvoie la somme des deux nombres.

# Public int sum (int num1, int num2)

Après la déclaration de la fonction régulière, une méthode abstraite est définie, mais son corps n'est pas déclaré ici car il s'agit d'une fonction abstraite.

# Public abstract int multiply (int num1, int num2)

Après la classe abstraite, nous créerons une classe dérivée qui héritera de la fonction abstraite de la multiplication.

Classe dérivée: abstractClass
Public Override int multiply (int num1, int num2)

Cette fonction multipliera les deux valeurs, puis renvoie la réponse.

Nous allons maintenant créer un programme principal pour créer l'objet.

Dérivé d = new dérivé ();
d.somme (20, 8);
d.multiplier (20, 8);

Conclusion

Une classe abstraite en C Sharp est créée pour masquer les informations en définissant uniquement l'en-tête de la fonction. Cette classe abstraite est non fonctionnelle jusqu'à ce qu'une autre classe d'enfants soit dérivée. Une classe abstraite est utilisée dans l'héritage; Sinon, la déclaration d'une classe abstraite est inutile. En raison de l'héritage, nous y accédons en créant et en instanciant l'objet pour la classe enfant. Il n'est pas obligatoire qu'une classe abstraite doit avoir toutes les méthodes abstraites. Nous avons expliqué le travail et la déclaration d'une classe abstraite en utilisant quelques exemples et en les mettant en œuvre dans Ubuntu.