Concepts de programmation orientée objet JAVA

JAVA est basé sur les concepts de programmation orientée objet, ce qui permet de passer à un niveau d'abstraction supérieur pour résoudre n'importe quel problème de manière réaliste. L'approche orientée objet conceptualise la solution à un problème en termes d'objets du monde réel plus faciles à réutiliser dans une application. Par exemple, Chair(chaise), Fan(ventilateur), Dog(chien), Computer(ordinateur) et ainsi de suite. En JAVA, une classe est une mise en page, un modèle ou un prototype qui définit le comportement général d'un objet d'un type donné. Une instance est une implémentation distincte d'une classe et toutes les instances d'une classe ont les mêmes propriétés, qui sont décrites dans la définition de la classe. Par exemple, vous pouvez définir une classe nommée House avec le nombre de pièces comme attribut et créer des instances de la classe telles qu'une maison à deux pièces, une maison à trois pièces, etc. Avantages : vous trouverez ci-dessous quelques avantages du développement de logiciels orientés objet.

• Coûts de support logiciel réduits, principalement grâce au fait qu'il est réalisé de manière modulaire.
• Réutilisation améliorée du code grâce à des fonctionnalités telles que l’héritage, ce qui permet un développement logiciel plus rapide.
• Fiabilité et flexibilité accrues du code.
• Facilité de compréhension grâce à la simulation du monde réel.
• Meilleure abstraction au niveau de l'objet.
• Réduire la complexité de la transition d’une phase de développement à une autre.

Il y a quatre caractéristiques principales de la POO :

• Encapsulation
• Héritage
• Polymorphisme
• Abstraction

Encapsulation

L'encapsulation agit comme un contrat pour un objet sur ce qu'il doit cacher et ce qu'il doit ouvrir pour que d'autres objets puissent y accéder. En JAVA, nous utilisons un modificateur d'accès privatepour masquer une méthode et restreindre l'accès à une variable depuis le monde extérieur. JAVA dispose également de divers modificateurs d'accès : public, default, protected, private, qui sont utilisés pour restreindre la visibilité à différents niveaux. Mais le but ultime est d’encapsuler les choses qui ne devraient pas être modifiées. L'approche qui fonctionne le mieux est qu'une classe ne devrait avoir qu'une seule raison de changer, et l'encapsulation fait de la conception de cette « raison unique » une réalité. La bonne approche de l'encapsulation consiste à masquer les éléments qui changent fréquemment pour éviter d'endommager les autres classes. Avantages : Vous trouverez ci-dessous quelques-uns des avantages de l'encapsulation :

• Nous pouvons protéger l'état interne d'un objet en masquant ses attributs.
• Cela améliore la modularité du code car cela empêche les objets d'interagir de manière inattendue.
• Améliore la convivialité du code.
• Cela prend en charge la relation contractuelle d’une entité spécifique.
• L'encapsulation facilite la maintenance des logiciels.
• Les modifications du code peuvent être apportées indépendamment les unes des autres.

Polymorphisme

Le polymorphisme en programmation est la capacité de fournir la même interface pour différentes formes sous-jacentes (types de données). Cela signifie que les classes ayant des fonctionnalités différentes partagent la même interface et peuvent être appelées dynamiquement en passant des paramètres par référence. Un exemple classique est la classe Shape(forme) et toutes les classes qui en héritent : square(carré), circle(cercle), dodecahedron(dodécaèdre), irregular polygon(polygone irrégulier), splat(blob), etc. Dans cet exemple, chaque classe aura sa propre méthode Draw()et le code client pourra simplement faire :

Shape shape = new Shape();

Shape.area()pour obtenir le comportement correct de n'importe quelle forme La beauté du polymorphisme est que le code, travaillant avec différentes classes, n'a pas besoin de savoir quelle classe il utilise, puisqu'elles fonctionnent toutes sur le même principe. Le processus utilisé par les langages de programmation orientés objet pour implémenter le polymorphisme dynamique est appelé liaison dynamique. Remarque : Le polymorphisme est la possibilité de choisir des méthodes plus spécifiques à exécuter en fonction de l'objet. Le polymorphisme se produit lorsque les classes abstraites ne sont pas impliquées. Avantages :

