Une classe abstraite peut être considérée comme un modèle pour d'autres Des classes . Il vous permet de créer un ensemble de méthodes qui doivent être créées dans toutes les classes enfants créées à partir de la classe abstraite.

Une classe qui contient une ou plusieurs méthodes abstraites est appelée une classe abstraite . Un méthode abstraite est une méthode qui a une déclaration mais n'a pas d'implémentation.

Nous utilisons une classe abstraite lorsque nous concevons de grandes unités fonctionnelles ou lorsque nous souhaitons fournir une interface commune pour différentes implémentations d'un composant.

Classes de base abstraites en Python

En définissant une classe de base abstraite, vous pouvez définir une classe commune Interface de programme d'application (API) pour un ensemble de sous-classes. Cette fonctionnalité est particulièrement utile dans les situations où un tiers va fournir des implémentations, comme avec des plugins, mais peut également vous aider lorsque vous travaillez dans une grande équipe ou avec une grande base de code où il est difficile ou non de garder toutes les classes à l'esprit. possible.

tableau en java

Travailler sur des classes abstraites Python

Par défaut, Python ne fournit pas cours abstraits . Python est livré avec un module qui fournit la base pour définir A classes de base abstraites (ABC) et ce nom de module est abc .

abc fonctionne en décorant les méthodes de la classe de base en tant que résumé, puis en enregistrant des classes concrètes en tant qu'implémentations de la base abstraite. Une méthode devient abstraite lorsqu’elle est décorée du mot-clé @abstractmethod.

Exemple 1:

Ce code définit une classe de base abstraite appelée Polygone en utilisant le module ABC (Abstract Base Class) en Python. La classe Polygon possède une méthode abstraite appelée noofsides qui doit être implémenté par ses sous-classes.

scanner en java

Il existe quatre sous-classes de polygones définies : Triangle, Pentagone, Hexagone et Quadrilatère. Chacune de ces sous-classes remplace la méthode noofsides et fournit sa propre implémentation en imprimant le nombre de côtés dont elle dispose.

Dans le code du pilote, des instances de chaque sous-classe sont créées et la méthode noofsides est appelée sur chaque instance pour afficher le nombre de côtés spécifiques à cette forme.

# Python program showing # abstract base class work from abc import ABC, abstractmethod class Polygon(ABC): @abstractmethod def noofsides(self): pass class Triangle(Polygon): # overriding abstract method def noofsides(self): print('I have 3 sides') class Pentagon(Polygon): # overriding abstract method def noofsides(self): print('I have 5 sides') class Hexagon(Polygon): # overriding abstract method def noofsides(self): print('I have 6 sides') class Quadrilateral(Polygon): # overriding abstract method def noofsides(self): print('I have 4 sides') # Driver code R = Triangle() R.noofsides() K = Quadrilateral() K.noofsides() R = Pentagon() R.noofsides() K = Hexagon() K.noofsides()>

I have 3 sides I have 4 sides I have 5 sides I have 6 sides>

Exemple 2 :

Ici, ce code définit une classe de base abstraite appelée Animal à l'aide du module ABC (Abstract Base Class) en Python. La classe Animal possède une méthode non abstraite appelée move qui n’a aucune implémentation. Il existe quatre sous-classes d'animaux définies : l'humain, le serpent, le chien et le lion. Chacune de ces sous-classes remplace la méthode move et fournit sa propre implémentation en imprimant une caractéristique de mouvement spécifique.

exemple de sous-chaîne Java

# Python program showing # abstract base class work from abc import ABC, abstractmethod class Animal(ABC): def move(self): pass class Human(Animal): def move(self): print('I can walk and run') class Snake(Animal): def move(self): print('I can crawl') class Dog(Animal): def move(self): print('I can bark') class Lion(Animal): def move(self): print('I can roar') # Driver code R = Human() R.move() K = Snake() K.move() R = Dog() R.move() K = Lion() K.move()>

I can walk and run I can crawl I can bark I can roar>

Implémentation du résumé via la sous-classe

En sous-classant directement à partir de la base, nous pouvons éviter d'avoir à enregistrer explicitement la classe. Dans ce cas, la gestion des classes Python est utilisée pour reconnaître Implémentation du plugin comme la mise en œuvre du résumé PluginBase .

# Python program showing # implementation of abstract # class through subclassing import abc class parent: def geeks(self): pass class child(parent): def geeks(self): print('child class') # Driver code print( issubclass(child, parent)) print( isinstance(child(), parent))>

True True>

Un effet secondaire de l'utilisation du sous-classement direct est qu'il est possible de trouver toutes les implémentations de votre plugin en demandant à la classe de base la liste des classes connues qui en dérivent.

Méthodes concrètes dans les classes de base abstraites

Les classes concrètes contiennent uniquement des méthodes concrètes (normales) tandis que les classes abstraites peuvent contenir à la fois des méthodes concrètes et des méthodes abstraites.

La classe concrète fournit une implémentation de méthodes abstraites, la classe de base abstraite peut également fournir une implémentation en appelant les méthodes via super(). Regardons l'exemple pour appeler la méthode en utilisant super() :

# Python program invoking a  # method using super() from abc import ABC class R(ABC): def rk(self): print('Abstract Base Class') class K(R): def rk(self): super().rk() print('subclass ') # Driver code r = K() r.rk()>

Abstract Base Class subclass>

Dans le programme ci-dessus, nous pouvons invoquer les méthodes des classes abstraites en utilisant super().

Propriétés abstraites en Python

Les classes abstraites incluent des attributs en plus des méthodes, vous pouvez exiger les attributs dans des classes concrètes en les définissant avec @abstractproperty.

Madhubala

# Python program showing # abstract properties import abc from abc import ABC, abstractmethod class parent(ABC): @abc.abstractproperty def geeks(self): return 'parent class' class child(parent): @property def geeks(self): return 'child class' try: r = parent() print(r.geeks) except Exception as err: print(err) r = child() print(r.geeks)>

Can't instantiate abstract class parent with abstract methods geeks child class>

Dans l'exemple ci-dessus, la classe Base ne peut pas être instanciée car elle ne possède qu'une version abstraite de la méthode property-getter.

Instanciation de classe abstraite

Les classes abstraites sont incomplètes car elles ont des méthodes qui n'ont personne. Si Python permet de créer un objet pour les classes abstraites, utilisez cet objet si quelqu'un appelle la méthode abstraite, mais il n'y a pas d'implémentation réelle à invoquer.

Ainsi, nous utilisons une classe abstraite comme modèle et selon les besoins, nous l'étendons et construisons dessus avant de pouvoir l'utiliser. De ce fait, une classe abstraite n’est pas une classe concrète, elle ne peut pas être instanciée. Lorsque nous créons un objet pour la classe abstraite, il génère une erreur .

# Python program showing # abstract class cannot # be an instantiation from abc import ABC,abstractmethod class Animal(ABC): @abstractmethod def move(self): pass class Human(Animal): def move(self): print('I can walk and run') class Snake(Animal): def move(self): print('I can crawl') class Dog(Animal): def move(self): print('I can bark') class Lion(Animal): def move(self): print('I can roar') c=Animal()>

Sortir:

Traceback (most recent call last): File '/home/ffe4267d930f204512b7f501bb1bc489.py', line 19, in c=Animal() TypeError: Can't instantiate abstract class Animal with abstract methods move>