Encapsulation en Java

Salut! Nous allons consacrer la leçon d'aujourd'hui à Encapsulation en Java et commencer par des exemples dès le départ :) Ici, vous avez un distributeur de soda ordinaire . J'ai une question pour vous : comment ça marche ? Essayez de donner une réponse détaillée : d'où vient le soda ? Comment la température interne est-elle maintenue ? Où la glace est-elle stockée ? Comment la machine sait-elle quel sirop ajouter ? Vous n'avez probablement pas de réponses à ces questions. D'accord, peut-être que tout le monde n'utilise pas ces machines. Ils ne sont pas très populaires à l'heure actuelle. Essayons un autre exemple. Quelque chose que vous utilisez certainement plusieurs fois par jour. Ah j'ai une idée ! Dites-moi comment le moteur de recherche Googletravaux. Comment recherche-t-il exactement des informations sur les mots que vous saisissez ? Pourquoi ces résultats sont-ils en tête et pas d'autres ? Même si vous utilisez Google tous les jours, vous ne le savez probablement pas. Mais cela n'a pas d'importance. Après tout, ce n'est pas quelque chose que vous devez savoir. Vous pouvez utiliser un moteur de recherche sans vous demander exactement comment il fonctionne. Vous pouvez acheter du soda à partir d'une machine sans savoir comment elle est construite. Vous pouvez conduire une voiture sans vous plonger dans le fonctionnement du moteur à combustion interne et sans même connaître la physique du lycée. Tout cela est possible grâce à l'un des grands principes de la programmation orientée objet : l'encapsulation. En lisant différents articles sur le sujet, vous avez dû rencontrer deux concepts de programmation répandus : l'encapsulation et le masquage d'informations. Il se trouve que différentes personnes comprennent le mot ' encapsulation' pour signifier différentes choses. Nous allons déchiffrer les deux termes afin que vous ayez une compréhension complète. En programmation, le sens originel del'encapsulation combinait des données et des méthodes pour travailler avec ces données dans un seul package ("capsule"). En Java, le package d'encapsulation est la classe . La classe contient à la fois des données (champs) et des méthodes pour travailler avec ces données. Cela peut vous sembler évident, mais tout s'arrange différemment dans d'autres paradigmes de programmation. Par exemple, dans la programmation fonctionnelle, les données sont strictement séparées des opérations sur les données. Dans la programmation orientée objet (POO), les programmes sont constitués de capsules (classes) composées à la fois de données et de fonctions permettant de travailler avec des données.

Parlons maintenant de la dissimulation d'informations

Comment utiliser toutes sortes de mécanismes complexes sans comprendre comment ils sont construits ou comment ils fonctionnent ? C'est simple : leurs créateurs ont fourni des interfaces simples et pratiques. Sur une machine à soda, l'interface est constituée des boutons du panneau avant. Un bouton vous permet de choisir la taille de bonnet. Vous choisissez le sirop avec un deuxième bouton. Un troisième est chargé d'ajouter de la glace. Et c'est tout ce que vous devez faire. Peu importe à quoi ressemble la machine à l'intérieur. L'important est qu'il soit conçu pour que l'utilisateur obtienne du soda en appuyant sur trois boutons. La même chose s'applique à une voiture. Peu importe ce qui se passe à l'intérieur. L'important est que lorsque vous appuyez sur la pédale de droite, la voiture avance et lorsque vous appuyez sur la pédale de gauche, la voiture ralentit. C'est l'essence même de la dissimulation d'informations. Tout d'un programme' s 'entrailles' sont cachés à l'utilisateur. Ces informations sont superflues ou inutiles pour l'utilisateur. L'utilisateur a besoin d'un résultat final, pas d'un processus interne. A titre d'exemple, regardons leClasse de véhicule :

public class Vehicle {

   public void gas() {

       /* Some complicated things happen inside a car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside a car.
       As a result, it slows down */
   }

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

C'est ainsi que l'implémentation est cachée dans un programme Java. Comme dans la vraie vie : l'utilisateur dispose d'une interface (méthodes). Dans un programme, si vous avez besoin d'une voiture pour effectuer une action, il vous suffit d'appeler la méthode souhaitée. Ce qui se passe à l'intérieur de ces méthodes est superflu. Ce qui compte, c'est que tout fonctionne comme il se doit. Ici, nous avons parlé du masquage d'implémentation. Java cache également des données. Nous en avons parlé dans la leçon sur les getters et les setters, mais un rappel ne fera pas de mal. Par exemple, nous avons une classe Cat :

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

Peut-être vous souvenez-vous d'une leçon passée quel est le problème avec cette classe ? Sinon, rappelons-le. Le problème est que ses données (champs) sont ouvertes à tous. Un autre programmeur pourrait facilement créer un chat sans nom avec un poids de 0 et un âge de -1000 ans :

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

Dans cette situation, vous pouvez suivre attentivement si l'un de vos collègues crée des objets avec un état invalide, mais il serait bien préférable d'éliminer même la possibilité de créer ces objets invalides. Nous réalisons la dissimulation des données à l'aide de :

1. modificateurs d'accès ( privé, protégé, package par défaut ) ;
2. getters et setters.

Nous les utilisons pour vérifier si quelqu'un essaie de donner au chat un âge négatif. Comme nous l'avons dit précédemment, les auteurs de divers articles sur l'encapsulation font en fait référence à l'encapsulation (combinant des données et des méthodes) ou à la dissimulation d'informations, ou aux deux. Java a les deux mécanismes (ce n'est pas nécessairement le cas dans d'autres langages POO), donc la dernière option est la plus correcte.

L'encapsulation nous offre plusieurs avantages importants :

1. Surveillance de l'état correct de l'objet. Nous en avons donné des exemples plus haut : grâce au setter et au modificateur privé , nous avons sécurisé notre programme contre les chats de poids 0.


2. Interface conviviale. Nous ne laissons que les méthodes exposées à l'utilisateur. L'utilisateur doit simplement les appeler pour obtenir un résultat. Et il n'est pas nécessaire de se plonger dans les détails de leur fonctionnement.


3. Les changements de code n'affectent pas les utilisateurs. Nous apportons toutes les modifications à l'intérieur des méthodes. Cela n'affecte pas les utilisateurs : ils ont écrit vehicle.gas() pour appliquer le gaz, et c'est ce qu'ils continueront à faire. Le fait que nous ayons changé quelque chose à l'intérieur de la méthode gas() reste invisible : comme avant, ils obtiennent simplement le résultat requis.