• Création de code réutilisable. Autrement dit, une fois qu’une classe est créée, implémentée et testée, elle peut être utilisée librement sans se soucier de ce qui y est exactement écrit.
• Cela permet un code plus générique et faiblement couplé.
• Le temps de compilation est réduit, ce qui accélère le développement.
• Liaison dynamique.
• La même interface peut être utilisée pour créer des méthodes avec différentes implémentations.
• L'intégralité de l'implémentation peut être remplacée en utilisant les mêmes signatures de méthode.

Remplacement de méthode dans le cadre du polymorphisme. Un remplacement interagit avec deux méthodes : une méthode de la classe parent et une méthode de la classe dérivée. Ces méthodes ont le même nom et les mêmes signatures. Le remplacement vous permet d'effectuer la même opération de différentes manières pour différents types d'objets. Par exemple:

while(it.hasNext()) {
Shape s = (Shape) it.next();
totalArea += s.area(dim); //будет применен полиморфизм и вызван нужный метод для каждого an object.
}

Surcharge de méthode ou polymorphisme ad hoc ou polymorphisme statique La surcharge interagit avec plusieurs méthodes de la même classe qui portent le même nom mais ont des signatures de méthode différentes. Le rechargement permet de décrire la même opération de différentes manières pour différentes données. On l’appelle parfois polymorphisme statique, mais en réalité ce n’est pas un polymorphisme. Ce n’est rien de plus que d’avoir simplement deux méthodes portant les mêmes noms, mais une liste d’arguments différente. Le redémarrage n'a rien à voir avec l'héritage et le polymorphisme. Et une méthode surchargée n’est pas du tout la même chose qu’une méthode surchargée. Polymorphisme paramétrique via la génération en JAVA Lors de la déclaration d'une classe, le champ de nom peut être associé à différents types et le nom de la méthode peut être associé à différents paramètres et types de retour. JAVA prend en charge le polymorphisme paramétrique en utilisant des génériques.

List<String> list = new ArrayList<String>();

Pourquoi ne pouvons-nous pas remplacer une méthode statique en JAVA ? Le remplacement dépend de l'existence d'une instance de la classe. L'idée du polymorphisme est que vous pouvez créer une sous-classe et que les objets implémentés par ces sous-classes se comporteront différemment avec les mêmes méthodes de la classe parent (remplacées dans les sous-classes). Une méthode statique n’est associée à aucune instance de la classe, le concept de substitution elle-même ne peut donc pas être appliqué. Les créateurs de JAVA ont été guidés par deux considérations qui ont influencé cette approche. Premièrement, il y a des problèmes d’exécution de code : Smalltalk a été beaucoup critiqué pour sa lenteur (le garbage collection et le polymorphisme faisaient partie de ce problème), et JAVA a été conçu pour éviter cela. La deuxième considération était la décision selon laquelle le public cible de JAVA serait constitué de développeurs C++. Le fait que les méthodes statiques fonctionnent de cette manière était très familier aux programmeurs C++ et accélérait également les choses puisqu'il n'était pas nécessaire de remonter dans la hiérarchie des classes pour déterminer quelle méthode appeler. Vous allez directement en classe et appelez une méthode spécifique.

Héritage

L'héritage est l'acte d'incorporer le comportement (c'est-à-dire les méthodes) et l'état (c'est-à-dire les variables) d'une classe de base dans une classe dérivée afin qu'ils deviennent disponibles dans cette classe dérivée. Le principal avantage de l’héritage est qu’il fournit un mécanisme formel pour la réutilisation du code et évite la duplication. Une classe héritée étend les fonctionnalités de l'application en copiant le comportement de la classe parent et en ajoutant de nouvelles fonctionnalités. Cela rend le code hautement couplé. Si vous souhaitez changer de superclasse, vous devrez connaître tous les détails des sous-classes pour ne pas casser le code. L'héritage est une forme de réutilisation logicielle dans laquelle une nouvelle classe (sous-classe) est créée à partir d'une classe existante (superclasse) qui étend ses fonctionnalités et utilise certaines des propriétés de la superclasse. Ainsi, si vous avez une classe parent et qu'une classe enfant apparaît, l'enfant hérite de tout ce que possède le parent. Avantages :

