Menu

Encapsulation en Java: tutoriel complet avec des exemples

  • Principal
  • Autre
  • Encapsulation en Java: tutoriel complet avec des exemples

encapsulation java

Essayez Notre Instrument Pour Éliminer Les Problèmes

Découvrez l'encapsulation en Java avec des exemples, pourquoi nous en avons besoin, ainsi que les méthodes getter et setter associées:

Dans ce didacticiel, nous aborderons un autre concept de POO - «Encapsulation». La POO a quatre piliers, à savoir l'abstraction, l'encapsulation, le polymorphisme et l'héritage.

Alors que l'abstraction est utilisée pour exposer uniquement les détails pertinents à l'utilisateur final, l'encapsulation traite principalement de la sécurité des données. En garantissant la sécurité des données, l'encapsulation protège les données membres contre tout accès indésirable en spécifiant des modificateurs d'accès et regroupe également les données dans une seule unité.

youtube en mp3 plus de 90 minutes

=> Consultez le guide de formation Perfect Java ici.

Encapsulation en Java

Alors, comment pouvons-nous définir l'encapsulation en Java?

Définition de l'encapsulation

«L'encapsulation en Java peut être définie comme un mécanisme par lequel les données et les méthodes qui fonctionnent sur ces données sont encapsulées pour former une seule unité.»

Ce que vous apprendrez:

Qu'est-ce que l'encapsulation en Java

En utilisant l'encapsulation, nous pouvons également masquer les membres de données de classe (variables) des autres classes. Ces variables membres de données sont accessibles indirectement à l'aide des méthodes de la classe dans laquelle elles sont déclarées. Les méthodes à leur tour sont accessibles à l'aide de l'objet de cette classe.

Donc, ce que nous concluons de la définition ci-dessus, c'est que nous avons caché les variables membres de données à l'intérieur d'une classe et avons également spécifié les modificateurs d'accès afin qu'ils ne soient pas accessibles aux autres classes.

Ainsi, l'encapsulation est également une sorte de «masquage de données» bien que plus tard dans le didacticiel, nous verrons que l'encapsulation n'est pas la même chose que le masquage de données.

encapsulation

La figure ci-dessus représente une classe qui est une unité d'encapsulation qui regroupe les données et les méthodes opérant sur ces données dans une seule unité.

L'encapsulation traitant principalement des données, elle est également appelée «encapsulation de données».

Nous pouvons visualiser l'encapsulation comme une capsule médicale. Comme nous le savons tous, le médicament est enfermé dans une capsule médicale. De même, les données et les méthodes sont incluses dans une seule unité dans l'encapsulation.

Ainsi, l'encapsulation agit comme un bouclier protecteur autour des données et empêche les données d'un accès non autorisé par le monde extérieur. En d'autres termes, il protège les données sensibles de notre application.

En Java, il existe deux étapes pour implémenter l'encapsulation. Voici les étapes:

  • Utilisez le modificateur d’accès «privé» pour déclarer les variables des membres de la classe.
  • Pour accéder à ces variables membres privées et modifier leurs valeurs, nous devons fournir respectivement les méthodes publiques getter et setter.

Implémentons maintenant l'exemple de l'encapsulation en Java.

Exemple d'encapsulation Java

//Student_Id and name bundled in a unit 'Student' => encapsulation class Student { private int Student_Id; private String name; //getters, setters for Student_Id and name fields. public int getId() { return Student_Id; } public void setId(int s_id) { this.Student_Id = s_id; } public String getname() { return name; } public void setname(String s_name) { this.name = s_name; } } class Main{ public static void main(String() args) { //create an object of Student class Student s=new Student(); //set fields values using setter methods s.setId (27); s.setname('Tom Lee'); //print values using getter methods System.out.println('Student Data:' + ' Student ID:' + s.getId() + ' Student Name:' + s.getname()); } }

Production:

Sortie - Exemple d

Dans le programme ci-dessus, nous déclarons une classe qui est l'unité d'encapsulation. Cette classe Student a regroupé les données (Student_Id et name) et les méthodes pour lire et définir les valeurs de ces membres dans une seule unité.

Notez les modificateurs d'accès associés aux champs de membre. Les deux champs membres sont privés et ne sont donc pas accessibles en dehors de la classe Student.

Nous fournissons des getters (getId et getname) pour lire les valeurs de ces champs et des méthodes de définition (setId et setname) pour définir les valeurs de ces méthodes. C'est le seul accès dont ils disposent et cela doit également être fait à l'aide de l'objet de classe Student.

Méthodes Getter et Setter

Pour implémenter l'encapsulation en Java, nous rendons les variables de membre de données de la classe privées. Désormais, ces variables privées ne sont accessibles à rien en dehors de la classe, y compris l'objet de classe.

Cela signifie que si nous avons une classe ABC comme suit.

classe ABC {

int age privé;

}

Créons un objet de classe ABC comme suit:

ABC abc = nouveau ABC ();

abc.age = 21; // erreur du compilateur

Donc, dans le code ci-dessus, accéder à la variable privée à l'aide de l'objet de classe entraînera une erreur du compilateur.

Pour accéder aux variables privées et lire leurs valeurs et y définir de nouvelles valeurs, nous avons besoin d'un moyen de le faire. Ainsi Java fournit un moyen d'accéder aux variables privées en utilisant les méthodes getter et setter.

Getter et Setters sont des méthodes publiques que nous pouvons utiliser pour créer, modifier, supprimer ou simplement afficher les valeurs des variables privées.

Le programme ci-dessous est un exemple des méthodes Getter et Setter.

