ABSTRACTION EN JAVA

Abstraction en Java est le processus dans lequel nous montrons uniquement les détails/fonctionnalités essentielles à l'utilisateur. Les détails d'implémentation non essentiels ne sont pas affichés à l'utilisateur.

Dans cet article, nous découvrirons l'abstraction et ce que signifie abstrait.

Exemple simple pour comprendre l'abstraction :

Télécommande de télévision est un excellent exemple d'abstraction . Il simplifie l'interaction avec un téléviseur en cachant la complexité derrière de simples boutons et symboles, ce qui la rend facile sans avoir besoin de comprendre les détails techniques du fonctionnement du téléviseur.

Qu’est-ce que l’abstraction en Java ?

En Java, l'abstraction est réalisée par interfaces et cours abstraits . Nous pouvons atteindre 100 % d’abstraction en utilisant des interfaces.

L'abstraction des données peut également être définie comme le processus d'identification uniquement des caractéristiques requises d'un objet en ignorant les détails non pertinents. Les propriétés et les comportements d'un objet le différencient des autres objets de type similaire et aident également à classer/regrouper les objets.

Exemple concret d'abstraction :

Prenons l’exemple réel d’un homme conduisant une voiture. L'homme sait seulement qu'appuyer sur les accélérateurs augmentera la vitesse d'une voiture ou que l'application des freins arrêtera la voiture, mais il ne sait pas comment en appuyant sur l'accélérateur la vitesse augmente réellement, il ne connaît pas le mécanisme interne de la voiture. ou la mise en place de l'accélérateur, des freins, etc. dans la voiture. C’est ça l’abstraction.

Classes abstraites Java et méthodes abstraites Java

Une classe abstraite est une classe déclarée avec un mot-clé abstrait.
Une méthode abstraite est une méthode déclarée sans implémentation.
Une classe abstraite peut avoir ou non toutes les méthodes abstraites. Certaines d'entre elles peuvent être des méthodes concrètes
Un résumé défini par une méthode doit toujours être redéfini dans la sous-classe, ce qui rend primordial obligatoire ou rendant la sous-classe elle-même abstraite.
Toute classe contenant une ou plusieurs méthodes abstraites doit également être déclarée avec un mot-clé abstrait.
Il ne peut y avoir aucun objet d’une classe abstraite. Autrement dit, une classe abstraite ne peut pas être directement instanciée avec le nouvel opérateur .
Une classe abstraite peut avoir des constructeurs paramétrés et le constructeur par défaut est toujours présent dans une classe abstraite.

Algorithme pour implémenter l'abstraction en Java

Déterminez les classes ou interfaces qui feront partie de l’abstraction.
Créez une classe ou une interface abstraite qui définit les comportements et propriétés communs de ces classes.
Définissez des méthodes abstraites au sein de la classe abstraite ou de l'interface qui n'ont aucun détail d'implémentation.
Implémentez des classes concrètes qui étendent la classe abstraite ou implémentent l'interface.
Remplacez les méthodes abstraites dans les classes concrètes pour fournir leurs implémentations spécifiques.
Utilisez les classes concrètes pour implémenter la logique du programme.

Quand utiliser des classes abstraites et des méthodes abstraites ?

Il existe des situations dans lesquelles nous souhaiterons définir une superclasse qui déclare la structure d'une abstraction donnée sans fournir une implémentation complète de chaque méthode. Parfois, nous souhaiterons créer une superclasse qui définit uniquement une forme de généralisation qui sera partagée par toutes ses sous-classes, laissant à chaque sous-classe le soin de remplir les détails.

Prenons un exemple de forme classique, peut-être utilisé dans un système de conception assistée par ordinateur ou une simulation de jeu. Le type de base est la forme et chaque forme a une couleur, une taille, etc. À partir de là, des types spécifiques de formes sont dérivés (hérités) – cercle, carré, triangle, etc. – chacun d’entre eux pouvant avoir des caractéristiques et des comportements supplémentaires. Par exemple, certaines formes peuvent être inversées. Certains comportements peuvent être différents, par exemple lorsque vous souhaitez calculer l'aire d'une forme. La hiérarchie des types incarne à la fois les similitudes et les différences entre les formes.