• Réutilisation améliorée du code.
• La relation logique « est un » (est quelqu'un, quelque chose) s'établit. Par exemple : Le chien est un animal . (Un chien est un animal).
• Modularisation du code.
• Les répétitions sont exclues.

Défaut:

• Étroitement couplé : une sous-classe dépend de l’implémentation d’une classe parent, ce qui rend le code étroitement couplé.

Abstraction

L'abstraction signifie concevoir des classes basées sur leurs interfaces et fonctionnalités, sans prendre en compte les détails d'implémentation. Une classe abstraite représente les interfaces sans inclure l'implémentation réelle. Il distingue l'implémentation d'un objet de son comportement. L'abstraction simplifie le code en masquant les détails sans importance. Avantages :

• En utilisant l’abstraction, nous pouvons séparer ce qui peut être regroupé en un certain type.
• Les propriétés et méthodes qui changent fréquemment peuvent être regroupées dans un type distinct, afin que le type principal ne soit pas soumis à des modifications. Cela renforce le principe de la POO : « Le code doit être ouvert à l'extension, mais fermé au changement . »
• L'abstraction simplifie la représentation des modèles de domaine.

Différence entre abstraction et encapsulation L'encapsulation est une stratégie utilisée dans le cadre de l'abstraction. L'encapsulation fait référence à la structure d'un objet : les objets encapsulent leurs propriétés et les cachent aux accès extérieurs. Les utilisateurs d'une classe interagissent avec elle à l'aide de ses méthodes, mais n'ont pas d'accès direct à la structure de la classe. De cette façon, la classe résume les détails d’implémentation liés à sa conception. L'abstraction est un terme plus général. Cela peut également être réalisé, entre autres, à l’aide de sous-classes. Par exemple, une classe List(liste) dans la bibliothèque standard est une abstraction d'une séquence d'éléments, indexés selon leur place dans la liste. Des exemples spécifiques d'une liste Listsont ArrayListou LinkedList. Le code qui interagit avec une liste Listrésume les détails de la liste qu’il utilise. Souvent, l’abstraction n’est pas possible sans masquer l’état sous-jacent à l’aide de l’encapsulation. Si une classe expose sa structure interne, elle ne peut pas modifier ses opérations internes et ne peut donc pas être abstraite. Que sont la classe abstraite et la méthode abstraite ? Il arrive que lors du développement, vous souhaitiez qu'une classe de base fournisse uniquement une interface à ses classes dérivées. Autrement dit, vous ne voulez pas que quiconque crée des instances de la classe de base. Vous devez utiliser l'interface de telle manière que vous ne transtypez que des objets (il s'agit d'une conversion implicite qui permet un comportement polymorphe). Ceci est réalisé en rendant cette classe abstraite à l'aide du mot-clé abstract. Cela impose certaines restrictions, comme l'impossibilité de créer des instances d'une classe abstraite ; lors de l'utilisation d'une classe abstraite, il est nécessaire d'implémenter des méthodes abstraites. Cela garantit le polymorphisme. Une classe abstraite peut contenir à la fois des méthodes abstraites et concrètes. Si au moins une méthode d’une classe est déclarée abstraite, la classe entière doit également être déclarée abstraite. Cependant, la règle inverse ne doit pas être respectée. Si une classe est déclarée abstraite, elle ne peut pas contenir de méthodes abstraites. Une méthode qui définit simplement ses signatures et ne fournit pas d’implémentation est appelée abstraite. Son implémentation réelle est laissée à ses sous-classes, qui étendent la classe abstraite. Une méthode abstraite ne peut pas être utilisée par un objet, seule une autre classe peut l'étendre. Quand faut-il utiliser une classe abstraite ? Les classes abstraites vous permettent de définir un comportement par défaut et de demander aux sous-classes de fournir un comportement spécifique. Par exemple : List(list) est une interface, qui définit à son tour AbstractListle comportement de base d'une liste, qui peut être utilisée telle quelle ou affinée dans une sous-classe, par exemple dans ArrayList(list array). Qu'est-ce qu'une interface ? Le concept d'interface est une classe abstraite, mais l'interface (définie par le mot-clé interface) va encore plus loin. Cela empêche toute implémentation d’une méthode ou d’une fonction. Vous pouvez uniquement déclarer une méthode ou une fonction, mais pas fournir son implémentation. La classe qui implémente l’interface doit s’occuper de l’implémentation réelle. Les interfaces sont très utiles et sont largement utilisées en POO. Puisqu’ils partagent l’interface elle-même et la mise en œuvre, ils offrent de nombreux avantages lors de leur utilisation :

1. Héritage multiple .
2. Couplage lâche . Il existe une abstraction de l'opération, comme la superposition, et l'implémentation concrète peut être n'importe quoi : JDBC, JPA, JTA, etc.
3. Le programme d'interface n'est pas implémenté .
4. Polymorphisme de liaison dynamique : L'interface de programmation d'un objet est exposée sans révéler son implémentation réelle.
5. Niveaux abstraits , séparation des fonctionnalités.

Différence entre interface et classe abstraite.

• Une interface est une relation contractuelle avec les classes qui implémentent cette interface, stipulant que l'implémentation se produit de la manière désignée par l'interface. Il s'agit d'un shell vide avec des méthodes déclarées.
• Une classe abstraite définit un comportement général et demande à ses sous-classes de définir un comportement atypique ou spécifique pour leur classe.
• Les méthodes et les membres d'une classe abstraite peuvent être désignés avec n'importe quel modificateur d'accès ; à leur tour, toutes les méthodes d'interface doivent être publiques.
• Lorsqu'elle hérite d'une classe abstraite, la classe descendante doit définir des méthodes abstraites, tandis qu'une interface peut hériter d'une autre interface sans nécessairement définir ses méthodes.
• Une classe descendante ne peut étendre qu'une seule classe abstraite, mais une interface peut étendre ou une classe peut implémenter de nombreuses autres interfaces.
• Une classe descendante peut définir des méthodes abstraites avec un modificateur d'accès identique ou moins restrictif, mais la classe implémentant l'interface doit définir des méthodes avec le même niveau de visibilité.
• Une interface ne contient pas de constructeurs, contrairement à une classe abstraite.
• Les variables déclarées dans l'interface Java sont définitives par défaut. Une classe abstraite peut contenir des variables qui ne sont pas définitives.
• Tous les membres de l'interface Java sont public. Les membres d'une classe abstraite peuvent se permettre d'être public, protectedetc.

Composition

La réutilisation du code peut être réalisée en utilisant à la fois l'héritage et la composition. Mais l’utilisation de la composition offre un niveau d’encapsulation plus élevé que l’héritage, puisque les modifications apportées à la classe back-end n’affecteront pas nécessairement le code appartenant à la classe front-end. La composition est une technique de conception qui utilise des relations « has-a » (has, include) dans les classes. L'héritage Java et la composition d'objets peuvent être utilisés pour réutiliser le code. L’essence de la composition est d’exprimer la relation « a une » entre les objets. Pensez à une chaise. La chaise a un siège. La chaise a un dossier. Une chaise possède un certain nombre de pieds. L’expression « a un » suggère une relation dans laquelle la chaise a, ou du moins utilise, un autre objet. C’est précisément la relation « a-a-a » qui est à la base de la composition. Avantages :

• Contrôle de la visibilité
• L'implémentation peut être remplacée au moment de l'exécution
• Couplage lâche, puisque la classe d'interface ne dépend pas de l'implémentation.

Différences entre composition et héritage Remarque : N'utilisez pas l'héritage uniquement pour garantir la réutilisation du code. S'il n'y a pas de relation « est un » (est), la composition est utilisée à ces fins. La différence entre la composition et l'agrégation réside dans les relations d'objet. L'agrégation est une relation dans laquelle une classe s'inscrit dans une collection. C'est une partie d'une relation globale, où une partie peut exister sans le tout. De telles relations sont beaucoup plus faibles. Il n'y a pas de dépendance cyclique. Par exemple : commande et produit. La composition est une relation dans laquelle une classe s'inscrit dans une collection. C'est une partie d'une relation globale dans laquelle la partie ne peut exister sans le tout. Si le tout est détruit, tous ses composants le seront également. C'est une relation plus forte. Par exemple : un polygone et ses sommets, un ordre et sa composante.