//Account class - private data members bundled with getters and setters class Account { //private data members private long acc_no; private String name,email; private float amount; //public getter and setter methods for each data member public long getAcc_no() { return acc_no; } public void setAcc_no(long acc_no) { this.acc_no = acc_no; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public float getAmount() { return amount; } public void setAmount(float amount) { this.amount = amount; } } public class Main { public static void main(String() args) { //create instance of Account class Account myAcc=new Account(); //set values for data members through setter methods myAcc.setAcc_no(775492842L); myAcc.setName('SoftwareTestingHelp.com'); myAcc.setEmail('sth_account@sth.com'); myAcc.setAmount(25000f); //read data member values through getter methods System.out.println('Account No:' + myAcc.getAcc_no()+' '+'Account Name:' + myAcc.getName()+' '+'Account holder email:' + myAcc.getEmail()+' ' + 'Amount in Account:' + myAcc.getAmount()); } }

Production:

méthodes getter et setter - sortie

Le programme ci-dessus a un compte de classe et il a quatre variables privées liées au compte. Comme tous les membres de données sont privés, nous avons fourni les méthodes getter et setter pour chacune de ces variables.

Dans la méthode principale, nous lisons et définissons les valeurs de ces variables privées à l'aide des méthodes publiques getter et setter accessibles via l'objet de la classe Account.

Masquage des données en Java

Souvent, nous utilisons l’encapsulation et le masquage des données de manière interchangeable. Mais les deux ne sont pas les mêmes. L'encapsulation Java consiste à regrouper les données associées en une seule unité pour garantir une meilleure gestion et une meilleure sécurité des données.

Le masquage des données, en revanche, limite l'accès des membres aux données en masquant les détails de l'implémentation. Bien que l'encapsulation ne soit pas exactement le masquage des données, elle nous fournit le moyen de masquer les données. Le masquage des données est réalisé à l'aide de modificateurs d'accès.

Java fournit quatre modificateurs d'accès.

  • Publique: Accessible à tous.
  • privé: Accessible uniquement au sein de la classe.
  • protégé: Accessible au package contenant et aux sous-classes.
  • défaut: Accessible dans le package.

L'encapsulation regroupe les données dans une seule unité, donc d'une certaine manière, elle masque les données. En outre, cela rend les données privées et donc inaccessibles au monde extérieur. Pour rendre les données privées, nous utilisons le modificateur d'accès private qui est un concept de masquage de données.

Dans le même temps, seuls les détails pertinents sont fournis à l'utilisateur final sans exposer les détails de mise en œuvre qui sont une définition de l'abstraction. Ainsi, nous pouvons voir l'encapsulation comme une combinaison d'abstraction et de masquage de données.

Pourquoi avons-nous besoin d'encapsulation

Plusieurs raisons expliquent pourquoi l'encapsulation est essentielle en Java:

  • L'encapsulation nous permet de modifier le code ou une partie du code sans avoir à changer d'autres fonctions ou code.
  • L'encapsulation contrôle la façon dont nous accédons aux données.
  • Nous pouvons modifier le code en fonction des exigences en utilisant l'encapsulation.
  • L'encapsulation simplifie nos applications.

Questions fréquemment posées

Q # 1) Pourquoi l'encapsulation est-elle utilisée en Java?

Répondre: L'encapsulation en Java est surtout utile pour masquer les données. Ou en d'autres termes, décider de l'accès accordé aux données quant à savoir qui peut y accéder et qui ne le peut pas.

Q # 2) Qu'est-ce que l'encapsulation en POO?

Répondre: L'encapsulation est l'un des piliers importants du langage de programmation orienté objet et traite du regroupement des données et des méthodes opérant sur ces données en une seule unité. Par exemple, une classe en Java est une structure encapsulée. L'encapsulation traite également des décisions concernant l'accès aux données.

Q # 3) Quel est l'avantage de l'encapsulation en Java?

Répondre: Le principal avantage de l'encapsulation en Java est le masquage des données. En utilisant l'encapsulation, nous pouvons permettre au programmeur de décider de l'accès aux données et des méthodes opérant sur ces données. Par exemple, si nous voulons qu'une donnée particulière soit inaccessible à quiconque en dehors de la classe, nous rendons ces données privées.

Q # 4) Quel est le processus d'encapsulation?

Répondre: L'encapsulation est un processus de collecte de données d'un format ou d'un protocole (en termes de mise en réseau) et de les traduire ou de les reformater dans un autre format ou protocole afin que les données soient accessibles à travers les applications ou le réseau tout en étant protégées.

Q # 5) Quelle est la dernière étape de l'encapsulation des données?

Répondre: La dernière étape de l'encapsulation consiste à changer les informations utilisateur en données équivalentes. Ensuite, ces données sont transformées en segments qui sont ensuite transformés en paquets de données. Les paquets de données sont placés dans une trame logique qui peut être transférée d'avant en arrière dans l'environnement logiciel

Conclusion

Ceci conclut notre tutoriel sur l'encapsulation en Java. L'encapsulation est une technique de regroupement des variables membres et des méthodes opérant sur ces données membres en une seule unité. Une classe en Java est un exemple classique d'encapsulation car elle regroupe les données et les méthodes dans une seule unité.

Java réalise l'implémentation de l'encapsulation en rendant tous les membres de données privés, puis en fournissant des méthodes getter et setter qui sont publiques afin que nous puissions lire les valeurs des variables privées et définir de nouvelles valeurs pour ces variables.

=> Visitez ici pour la série exclusive de didacticiels de formation Java.

lecture recommandée

^