Oops-Programmation Orientée Objet

La Programmation Orientée Objet (POO) fait référence à une méthodologie de programmation basée sur des objets, au lieu de simplement des fonctions et des procédures. Les objets contiennent les données et les méthodes (ou comportement).

dans les concepts OOPs, nous apprendrons quatre principes majeurs: l’abstraction, l’encapsulation, l’héritage et le polymorphisme. Ils sont également connus comme quatre piliers du paradigme de la programmation orientée objet.,

1. l’Abstraction est le processus d’exposer les détails essentiels d’une entité, tout en ignorant les détails inutiles, de réduire la complexité pour les utilisateurs.
2. l’Encapsulation est le processus de regroupement des données et des opérations sur les données regroupées dans une entité.
3. L’héritage est utilisé pour dériver un nouveau type à partir d’un type existant, établissant ainsi une relation parent-enfant.
4. le polymorphisme permet à une entité de prendre différentes significations dans différents contextes.

qu’est-Ce que la programmation orientée Objet?,

dans les premiers jours, les programmes étaient écrits avec du code binaire et des commutateurs mécaniques étaient utilisés pour charger les programmes. Plus tard, à mesure que les capacités matérielles évoluaient, les experts ont essayé de simplifier la programmation en utilisant des langages de haut niveau où des compilateurs étaient utilisés pour générer des instructions de machine à partir du programme.

avec plus d’évolution, les experts ont créé la programmation structurée qui était basée sur de petites fonctions. Ces fonctions ont aidé à bien des égards, par exemple la réutilisation de code, les variables locales, le débogage de code et la maintenabilité du code.,

avec plus de progrès informatiques et la demande pour des applications plus complexes, les limites de la programmation structurée ont commencé à être visibles. Les applications complexes devaient être plus étroitement modélisées avec le monde réel et les cas d’utilisation.

ensuite, les experts ont développé la programmation orientée objet. Au centre de la POO, nous avons des objets et des classes., Tout comme une entité réelle, un objet a deux caractères majeurs :

• données-indique les attributs et l’état de l’objet
• comportement – lui donne la possibilité de se changer et de communiquer avec d’autres objets

1.1. Class and Object

un objet est une instance d’une classe. Chaque objet a son propre état, comportement et identité. Une classe est le modèle ou le modèle de ses objets. Les objets peuvent communiquer avec d’autres objets en appelant des fonctions. Il est parfois appelé passage de message.,

par exemple, si nous travaillons sur une application RH, elle se compose d’entités/acteurs, par exemple employé, gestionnaire, département, fiches de paie, vacances, objectifs, suivi du temps, etc. Pour modéliser ces entités dans des programmes informatiques, nous pouvons créer des classes qui auront des attributs de données et un comportement similaires à ceux de la vie réelle.

Par exemple, un employé de l’entité peut être représenté comme Employee catégorie:

Au-dessus Employee agit comme un modèle. Nous pouvons utiliser cette classe pour créer autant d’objets employés différents que nécessaire dans l’application.,

Employee e = new Employee(111);e.setFirstName("Alex");....int age = e.getAge();

Le id champ permet de stocker et de récupérer les détails de tout employé.

l’identité de l’objet est généralement maintenue par l’environnement d’exécution de l’application, par exemple pour les applications Java, sa machine virtuelle Java (JVM). Chaque fois que nous créons un objet Java, JVM crée un hashcode pour cet objet et l’affecte. De cette façon, même si le programmeur oublie d’ajouter le champid, JVM garantit que tous les objets sont identifiés de manière unique.

1.2., Constructeur

les Constructeurs sont des méthodes spéciales sans valeur de retour. Leur nom est toujours le même que le nom de la classe; mais ils peuvent accepter des paramètres qui aident à définir l’état initial de l’objet, avant que l’application ne commence à l’utiliser.

Si nous ne fournissons aucun constructeur, JVM assigne un constructeur par défaut à la classe. Ce constructeur par défaut n’accepte aucun paramètre.