Classe abstraite en Java

Exemple d'abstraction Java

Exemple 1:

Java

factorielle en Java

// Java program to illustrate the> // concept of Abstraction> abstract> class> Shape {> >String color;> > >// these are abstract methods> >abstract> double> area();> >public> abstract> String toString();> > >// abstract class can have the constructor> >public> Shape(String color)> >{> >System.out.println(>'Shape constructor called'>);> >this>.color = color;> >}> > >// this is a concrete method> >public> String getColor() {>return> color; }> }> class> Circle>extends> Shape {> >double> radius;> > >public> Circle(String color,>double> radius)> >{> > >// calling Shape constructor> >super>(color);> >System.out.println(>'Circle constructor called'>);> >this>.radius = radius;> >}> > >@Override> double> area()> >{> >return> Math.PI * Math.pow(radius,>2>);> >}> > >@Override> public> String toString()> >{> >return> 'Circle color is '> +>super>.getColor()> >+>'and area is : '> + area();> >}> }> class> Rectangle>extends> Shape {> > >double> length;> >double> width;> > >public> Rectangle(String color,>double> length,> >double> width)> >{> >// calling Shape constructor> >super>(color);> >System.out.println(>'Rectangle constructor called'>);> >this>.length = length;> >this>.width = width;> >}> > >@Override> double> area() {>return> length * width; }> > >@Override> public> String toString()> >{> >return> 'Rectangle color is '> +>super>.getColor()> >+>'and area is : '> + area();> >}> }> public> class> Test {> >public> static> void> main(String[] args)> >{> >Shape s1 =>new> Circle(>'Red'>,>2.2>);> >Shape s2 =>new> Rectangle(>'Yellow'>,>2>,>4>);> > >System.out.println(s1.toString());> >System.out.println(s2.toString());> >}> }>

date actuelle en java

Sortir

Shape constructor called Circle constructor called Shape constructor called Rectangle constructor called Circle color is Redand area is : 15.205308443374602 Rectangle color is Yellowand area is : 8.0>

Exemple 2 :

Java

// Java Program to implement> // Java Abstraction> > // Abstract Class declared> abstract> class> Animal {> >private> String name;> > >public> Animal(String name) {>this>.name = name; }> > >public> abstract> void> makeSound();> > >public> String getName() {>return> name; }> }> > // Abstracted class> class> Dog>extends> Animal {> >public> Dog(String name) {>super>(name); }> > >public> void> makeSound()> >{> >System.out.println(getName() +>' barks'>);> >}> }> > // Abstracted class> class> Cat>extends> Animal {> >public> Cat(String name) {>super>(name); }> > >public> void> makeSound()> >{> >System.out.println(getName() +>' meows'>);> >}> }> > // Driver Class> public> class> AbstractionExample {> >// Main Function> >public> static> void> main(String[] args)> >{> >Animal myDog =>new> Dog(>'Buddy'>);> >Animal myCat =>new> Cat(>'Fluffy'>);> > >myDog.makeSound();> >myCat.makeSound();> >}> }>

Sortir

Buddy barks Fluffy meows>

Explication du programme Java ci-dessus :

Ce code définit une classe abstraite Animal avec une méthode abstraite makeSound(). Les classes Dog et Cat étendent Animal et implémentent la méthode makeSound(). La méthode main() crée des instances de Dog et Cat et appelle la méthode makeSound() sur celles-ci.
acteur Zeenat Aman

Cela démontre le concept d'abstraction en Java, où nous définissons un modèle pour une classe (dans ce cas Animal), mais laissons l'implémentation de certaines méthodes être définie par des sous-classes (dans ce cas makeSound()).

Interface

