L'intérêt principal de définir une classe comme abstraite va être justement de fournir un cadre plus strict lorsqu'ils vont utiliser notre code en les forçant à définir certaines méthodes et etc. En effet, une classe abstraite ne peut pas être instanciée directement et contient généralement des méthodes abstraites.
La classe abstraite peut avoir un modificateur d'accès. Il est préférable d'utiliser l'interface lorsque plusieurs implémentations partagent uniquement la signature de méthode. Il doit être utilisé lorsque différentes implémentations du même type partagent un comportement commun.
Une sous-classe d'une classe abstraite sera encore abstraite si elle ne définit pas toutes les méthodes abstraites dont elle hérite. Les classes abstraites sont très utiles pour définir des méthodes dépendant d'autres méthodes qui ne sont pas précisées.
La première particularité d'une classe abstraite, c'est qu'elle ne peut être instanciée (et donc créer un objet). De cette affirmation, on en déduit logiquement qu'une classe abstraite est déclarée afin d'être dérivée par des classes concrètes. Une classe abstraite se comporte comme une classe concrète typique.
Une classe abstraite peut contenir ou non des méthodes abstraites. Une classe concrète ne peut pas contenir de méthode abstraite. Une classe abstraite ne peut pas être déclarée finale. Une classe concrète peut être déclarée finale.
Le mot-clé abstract en Java est utilisé pour créer ou déclarer une classe abstraite. En Java, le mot-clé interface est utilisé pour créer ou déclarer une nouvelle interface. Une classe peut hériter des propriétés et méthodes d'une classe abstraite en utilisant le mot-clé extends .
Notons qu'une classe abstraite peut avoir des constructeurs, mais qu'ils ne peuvent pas être invoqués pour créer des objets et qu'une classe abstraite peut avoir des méthodes non abstraites.
une classe est abstraite si elle contient au moins une méthode abstraite ; elle ne peut pas être instanciée, mais ses sous-classes non abstraites le peuvent. une classe abstarite est déclarée avec le modificateur abstract. une classe est abstraite ne peut être instanciée.
Définition du polymorphisme
Le nom de polymorphisme vient du grec et signifie qui peut prendre plusieurs formes. Cette caractéristique est un des concepts essentiels de la programmation orientée objet. Alors que l'héritage concerne les classes (et leur hiérarchie), le polymorphisme est relatif aux méthodes des objets.
Une classe abstraite est une classe qui ne peut pas être instanciée. Une classe abstraite peut contenir des méthodes déjà implémentées. Une classe abstraite peut contenir des méthodes non implémentées. Une classe abstraite est héritable.
Le polymorphisme est un mécanisme important dans la programmation objet. Il permet de modifier le comportement d'une classe fille par rapport à sa classe mère. Le polymorphisme permet d'utiliser l'héritage comme un mécanisme d'extension en adaptant le comportement des objets.
Les interfaces servent à créer des comportements génériques: si plusieurs classes doivent obéir à un comportement particulier, on créé une interface décrivant ce comportement, on est la fait implémenter par les classes qui en ont besoin.
Créer une interface peut-être utile si ces dernières ne devraient pas être accessibles. Lorsque du code interagit avec le système de fichier, du réseau ou n'importe quel système tiers, la mise en place d'une interface est essentielle pour se découpler de l'implémentation et faciliter l'écriture de tests.
La syntaxe de déclaration d'une classe est la suivante : modificateurs class nom_de_classe [extends classe_mere] [implements interfaces] { ... } la classe contient une ou des méthodes abstraites, qui n'ont pas de définition explicite.
On les utilise : lorsqu'on a besoin de l'héritage (réutilisation du code ; méthodes concrètes dans la classe de base qui fonctionnent de la même manière quelque soit les classes dérivées). mais que certaines méthodes n'ont pas de sense à être définie.
Une classe abstraite peut être considérée comme un modèle pour d'autres classes. Il vous permet de créer un ensemble de méthodes qui doivent être créées dans toutes les classes enfants construites à partir de la classe abstraite.
L'encapsulation permet de définir des niveaux de visibilité des éléments de la classe. Ces niveaux de visibilité définissent les droits d'accès aux données selon que l'on y accède par une méthode de la classe elle-même, d'une classe héritière, ou bien d'une classe quelconque.
L'abstraction est l'un des concepts clés dans les langages de programmation orientée objet (POO). Son objectif principal est de gérer la complexité en masquant les détails inutiles à l'utilisateur.
En Programmation Orientée Object (POO), la généricité est un concept permettant de définir des algorithmes (types de données et méthodes) identiques qui peuvent être utilisés sur de multiples types de données. Cela permet donc de réduire les quantités de codes à produire.
En Java, il n'est pas possible de combiner abstract et final dans la déclaration d'une classe car cela n'aurait aucun sens. Une classe abstraite ne pouvant être instanciée, il faut nécessairement qu'il existe une ou des classes filles.
Les classes statiques sont scellées (sealed) et ne peuvent par conséquent pas être héritées. Elles ne peuvent hériter d'aucune classe à part Object. Les classes statiques ne peuvent pas contenir de constructeur d'instance. Toutefois, ils peuvent contenir un constructeur statique.
En programmation orientée objet, le concept d'interface permet de définir des abstractions sans avoir besoin d'écrire de classes. Une interface contient une description de ce qui sera implémenté par une classe (on parle parfois de contrat).
Formellement une classe abstraite n'est pas différente d'une classe normale. Simplement, elle est déclarée en ajoutant le mot-clé abstract , comme dans l'exemple suivant. On peut déclarer autant de méthodes abstraites que l'on veut dans une classe abstraite, y compris ne pas en déclarer du tout.
La raison derrière cela est d'éviter toute ambiguïté. Considérons un cas où la classe A hérite la classe B et la classe C. Les classes B et C ont la même méthode show(). Maintenant, le compilateur Java ne peut pas décider quelle méthode show() il doit hériter.
Le mot-clé static permet de définir une méthode statique d'une classe.