rappelez-vous que si nous attribuons un constructeur à n’importe quelle classe, la JVM ne lui attribue pas le constructeur par défaut. Si nécessaire, nous devons spécifier explicitement le constructeur par défaut à la classe.,

public class Employee { // Default constructor public Employee() { } // Custom constructor public Employee(int id) { this.id = id; }}

les Quatre Principes de la programmation orientée objet

Les quatre principales caractéristiques de la programmation orientée objet sont:

• l’Abstraction
• l’Encapsulation
• Héritage
• le Polymorphisme

2.1. Abstraction

L’Abstraction est très facile à comprendre lorsque nous la rapportons à l’exemple en temps réel. Par exemple, lorsque nous conduisons notre voiture, nous n’avons pas à nous soucier du fonctionnement interne exact de la voiture., Ce qui nous préoccupe, c’est l’interaction avec la voiture via ses interfaces, comme le volant, la pédale de frein, pédale d’accélérateur, etc. Ici, la connaissance que nous avons de la voiture est abstrait.

en informatique, l’abstraction est le processus par lequel les données et les programmes sont définis avec une représentation similaire à sa signification (sémantique) tout en cachant les détails de l’implémentation.

en termes plus simples, l’abstraction consiste à masquer des informations qui ne sont pas pertinentes pour le contexte ou plutôt à ne montrer que des informations pertinentes et à les simplifier en les comparant à quelque chose de similaire dans le monde réel.,

typiquement, l’abstraction peut être vue de deux manières:

1. abstraction de données

   l’abstraction de données est le moyen de créer des types de données complexes à partir de plusieurs types de données plus petits – ce qui est plus proche des entités réelles. par exemple, une classe Employee peut être un objet complexe d’avoir diverses petites associations.,

   public class Employee { private Department department; private Address address; private Education education; //So on...}

   Donc, si vous voulez extraire les informations d’un employé, vous demandez-vous à partir de Employee objet – comme vous le faites dans la vraie vie, demandez à la personne elle-même.

2. abstraction de contrôle

   L’abstraction de contrôle est obtenue en masquant la séquence d’actions pour une tâche complexe – à l’intérieur d’un appel de méthode simple, de sorte que la logique pour effectuer la tâche peut être cachée au client et pourrait être modifiée à l’avenir sans affecter le code client.,

   public class EmployeeManager{ public Address getPrefferedAddress(Employee e) { //Get all addresses from database //Apply logic to determine which address is preferred //Return address }}