Les interfaces sont une autre méthode d'implémentation de l'abstraction en Java. La principale différence est qu’en utilisant des interfaces, nous pouvons atteindre 100 % d’abstraction dans les classes Java. En Java ou dans tout autre langage, les interfaces incluent à la fois des méthodes et des variables mais n'ont pas de corps de méthode. Outre l'abstraction, les interfaces peuvent également être utilisées pour implémenter des interfaces en Java.

Mise en œuvre: Pour mettre en œuvre un interface nous utilisons le mot-clé met en œuvre avec classe.

Java

// Define an interface named Shape> interface> Shape {> >double> calculateArea();>// Abstract method for> >// calculating the area> }> > // Implement the interface in a class named Circle> class> Circle>implements> Shape {> >private> double> radius;> > >// Constructor for Circle> >public> Circle(>double> radius) {>this>.radius = radius; }> > >// Implementing the abstract method from the Shape> >// interface> >public> double> calculateArea()> >{> >return> Math.PI * radius * radius;> >}> }> > // Implement the interface in a class named Rectangle> class> Rectangle>implements> Shape {> >private> double> length;> >private> double> width;> > >// Constructor for Rectangle> >public> Rectangle(>double> length,>double> width)> >{> >this>.length = length;> >this>.width = width;> >}> > >// Implementing the abstract method from the Shape> >// interface> >public> double> calculateArea() {>return> length * width; }> }> > // Main class to test the program> public> class> Main {> >public> static> void> main(String[] args)> >{> >// Creating instances of Circle and Rectangle> >Circle myCircle =>new> Circle(>5.0>);> >Rectangle myRectangle =>new> Rectangle(>4.0>,>6.0>);> > >// Calculating and printing the areas> >System.out.println(>'Area of Circle: '> >+ myCircle.calculateArea());> >System.out.println(>'Area of Rectangle: '> >+ myRectangle.calculateArea());> >}> }>

entreprise contre entreprise

Sortir

Area of Circle: 78.53981633974483 Area of Rectangle: 24.0>

Avantages de l'abstraction

Voici quelques avantages de l’abstraction :

Cela réduit la complexité de la visualisation des choses.
Évite la duplication de code et augmente la réutilisabilité.
Contribue à augmenter la sécurité d'une application ou d'un programme car seuls les détails essentiels sont fournis à l'utilisateur.
Cela améliore la maintenabilité de l’application.
Il améliore la modularité de l'application.
L'amélioration deviendra très simple car sans affecter les utilisateurs finaux, nous pouvons effectuer tout type de modifications dans notre système interne.
Améliore la réutilisabilité et la maintenabilité du code.
Masque les détails de mise en œuvre et expose uniquement les informations pertinentes.
Fournit une interface claire et simple à l’utilisateur.
Augmente la sécurité en empêchant l’accès aux détails internes de la classe.
Prend en charge la modularité, car les systèmes complexes peuvent être divisés en parties plus petites et plus faciles à gérer.
L'abstraction fournit un moyen de cacher à l'utilisateur la complexité des détails d'implémentation, ce qui la rend plus facile à comprendre et à utiliser.
L'abstraction permet une flexibilité dans la mise en œuvre d'un programme, car des modifications des détails de mise en œuvre sous-jacents peuvent être apportées sans affecter l'interface utilisateur.
L'abstraction permet la modularité et la séparation des préoccupations, rendant le code plus maintenable et plus facile à déboguer.

Inconvénients de l'abstraction en Java

Voici les principaux inconvénients de l’abstraction en Java :

L'abstraction peut rendre plus difficile la compréhension du fonctionnement du système.
Cela peut entraîner une complexité accrue, surtout s’il n’est pas utilisé correctement.
Cela peut limiter la flexibilité de la mise en œuvre.
L'abstraction peut ajouter une complexité inutile au code si elle n'est pas utilisée de manière appropriée, entraînant une augmentation du temps et des efforts de développement.
L'abstraction peut rendre plus difficile le débogage et la compréhension du code, en particulier pour ceux qui ne connaissent pas les couches d'abstraction et les détails d'implémentation.
La surutilisation de l'abstraction peut entraîner une diminution des performances en raison des couches supplémentaires de code et de l'indirection.