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 AmanCela 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.
Lire aussi :
- Interfaces en Java
- Classes abstraites en Java
- Différence entre classe abstraite et interface
- mot-clé abstrait en Java
Abstraction en Java – FAQ
T1. Pourquoi utilisons-nous l'abstrait ?
L’une des principales raisons pour lesquelles nous utilisons des concepts abstraits est de simplifier la complexité. Imaginez essayer d'expliquer l'univers entier avec chaque atome et chaque étoile ! Les abstraits nous permettent de faire un zoom arrière, de saisir les idées principales comme la gravité et l'énergie, et de donner un sens à tout cela sans nous perdre dans les détails.
Voici quelques autres raisons pour lesquelles nous utilisons le résumé en Java :
1. Abstraction : Les classes abstraites sont utilisées pour définir un modèle générique que d'autres classes doivent suivre. Ils définissent un ensemble de règles et de lignes directrices que leurs sous-classes doivent suivre. En fournissant une classe abstraite, nous pouvons garantir que les classes qui l'étendent ont une structure et un comportement cohérents. Cela rend le code plus organisé et plus facile à maintenir.
2. Polymorphisme : Les classes et méthodes abstraites permettent le polymorphisme en Java. Le polymorphisme est la capacité d'un objet à prendre plusieurs formes. Cela signifie qu'une variable de type abstrait peut contenir des objets de n'importe quelle sous-classe concrète de cette classe abstraite. Cela rend le code plus flexible et adaptable à différentes situations.
3. Frameworks et API : Java dispose de nombreux frameworks et API qui utilisent des classes abstraites. En utilisant des classes abstraites, les développeurs peuvent économiser du temps et des efforts en s'appuyant sur le code existant et en se concentrant sur les aspects spécifiques à leurs applications.
Q2. Quelle est la différence entre Encapsulation et abstraction de données ?
Voici quelques différences clés entre l’encapsulation et l’abstraction n/b :
Encapsulation
Abstraction
L'encapsulation consiste à cacher des données (masquage d'informations) L'abstraction est un masquage détaillé (masquage de l'implémentation). L'encapsulation regroupe les données et les méthodes qui agissent sur les données L'abstraction des données consiste à exposer l'interface à l'utilisateur et à masquer les détails de la mise en œuvre. Les classes encapsulées sont des classes Java qui suivent le masquage et l'abstraction des données L'implémentation de l'abstraction se fait à l'aide de classes abstraites et d'une interface L'encapsulation est une procédure qui a lieu au niveau de la mise en œuvre l'abstraction est un processus au niveau de la conception
Q3. Qu'est-ce qu'un exemple concret d'abstraction de données ?
Télécommande de télévision est un excellent exemple concret 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.
Q4. Quelle est la différence entre les classes abstraites et les interfaces en Java ?
Voici quelques différences clés entre les classes abstraites et les interfaces en Java :
Classe abstraite
tri par sélection JavaInterfaces
Les classes abstraites prennent en charge les méthodes abstraites et non abstraites Les supports d'interface n'ont que des méthodes abstraites. Ne prend pas en charge l'héritage multiple Prend en charge l'héritage multiple Les classes abstraites peuvent être étendues par des classes Java et plusieurs interfaces L'interface peut être étendue uniquement par l'interface Java. Les membres de la classe abstraite en Java peuvent être privés, protégés, etc. Les interfaces sont publiques par défaut. Exemple:
classe abstraite publique Vechicle{
lecteur vide abstrait public ()
}Exemple:
interface publique Animal{
void parler();
}