   dans l’exemple ci-dessus, demain, si vous voulez changer la logique pour que chaque adresse domestique soit toujours l’adresse préférée, vous changerez la logique à l’intérieur de la méthodegetPrefferedAddress(), et le client ne sera pas affecté.

en savoir Plus : l’Abstraction en Java

2.2. Encapsulation

L’encapsulation des données et des méthodes dans les classes en combinaison avec le masquage de l’implémentation (via le contrôle d’accès) est souvent appelée encapsulation., Le résultat est un type de données avec des caractéristiques et des comportements.

« quels que soient les changements, encapsulez – le” – un principe de conception célèbre

L’Encapsulation a essentiellement à la fois un cache d’informations et un cache d’implémentation.

• le masquage des informations se fait en utilisant des modificateurs de contrôle d’accès (public, privé, protégé) et implementation hiding est réalisé par la création d’une interface pour une classe.
• le masquage de L’implémentation donne au concepteur la liberté de modifier la façon dont la responsabilité est remplie par un objet., Ceci est particulièrement utile aux points où la conception (ou même les exigences) sont susceptibles de changer.

prenons un exemple pour le rendre plus clair.

2.2.1. Informations masquant

class InformationHiding { //Restrict direct access to inward data private ArrayList items = new ArrayList(); //Provide a way to access data - internal logic can safely be changed in future public ArrayList getItems(){ return items; }}

2.2.2. La mise en œuvre de cacher

interface ImplemenatationHiding { Integer sumAllItems(ArrayList items);}class InformationHiding implements ImplemenatationHiding{ //Restrict direct access to inward data private ArrayList items = new ArrayList(); //Provide a way to access data - internal logic can safely be changed in future public ArrayList getItems(){ return items; } public Integer sumAllItems(ArrayList items) { //Here you may do N number of things in any sequence //Which you do not want your clients to know //You can change the sequence or even whole logic //without affecting the client }}

en savoir Plus : l’Encapsulation En Java

2.3. Héritage

L’héritage est un autre concept important dans la programmation orientée objet., L’héritage en Java est un mécanisme par lequel une classe acquiert les propriétés et les comportements de la classe parent. Cela crée essentiellement une relation parent-enfant entre les classes. En Java, nous utiliserons l’héritage principalement pour la réutilisabilité et la maintenabilité du code.

mot Clé « extends” est utilisé pour hériter d’une classe en java. Le mot-clé » » indique que nous créons une nouvelle classe qui dérive d’une classe existante.

dans la terminologie de Java, une classe héritée est appelée une super classe. La nouvelle classe est appelée sous-classe.,

une sous-classe hérite de tous les membres non privés (champs, méthodes et classes imbriquées) de sa superclasse. Les constructeurs ne sont pas membres, ils ne sont donc pas hérités par les sous-classes, mais le constructeur de la superclasse peut être appelé à partir de la sous-classe.

2.3.1., Exemple d’héritage

public class Employee { private Department department; private Address address; private Education education; //So on...}public class Manager extends Employee { private List<Employee> reportees;}

Dans le code ci-dessus, Manager est spécialisée version de Employee et réutilise department, address et education à partir de Employee de classe ainsi que de définir ses propres balises reportees liste.

3.2.2. Types d’héritage

• héritage unique – une classe enfant est dérivée d’une classe parent.

  class Parent{ //code}class Child extends Parent{ //code}

• Plusieurs héritages – Un enfant peut dériver de plusieurs parents. Jusqu’à JDK 1.,7, l’héritage multiple n’était pas possible en java grâce à l’utilisation de classes. Mais à partir de JDK 1.8, l’héritage multiple est possible via l’utilisation d’interfaces avec des méthodes par défaut.

  l’héritage Multiple par l’utilisation d’interfaces est toujours possible en Java.

  interface MyInterface1{ }interface MyInterface2{ }class MyClass implements MyInterface1, MyInterface2{}

• héritage multiniveau – il fait référence à l’héritage entre plus de trois classes de telle sorte qu’une classe enfant agira comme classe parent pour une autre classe enfant.

  dans l’exemple donné, B est la classe parent ainsi que la classe enfant.,

  class A{}class B extends A{}class C extends B{}

• héritage hiérarchique – il fait référence à l’héritage lorsqu’il y a une super classe et plusieurs sous-classes étendant la super classe.

  class A{}class B extends A{}class C extends A{}class D extends A{}

• héritage Hybride – c’est une combinaison de deux types d’héritage ou plus. Ainsi, lorsque la relation entre les classes contient un héritage de deux types ou plus, nous disons que les classes implémentent un héritage hybride.

