Classe abstraite en Java et méthodes [avec exemples]
Publié: 2021-06-18L'article suivant discutera des propriétés de l'abstraction en Java et de la manière dont elle pourrait être réalisée via des classes abstraites et des méthodes abstraites. Nous explorerons les fonctionnalités des classes abstraites et des interfaces en Java.
Table des matières
Abstraction
L'un des concepts importants de Java est l'abstraction. C'est la propriété par laquelle l'utilisateur est affiché avec seulement les détails importants d'un programme. Toutes les parties non essentielles sont cachées. Le processus peut être expliqué à travers l'exemple d'un e-mail. Les expéditeurs envoient un e-mail qui est remis au destinataire. La seule information connue de l'expéditeur est que l'e-mail a été envoyé. Le processus d'arrière-plan d'envoi de l'e-mail est caché aux utilisateurs. Le processus est similaire dans la programmation orientée objet (POO) où les éléments essentiels sont affichés à l'utilisateur tandis que les parties non essentielles sont masquées. L'utilisateur n'a aucune information sur le processus de mise en œuvre, mais seule la fonctionnalité est connue. Ce mécanisme est connu sous le nom d'abstraction où seules les caractéristiques essentielles d'un objet sont affichées en ignorant les autres caractéristiques.
En Java, l'abstraction est réalisée via les classes abstraites et les interfaces.
Classe abstraite en Java
Le mot-clé "abstract" est utilisé pour les classes et méthodes abstraites en Java. La classe abstraite a le mot clé abstract dans sa déclaration.
La syntaxe d'une classe abstraite Java est :
classe abstraite nom_classe
{
abstract public void the_abstractMethod();
public void the_normalMethod()
{
#corps de la méthode
}
}
La syntaxe ci-dessus montre que les méthodes normales et abstraites peuvent être contenues dans une classe abstraite.
Quelques propriétés des classes abstraites sont :
- Les méthodes abstraites peuvent ou non être présentes dans la classe abstraite Java .
- La présence d'au moins une méthode abstraite dans une classe fait de la classe une classe abstraite.
- Une classe abstraite ne peut pas avoir d'objets et ne peut donc pas être directement instanciée.
- Une classe abstraite ne peut être utilisée que si elle est héritée d'une autre classe et implémente les méthodes abstraites.
- Des implémentations appropriées des méthodes abstraites sont requises lors de l'héritage d'une classe abstraite.
- Les méthodes régulières et abstraites peuvent être présentes dans une classe abstraite Java .
- Les constructeurs paramétrés peuvent être présents dans une classe abstraite. De plus, une classe abstraite contient toujours un constructeur par défaut.
Méthodes abstraites
Les méthodes abstraites sont les types de méthodes qui ne nécessitent pas d'implémentation pour leur déclaration. Ces méthodes n'ont pas de corps, ce qui signifie qu'elles ne sont pas implémentées. Quelques propriétés d'une méthode abstraite sont :
- Une méthode abstraite en Java est déclarée par le mot-clé "abstract".
- Lors de la déclaration de la méthode abstraite, le mot clé abstract doit être placé avant le nom de la méthode.
- Il n'y a pas de corps dans une méthode abstraite, seule la signature de la méthode est présente.
- Une méthode abstraite en Java n'a pas d'accolades, mais la fin de la méthode aura un point-virgule (;)
abstract double Method(double n1, double n2);
- Toute classe contenant une méthode abstraite doit être déclarée en tant que classe abstraite. Bien que l'inverse puisse ne pas être vrai, c'est-à-dire qu'il n'est pas nécessaire qu'une classe abstraite ait une méthode abstraite.
- L'héritage d'une classe abstraite par une classe régulière nécessite l'implémentation de toutes les méthodes abstraites dans la classe mère.
Exemple de méthode abstraite
voiture de classe abstraite publique
{
modèle de chaîne privé ;
couleur de chaîne privée ;
privé int année;
public abstract double computePrice();
}
Si les classes dérivées n'implémentent pas les méthodes abstraites, cela entraînerait des classes abstraites qui ne peuvent pas être instanciées.
Quelques-uns ne peuvent pas être utilisés avec le mot clé abstract en Java.
- final
- natif abstrait
- abstrait statique
- abstrait privé
- abstrait synchronisé
- résumé strictfp
Un code montrant l'utilisation d'une méthode abstraite en Java est présenté ci-dessous.
La source
La sortie du code est :
Interfaces Java
Outre les classes abstraites et les méthodes abstraites, Java utilise des interfaces pour réaliser l'abstraction. Lorsque des méthodes associées sont regroupées dans des corps vides, cela s'appelle une interface. L'interface est similaire à une classe abstraite car il s'agit du regroupement de méthodes abstraites. Lorsqu'une classe implémente l'interface, toutes les méthodes abstraites de l'interface sont héritées. L'interface peut également contenir des méthodes par défaut, des constantes et des méthodes statiques. Seuls les corps de méthode des méthodes par défaut et statiques sont présents. Un héritage et une classe peuvent être écrits de manière similaire, mais une classe peut décrire les attributs et le comportement d'un objet. Alors que dans le cas d'une interface, seuls ces comportements d'un objet sont présents, ceux-ci sont implémentés par la classe.
Une classe doit définir toutes les méthodes de l'interface qu'elle implémente. Uniquement pour une classe abstraite, les méthodes ne doivent pas nécessairement être définies par la classe.
Une interface est similaire à une classe abstraite Java de la manière suivante :
- N'importe quel nombre de méthodes peut être contenu dans une interface.
- L'extension .java est utilisée pour écrire une interface dans un fichier. Le nom du fichier doit correspondre au nom de l'interface.
- Le fichier .class contient le code d'octet d'une interface.
- Les interfaces apparaissent dans les packages. Le fichier bytecode d'une interface est présent dans un répertoire portant le même nom que le nom du package.
Une interface est différente d'une classe abstraite Java de la manière suivante :
- L'interface ne peut pas être instanciée.
- Il n'y a pas de constructeurs dans une interface.
- L'interface ne contient que des méthodes abstraites.
- Aucun champ d'instance n'est présent dans une interface. Un champ doit être déclaré à la fois statique et final s'il doit apparaître dans une interface.
- Seule une classe peut implémenter une interface, mais ne peut pas être étendue.
- Une interface peut étendre plusieurs interfaces.
Apprenez des cours de logiciels en ligne dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.
Propriétés d'une interface
- Il n'est pas nécessaire de déclarer une interface comme abstraite via le mot clé abstract car elle est implicitement abstraite.
- Les mots clés abstraits ne sont pas nécessaires pour déclarer les méthodes comme abstraites car elles sont implicitement abstraites.
- Toutes les méthodes d'une interface sont implicitement publiques.
Comment déclarer une interface ?
Le mot clé « interface » est utilisé pour déclarer une interface. L'abstraction totale est assurée par l'utilisation d'une interface. Par défaut, toutes les méthodes d'une interface sont abstraites et publiques. Cela signifie qu'il n'y a aucune méthode dans une interface et que tous les champs sont statiques, publics et finaux.
Syntaxe d'une interface :
Interface nom_de_l'interface {
# déclarer les champs
# déclarer des méthodes abstraites
}
Par exemple lecteur d'interface
{
âge int final = 40 ;
int calc();
}
Comment implémenter une interface ?
Pour implémenter une interface, le mot clé ' implémente' est utilisé. Plusieurs interfaces peuvent être implémentées par une classe. Dans de tels cas, le mot-clé ' implémente' est suivi d'une liste d'interfaces séparées par une virgule. Le mot clé est utilisé dans la déclaration de classe.
Un exemple d'implémentation de l'interface est illustré ci-dessous :
classe Maruti met en œuvre la voiture
Un exemple de code montrant l'implémentation d'une interface en Java est présenté ci-dessous.
La source
Le code génère la sortie suivante :
Un code appliquant l'implémentation de plusieurs interfaces est présenté ci-dessous.
La source
Le code génère la sortie suivante :
Du texte…
Un autre texte…
Pourquoi l'interface est-elle utilisée ?
- Les interfaces sont utilisées pour atteindre une abstraction totale.
- Plusieurs héritages en Java peuvent être obtenus grâce à l'utilisation de l'héritage car Java ne prend pas en charge les héritages multiples.
- Un couplage lâche peut être obtenu grâce à l'utilisation d'une interface.
- Grâce à l'utilisation de l'abstraction de mise en œuvre en Java peut être réalisé.
Bien que l'abstraction en Java puisse être réalisée via la classe abstraite Java, les interfaces sont utilisées car elles contiennent des variables finales, publiques et statiques. Cependant, des variables non finales peuvent être présentes dans une classe abstraite.
Si l'interface Java et la classe abstraite Java sont utilisées pour réaliser l'abstraction, quand faut-il utiliser une interface et une classe abstraite ?
- Une classe abstraite est utilisée lorsque l'utilisateur a besoin de définir un modèle pour un groupe de sous-classes.
- Une interface est utilisée lorsqu'un utilisateur a besoin de définir un rôle pour d'autres classes.
Voici quelques avantages de l'abstraction :
- La complexité du programme est réduite.
- Il y a moins de chances de duplication de code augmentant la réutilisabilité.
- La sécurité d'un programme est augmentée grâce à l'utilisation de l'abstraction car seuls quelques détails sont fournis à l'utilisateur.
Conclusion
L'article discutait du concept détaillé d' abstraction en Java, qui est une technique permettant de cacher des informations non essentielles à l'utilisateur. En Java, l'abstraction est réalisée via des classes abstraites et des interfaces. Une abstraction à 100% est fournie par les interfaces tandis qu'une abstraction partielle est fournie par les classes abstraites. L'article mentionnait en outre quand utiliser une interface et quand une classe abstraite devait être utilisée. Il a également répertorié les similitudes d'une interface avec celle de la classe abstraite Java ainsi que les différences. Sans la connaissance requise des deux concepts, il en résultera un code plein de défauts.
Si vous souhaitez en savoir plus et mettre en œuvre les concepts dans des problèmes réels, vous pouvez consulter le cours de maîtrise en informatique proposé par upGrad et IIIT-Bangalore reconnu par l'Université John Moores de Liverpool . Le cours est conçu pour les professionnels débutants (21 à 45 ans) offrant plus de 500 heures de formation dispensées par des experts de l'industrie et des facultés de génie logiciel. De plus amples détails sur le cours peuvent être consultés sur la page Web officielle d'upGrad.
