what is abstraction java learn with examples
Ce tutoriel explique ce qu'est l'abstraction en Java avec des exemples de programmation. Vous apprendrez également ce qu'est une classe abstraite et pourquoi est-elle utilisée:
Dans cette série JAVA, nous discuterons des caractéristiques importantes de la programmation orientée objet (POO) qui sont également connues sous le nom de quatre piliers, à savoir l'abstraction, l'encapsulation, l'héritage et le polymorphisme.
Le premier pilier de la POO est «l'abstraction». 'L'abstraction est le processus de sélection des données pour n'afficher que les informations pertinentes à l'utilisateur.'
=> Jetez un œil au guide du débutant Java ici.
Ce que vous apprendrez:
- Abstraction en POO
- Qu'est-ce que l'abstraction en Java
- Différence entre l'abstraction et l'encapsulation
- Conclusion
Abstraction en POO
En termes simples, l'abstraction «affiche» uniquement les attributs pertinents des objets et «cache» les détails inutiles.
Par exemple, lorsque nous conduisons une voiture, nous ne nous préoccupons que de la conduite de la voiture comme démarrer / arrêter la voiture, accélérer / freiner, etc. Nous ne sommes pas préoccupés par le fonctionnement interne du mécanisme de démarrage / arrêt ou du processus d'accélération / de freinage. Nous ne sommes tout simplement pas intéressés par ces détails.
Ce qui nous préoccupe, c'est la vision «abstraite» de ces opérations qui nous aidera à faire avancer la voiture et à atteindre notre destination. Ceci est un exemple simple d'abstraction.
Ainsi, la voiture a tous les mécanismes et processus en place, mais du point de vue de l’utilisateur final, c’est-à-dire du point de vue du conducteur, il ne s’intéressera qu’à la vue abstraite de ces processus.
L'abstraction réduit les efforts de programmation et donc la complexité. Un utilisateur final utilisant l'application n'a pas besoin de se soucier de la manière dont une fonctionnalité particulière est mise en œuvre. Il / elle peut simplement utiliser les fonctionnalités au besoin.
Ainsi, dans l'abstraction, nous traitons des idées et non des événements. Cela signifie que nous masquons les détails de mise en œuvre à l'utilisateur et n'exposons que la fonctionnalité à l'utilisateur final. Ainsi, l'utilisateur ne saura que «ce qu'il fait» plutôt que «comment il fait».
L'abstraction en POO peut être de deux types.
# 1) Abstraction des données
Dans l'abstraction de données, nous créons principalement des types de données complexes et masquons leur implémentation. Nous exposons uniquement les opérations pour manipuler ces types de données sans entrer dans les détails de leur implémentation.
L'un des avantages de cette approche est que nous pouvons modifier l'implémentation à tout moment sans changer le comportement exposé à l'utilisateur.
# 2) Abstraction de contrôle
L'abstraction de contrôle collecte toutes les instructions de contrôle qui font partie de l'application et les expose en tant qu'unité. Cette fonction est utilisée lorsque nous devons effectuer une fonction de travail à l'aide de cette unité de contrôle.
L'abstraction de contrôle constitue l'unité principale de la programmation structurée et en utilisant l'abstraction de contrôle, nous pouvons définir des fonctions simples à des cadres complexes.
Qu'est-ce que l'abstraction en Java
Comme Java est un langage POO, l'abstraction peut être considérée comme l'une des fonctionnalités et éléments de base importants du langage Java. En Java, l'abstraction est implémentée à l'aide d'une classe abstraite et d'une interface.
Alors, comment implémenter l'abstraction en Java? Java fournit un modificateur «abstrait» sans accès pour implémenter l'abstraction. Ce modificateur abstrait peut être utilisé avec des classes et des méthodes mais pas des variables.
L'interface fournit une abstraction complète, c'est-à-dire qu'elle ne fournit que des prototypes de méthodes et non leur implémentation. Une classe abstraite fournit une abstraction partielle dans laquelle au moins une méthode ne doit pas être implémentée.
Dans ce didacticiel, nous aborderons en détail l'abstraction avec des classes abstraites. Nous explorerons les interfaces en détail dans nos tutoriels ultérieurs.
Exemple d'abstraction Java
Prenons l'exemple ci-dessous.
//abstract class abstract class Car{ abstract void accelerate(); } //concrete class class Suzuki extends Car{ void accelerate(){ System.out.println('Suzuki::accelerate'); } } class Main{ public static void main(String args()){ Car obj = new Suzuki(); //Car object =>contents of Suzuki obj.accelerate(); //call the method } } Production:
L'exemple d'abstraction simple qui est donné ci-dessus a une classe Car. Dans cette classe Car, nous avons une méthode abstraite pour accelerate (). Ensuite, nous héritons de cette classe dans la classe Suzuki. À l'intérieur de la classe Suzuki, nous implémentons la méthode d'accélération.
L'exemple ci-dessus montre simplement la manière dont une classe abstraite est définie, héritée, puis utilisée dans le programme.
Qu'est-ce que la classe abstraite Java
Nous avons déjà mentionné que Java implémentait l'abstraction en utilisant des classes et des interfaces abstraites. Voyons d'abord tout sur la classe abstraite.
Une classe abstraite peut être définie comme une classe déclarée avec le mot-clé «abstract» et a une restriction qu'elle ne peut pas être instanciée.
Une classe abstraite peut avoir ou non une méthode abstraite (une méthode sans implémentation). En ce qui concerne JVM, une classe abstraite est une classe incomplète qui n'a pas un comportement complet.
La syntaxe générale d'une classe abstraite est donnée ci-dessous:
abstract class { public abstract void abstractMethod(); public void normalMethod() { //method body } } Comme le montre la syntaxe de la classe abstraite ci-dessus, nous pouvons avoir des méthodes abstraites et non abstraites dans une classe abstraite. Le mot-clé «abstract» précède la déclaration de classe.
En un mot, une classe abstraite peut être décrite comme indiqué ci-dessous.
Méthode abstraite en Java
Une méthode abstraite est une méthode précédée d’un mot-clé «abstrait» sans aucune implémentation. Une méthode abstraite est déclarée dans une classe abstraite.
Une méthode abstraite est celle qui rend une classe incomplète car elle n’a pas d’implémentation. Par conséquent, lorsque nous incluons une méthode abstraite dans la classe, la classe devient naturellement incomplète.
Nous pouvons utiliser la méthode abstraite en l'implémentant dans une sous-classe, c'est-à-dire qu'une classe hérite de la classe abstraite puis implémente ou fournit le code pour toutes les méthodes abstraites déclarées dans la classe abstraite en les surchargeant.
Ainsi, il devient obligatoire de remplacer la méthode abstraite dans la sous-classe. Si la méthode abstraite n'est pas implémentée dans la sous-classe également, nous devons déclarer la sous-classe également comme «abstraite».
La déclaration générale de la méthode abstraite est:
abstrait annuler methodName (liste_paramètres);
Lors de l'écriture de la méthode abstraite, nous devons nous rappeler les règles suivantes:
- Une classe contenant une ou plusieurs méthodes abstraites est une classe abstraite.
- Certains autres mots-clés ne doivent pas être utilisés avec le mot-clé abstract.
Ainsi, les combinaisons suivantes sont illégales en Java.
- final
- abstrait natif
- statique abstrait
- abstrait privé
- résumé synchronisé
- résumé strictfp
Implémentons un exemple de classe abstraite et de méthode abstraite.
//abstract class abstract class Bank{ abstract int getInterestRate(); } //concrete class class Citi extends Bank{ int getInterestRate(){return 7;} } //concrete class class HSBC extends Bank{ int getInterestRate(){return 6;} } class Main{ public static void main(String args()){ Bank b; b = new Citi (); // concrete class object System.out.println('Citi Rate of Interest is: '+b.getInterestRate()+'%'); b = new HSBC (); // concrete class object System.out.println('HSBC Rate of Interest is: '+b.getInterestRate()+'%'); } } Production:
Dans l'exemple ci-dessus, nous avons une classe Bank. Dans cette classe, nous avons une méthode abstraite, getInterestRate (). Ensuite, nous déclarons deux classes - ICICI et BOI qui héritent de la classe Bank. Ces deux classes implémentent la méthode getInterestRate () en renvoyant leurs taux d'intérêt respectifs.
Ensuite, dans la méthode principale, nous créons un objet banque. Tout d'abord, l'objet banque contient un objet de classe ICICI et affiche le taux d'intérêt. Ensuite, l'objet BOI est créé et affiche le taux d'intérêt.
Ainsi, nous pouvons supposer que la classe Bank est une sorte d'esquisse ou de structure qui nous permet d'obtenir un taux d'intérêt. À partir de cette structure, nous pouvons créer autant de classes concrètes que nous le souhaitons, puis nous pouvons obtenir les taux d'intérêt respectifs pour chaque objet bancaire (cela est montré dans la méthode principale).
Quelle est l'utilisation d'une classe abstraite en Java
Pourquoi utilisons-nous une classe abstraite alors qu'en réalité elle n'a pas d'implémentation propre?
En plus de la réponse à la question ci-dessus, nous illustrerons également comment utiliser une classe abstraite dans l'exemple qui suit.
Prenons un exemple de véhicules. Nous savons que les véhicules peuvent être de plusieurs types. Nous pouvons avoir des voitures, des scooters, des vélos, des cyclomoteurs, des bus, etc. Bien qu'il existe de nombreux types de véhicules, ils ont certaines propriétés ou attributs communs à tous les véhicules quel que soit leur type.
Par exemple, chaque véhicule a un modèle, un numéro de châssis, une couleur, etc. Chacun d'eux a des fonctions telles que démarrer, arrêter, accélérer, freiner, etc. Désormais, chaque véhicule aura les propriétés et méthodes ci-dessus qui sont également communes aux autres. En même temps que l'utilisateur d'un véhicule, certains aspects ne nous intéressent peut-être pas.
Par exemple, si une personne conduit une voiture, ce qui l'intéressera est simplement de démarrer et d'arrêter le véhicule ou d'accélérer ou de freiner le véhicule. Il ne sera pas intéressé de savoir comment le véhicule démarre ou s'arrête. Nous ne nous intéressons qu'au fonctionnement abstrait des fonctions et non à leurs détails.
Maintenant, si nous voulons représenter l'exemple de système ci-dessus dans une application logicielle, comment le concevoir? Tout d'abord, nous allons implémenter une certaine abstraction. Maintenant, on sait que certaines fonctions sont communes mais selon chaque modèle l'implémentation de ces fonctions sera différente.
Pour commencer, nous déclarons une classe abstraite «Véhicule».
Nous avons montré ce système ci-dessous:
Nous aurons donc une classe abstraite Véhicule et il y aura une classe concrète représentant chaque modèle du véhicule. À des fins d'illustration, nous n'avons utilisé que trois modèles, à savoir voiture, vélo et scooter.
Ci-dessous, la hiérarchie des classes du système ci-dessus.
abstract class Vehicle{ abstract void start () ; abstract void stop (); abstract void accelerate (); abstract void brake (); } class Car extends Vehicle{ void start () { //code here…} void stop () { //code here…} void accelerate () { //code here…} void brake () { //code here…} } class Bike extends Vehicle{ void start () { //code here…} void stop () { //code here…} void accelerate () { //code here…} void brake () { //code here…} } class Scooter extends Vehicle{ void start () { //code here…} void stop () { //code here…} void accelerate () { //code here…} void brake () { //code here…} } Nous aurons donc une classe abstraite de véhicule et trois classes de voiture, de vélo et de scooter. Chacune de ces classes étendra la classe Vehicle et remplacera chacune des méthodes abstraites.
Ainsi en général, chaque fois que nous devons représenter un tel système qui a des méthodes ou des opérations communes à représenter, alors pour ne présenter que la perspective extérieure à l'utilisateur, nous optons pour l'abstraction. En conséquence, nous retirons les méthodes communes et les représentons comme des méthodes abstraites et rassemblons ces méthodes abstraites dans une classe abstraite commune.
Une fois que nous avons le contour d'un système représenté comme une classe abstraite et les opérations comme des méthodes abstraites, nous pouvons alors dériver un nombre quelconque de classes de la classe abstraite donnée et remplacer les méthodes abstraites pour implémenter ces opérations pour chaque classe.
De cette façon, il devient utile de concevoir un système.
Classe abstraite et interface
Nous avons vu la classe abstraite ci-dessus. Les interfaces sont encore d'autres blocs de construction qui implémentent l'abstraction. Les interfaces sont des contrats et les classes implémentant l'interface doivent honorer ces contrats.
Les contrats dans les interfaces ne sont que des méthodes qui ne sont pas implémentées. À l'intérieur des interfaces, nous n'aurons que des prototypes de méthodes. Il n'y aura pas une seule implémentation de méthodes à l'intérieur des interfaces.
Si nous avons une déclaration d'interface comme suit:
public interface interfaceA{ void myInterfaceMethod (); } Ensuite, toute classe qui implémente l'interfaceA doit remplacer «myInterfaceMethod».
Si nous ne remplaçons pas du tout la méthode dans une classe, alors cette classe est représentée comme abstraite.
abstract class TestClass implements interfaceA{ // not a compulsion to override myInterfaceMethod. } Nous aurons un tutoriel séparé sur l'interface plus tard.
Ensuite, laissez-nous discuter de certaines des différences entre les classes abstraites et les interfaces en Java.
Différence entre la classe abstraite et l'interface
| Classe abstraite | Interface |
|---|---|
| Une classe abstraite peut avoir des membres de données privés ou protégés en dehors des membres publics. | Les membres de l'interface sont par défaut publics. |
| Une classe abstraite peut avoir des méthodes abstraites et / ou non abstraites. | Une interface ne peut avoir que des méthodes abstraites. |
| Le résumé peut contenir ou non les variables finales. | Les interfaces peuvent définir des variables finales comme variables par défaut. |
| Une classe abstraite peut avoir des variables finales, statiques ou non statiques ou non finales. | Les interfaces ne peuvent avoir que des variables finales et statiques. |
| Une classe abstraite peut fournir une implémentation d'interface. | Les interfaces ne peuvent pas implémenter une classe abstraite. |
| Une classe abstraite est héritée à l'aide du mot-clé «extend». | L'interface est implémentée à l'aide du mot-clé «implements». |
| Une classe abstraite peut étendre d'autres classes ou implémenter plusieurs interfaces. | L'interface ne peut implémenter qu'une autre interface. |
Quand utiliser une classe abstraite et une interface en Java
La décision sur le moment d'utiliser la classe abstraite et le moment d'utiliser les interfaces dans l'application Java doit être prise intelligemment après avoir bien compris le problème à résoudre. Il y a deux aspects que nous devons considérer comme indiqué ci-dessous.
Classes abstraites avec comportement partiel
Nous savons que les classes abstraites peuvent ne pas être complètement implémentées moins. Ils peuvent avoir un comportement partiel. En revanche, les interfaces n'ont aucune implémentation. Ainsi, lorsque nous devons choisir entre une classe abstraite et une implémentation, nous devons considérer cet aspect de notre application.
Cela signifie que nous devons d'abord décider si l'application que nous concevons a une implémentation partielle commune que nous pouvons séparer dans une classe abstraite.
Par exemple, considérez que nous concevons une application Web. Pour cela, nous devrons utiliser une technologie Web comme Servlet, API REST, etc. Maintenant, chacune de ces technologies Web a des techniques ou des étapes qui doivent être implémentées quelle que soit l'application que nous développons. Ensuite, nous construisons notre application personnalisée.
Ainsi, dans ce cas, le code défini que la technologie Web doit exécuter peut être placé dans une classe abstraite. Pouvons-nous avoir une interface pour cela? Non. C'est parce que l'interface ne peut pas avoir d'implémentation.
Interfaces contractuelles uniquement
Nous savons que les interfaces ont des contrats ou des méthodes qui en font partie. Ces méthodes ne sont que des prototypes. Nous devons implémenter ces interfaces dans une classe, puis remplacer les méthodes.
Considérons maintenant l'interface Map de Java Collections Framework. De nombreuses classes comme HashMap, TreeMap et HashTable, etc. implémentent cette interface. Chacune de ces classes a une implémentation différente. Ils n'ont aucun comportement commun pouvant être représenté dans la classe abstraite.
Nous concevons donc une interface avec des prototypes de méthodes, puis implémentons chacune des classes.
De cette façon, nous devrions peser chaque facteur correctement avant de choisir entre une classe abstraite et une interface.
Différence entre l'abstraction et l'encapsulation
Discutons de certaines des différences entre l'abstraction et une autre caractéristique importante de la POO, à savoir l'encapsulation.
| Abstraction | Encapsulation |
|---|---|
| Processus d'obtention et d'abstraction des informations | Processus de liaison des informations. |
| La technique d'abstraction se situe au niveau de la conception ou de l'interface. | Le mécanisme d'encapsulation se situe au niveau de la mise en œuvre. |
| L'abstraction cache les détails. | L'encapsulation lie les informations en une seule unité, ce qui garantit la sécurité des informations. |
| L'abstraction est implémentée à l'aide de classes abstraites et d'interfaces. | Les modificateurs d'accès à savoir public, privé et protégé et par défaut jouent un rôle dans l'encapsulation. |
| Dans l'abstraction, la seule vue abstraite est présentée à l'utilisateur tandis que les données complexes et détaillées sont cachées à l'utilisateur. | Dans l'encapsulation, les données sont regroupées sous forme d'unité et peuvent être protégées ou rendues accessibles à l'aide de modificateurs d'accès et de méthodes getter et setter. |
Questions fréquemment posées
Q # 1) L'abstraction et les données se cachent-elles de la même manière?
Répondre: Non, l'abstraction et le masquage des données ne sont pas les mêmes. Mais les deux sont des caractéristiques importantes de la programmation orientée objet. Alors que l'abstraction est un processus de masquage des détails d'arrière-plan, le masquage de données est une technique permettant d'isoler les données d'un accès direct.
java vs c ++ qui est mieux
Q # 2) Quels sont les avantages de l'abstraction?
Répondre: Quelques avantages de l'abstraction sont donnés ci-dessous:
- En masquant les détails d'arrière-plan et en exposant uniquement la vue abstraite à l'utilisateur, l'abstraction rend le code plus simple et plus lisible.
- Comme l'abstraction protège les détails inutiles, elle rend le code plus petit.
- La maintenance du code peut devenir complexe et difficile sans abstraction.
Q # 3) Pourquoi l'abstraction est-elle si importante?
Répondre: L'abstraction nous permet de masquer les détails d'arrière-plan qui sont importants et peuvent conduire au chaos s'ils sont divulgués dans le monde. En masquant les détails d'arrière-plan et en exposant uniquement l'interface requise à l'utilisateur, l'abstraction simplifie les applications.
Q # 4) Expliquez l'abstraction avec un exemple en temps réel.
Répondre: Il existe de nombreux exemples d'abstraction en temps réel, notamment des formes géométriques, des véhicules, etc. Un autre exemple encore est l'ATM (Automated Teller Machine). Le guichet automatique prend en charge des opérations comme le retrait d'espèces, la vérification du solde, le transfert d'argent, etc. Mais nous ne savons pas comment ces opérations fonctionnent en interne.
Nous ne disposons que d'un moniteur avec une interface utilisateur pour sélectionner et effectuer les opérations requises.
Q # 5) Pouvons-nous réaliser l'abstraction sans encapsulation?
Répondre: L'abstraction protège les détails de l'implémentation et l'encapsulation masque les détails de l'objet. L'objet est la forme abstraite du monde réel et ses détails sont cachés à l'aide de l'encapsulation. L'encapsulation est donc requise pour l'abstraction.
Conclusion
Dans ce tutoriel, nous avons abordé en détail l'abstraction en Java. L'abstraction est une technique consistant à cacher des détails inutiles à l'utilisateur. L'utilisateur n'a accès qu'aux détails pertinents. Les opérations de véhicules ou les opérations ATM sont des exemples classiques d'abstractions dans le monde réel.
Lorsque nous utilisons ATM, nous ne sommes intéressés qu'à effectuer des opérations telles que le retrait d'espèces, etc. sans avoir à connaître les détails sur la manière exacte dont cette opération est effectuée en interne.
Java fournit l'abstraction via des classes abstraites et des interfaces. Alors que les interfaces fournissent une abstraction à 100%, les classes abstraites fournissent une abstraction partielle. Le choix entre les interfaces et les classes abstraites doit être fait en fonction de l'application à développer et également des informations à exposer à l'utilisateur.
Nous avons également discuté des méthodes abstraites dans ce didacticiel ainsi que des différences entre les classes abstraites et les interfaces.
=> Consultez TOUS les didacticiels Java ici.
lecture recommandée
- Tutoriel sur l'interface Java et la classe abstraite avec des exemples
- Classe Java Integer et Java BigInteger avec exemples
- Tutoriel de classe de scanner Java avec des exemples
- Qu'est-ce que le vecteur Java | Tutoriel de classe vectorielle Java avec des exemples
- Java Enum: Tutoriel sur l'énumération Java avec des exemples
- Principes de base de Java: syntaxe Java, classe Java et principaux concepts Java
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques
- Java Iterator: Apprenez à utiliser les itérateurs en Java avec des exemples