  interface A{}interface B extends A{}class C implements A{}class D extends C impements B{}

2.4., Polymorphisme

le polymorphisme est la capacité par laquelle nous pouvons créer des fonctions ou des variables de référence qui se comportent différemment dans un contexte programmatique différent. Il est souvent appelé un nom avec de nombreuses formes.

Par exemple, dans la plupart des langages de programmation, l’opérateur '+' est utilisé pour ajouter deux nombres ainsi que pour concaténer deux chaînes. En fonction du type de variables, l’opérateur modifie son comportement. Il est connu sous le nom de surcharge de l’opérateur.

En Java, le polymorphisme est essentiellement considéré en deux types:

2.4.1., Polymorphisme à la compilation

dans le polymorphisme à la compilation, le compilateur peut lier les méthodes appropriées aux objets respectifs au moment de la compilation car il dispose de toutes les informations nécessaires et sait quelle méthode appeler pendant la compilation du programme.

Il est souvent appelé la liaison statique ou liaison précoce.

En Java, il est réalisé avec l’utilisation de la surcharge de méthode. Dans la surcharge de méthode, les paramètres de méthode peuvent varier en fonction d’un nombre, d’un ordre ou des types de paramètre.

2.4.2., Polymorphisme d’exécution

Dans polymorphisme d’exécution, l’appel à une méthode surchargée est résolu dynamiquement à l’exécution. L’objet sur lequel la méthode sera exécutée, est déterminé au moment de l’exécution – généralement en fonction de l’utilisateur contexte.

Il est souvent appelé la liaison dynamique ou la méthode de remplacement. Nous avons peut-être entendu avec le nom dynamique de la méthode d’expédition.

dans le polymorphisme d’exécution, nous avons généralement une classe parent et au minimum une classe enfant. Dans une classe, nous écrivons une instruction pour exécuter une méthode présente dans la classe parent et la classe enfant.,

l’appel de méthode est donné en utilisant la variable du type de classe parent. L’instance réelle de la classe est déterminée lors de l’exécution car une variable de type de classe parent peut également stocker la référence à l’instance de la classe parent ainsi qu’à la classe enfant.

En savoir plus : polymorphisme en java

Concepts mineurs

En dehors des 4 blocs de construction de la POO ci-dessus, nous avons quelques autres concepts qui jouent un rôle important dans la construction de l’ensemble de la compréhension.

avant d’aller plus loin, nous comprendrons le terme module., En programmation générale, un module fait référence à une classe ou à une sous-application qui exécute des fonctionnalités uniques. Dans L’application RH, une classe peut effectuer diverses fonctions telles que l’envoi d’e-mails, générer un bulletin de salaire, calculer l’âge de l’employé, etc.

3.1. Couplage

le Couplage est la mesure du degré d’interdépendance entre les modules. Le couplage fait référence à la force avec laquelle un élément logiciel est connecté à d’autres éléments. Un bon logiciel aura un faible couplage.

cela signifie qu’une classe doit effectuer une tâche unique ou uniquement des tâches indépendantes des autres tâches. E. g., une classeEmailValidator validera uniquement l’e-mail. De même, la classeEmailSender enverra uniquement des e-mails.

Si nous incluons les deux fonctonalités dans une seule classeEmailUtils alors c’est un exemple de couplage serré.

3.2. Cohésion

la cohésion est la colle interne qui maintient le module ensemble. Une bonne conception logicielle aura une cohésion élevée.

cela signifie qu’une classe/module doit inclure toutes les informations nécessaires pour remplir sa fonction sans aucune dépendance., Par exemple, une classe EmailSender devrait pouvoir configurer le serveur SMTP, accepter l’email, le sujet et le contenu de l’expéditeur. Fondamentalement, il devrait se concentrer sur l’envoi de courriels uniquement.

L’application ne doit pas utiliser EmailSender pour toute autre fonction autre que l’envoi d’e-mail. Une faible cohésion entraîne des classes monolithiques difficiles à maintenir, à comprendre et réduit la réutilisabilité.

3.3. Association

Association fait référence à la relation entre les objets qui ont un cycle de vie indépendant sans propriété.,

prenons un exemple d’un enseignant et de l’élève. Plusieurs étudiants peuvent s’associer à un seul enseignant et un seul étudiant peut s’associer à plusieurs enseignants, mais les deux ont leur propre cycle de vie.

les Deux peuvent être créés et supprimés de manière indépendante et donc, quand un enseignant quitte l’école, nous n’avons pas besoin de supprimer tous les étudiants, et lorsqu’un élève quitte l’école, nous n’avons pas besoin de supprimer tous les enseignants.

3.4. Agrégation

L’Association fait référence à la relation entre les objets qui ont un cycle de vie indépendant avec la propriété., C’est entre les classes enfant et parent où les objets enfant ne peuvent pas appartenir à un autre objet parent.

prenons un exemple d’un téléphone portable et un téléphone cellulaire de la batterie. Une seule batterie peut appartenir à un seul téléphone à la fois. Si le téléphone cesse de fonctionner et que nous le supprimons de notre base de données, la batterie du téléphone ne sera pas supprimée car elle peut toujours être fonctionnelle. Ainsi, dans l’agrégation, bien qu’il y ait propriété, les objets ont leur propre cycle de vie.

3.5. Composition

La Composition fait référence aux relations lorsque les objets n’ont pas de cycle de vie indépendant., Si l’objet parent est supprimé, tous les objets enfants seront également supprimés.

Par exemple, la relation entre les questions et les réponses. Des questions simples peuvent avoir plusieurs réponses, mais les réponses ne peuvent appartenir à plusieurs questions. Si nous supprimons une question, toutes ses réponses seront automatiquement supprimées.

les Meilleures pratiques

4.1. Favoriser la composition par rapport à l’héritage

L’héritage et la composition, tous deux favorisent la réutilisabilité du code. Mais l’utilisation de la composition est préférée à l’héritage.,

une implémentation de composition over inheritance commence généralement par la création de diverses interfaces représentant les comportements que le système doit présenter. Les Interfaces permettent un comportement polymorphe. Les Classes implémentant les interfaces identifiées sont construites et ajoutées aux classes de domaine métier selon les besoins. Ainsi, les comportements du système sont réalisés sans héritage.

4.2. Programme à une interface, pas à l’implémentation

cela conduit à un code flexible qui peut fonctionner avec n’importe quelle nouvelle implémentation de l’interface., Nous devrions viser à utiliser les interfaces comme variables, comme types de retour d’une méthode ou comme type d’argument de méthodes.

les Interfaces agissent comme des types de superclasse. De cette façon, nous pouvons créer plus de spécialisations de l’interface à l’avenir sans modifier le code existant.

4.3. DRY (ne vous répétez pas)

N’écrivez pas de code en double, utilisez plutôt L’Abstraction pour abstraire les choses communes au même endroit.

en règle générale, si vous écrivez le même morceau de code à deux endroits – envisagez d’extraire dans une fonction distincte et appelez la fonction aux deux endroits.

4.4., Encapsuler les changements

tous les logiciels obtiennent des changements au fil du temps. Donc, encapsulez le code que vous attendez ou soupçonnez d’être modifié à l’avenir.

en Java, utilisez les méthodesprivate pour masquer de telles implémentations aux clients afin que lorsque vous apportez une modification, le client ne soit pas obligé d’apporter des modifications à son code.

l’Utilisation de modèles de conception est également recommandé de réaliser l’encapsulation. Par exemple, le modèle de conception d’usine encapsule le code de création d’objet et offre la flexibilité d’introduire un nouveau type plus tard sans impact sur les clients existants.

4.5., Principe de Responsabilité Unique

C’est L’un des principes solides de la conception de la classe POO. Il souligne qu’une classe devrait avoir une et une seule responsabilité.

en d’autres termes, nous devrions écrire, Modifier et maintenir une classe dans un seul but. Cela nous donnera la flexibilité d’apporter des changements à l’avenir sans se soucier des impacts des changements pour une autre entité.

4.6. Principe Open Closed

Il souligne que les composants logiciels doivent être ouverts pour l’extension, mais fermés pour la modification.,

cela signifie que nos classes doivent être conçues de telle sorte que chaque fois que d’autres développeurs veulent changer le flux de contrôle dans des conditions spécifiques dans l’application, tout ce dont ils ont besoin pour étendre notre classe et remplacer certaines fonctions et c’est tout.

Si d’autres développeurs ne sont pas en mesure de concevoir le comportement souhaité en raison des contraintes imposées par notre classe, alors nous devrions reconsidérer la modification de notre classe.

Il y a beaucoup d’autres concepts et définitions dans tout le paradigme OOPs que nous apprendrons dans d’autres tutoriels.

Heureux d’Apprendre !!