Le concept d'encapsulation Java n'est pas clair
C'est une question fondamentale mais je ne comprends toujours pas le concept d'encapsulation. Je ne comprenais pas comment changer les propriétés de class d'autres classes.Parce que, lorsque nous essayons de définir la valeur d'instance publique de class, nous devons créer un objet de cette classe, puis définir la valeur. meme memory.so meme si nous changeons la valeur d'instance, cela n'aura aucun impact sur aucun autre objet.
Même si j'essaie de changer en utilisant une valeur d'instance publique statique, je ne peux pas non plus changer la valeur de la propriété de classe.
Exemple donné ci-dessous
// Employee class
public class Employee {
public static int empid;
public static String empname;
public static void main(String[] args) {
System.out.println("print employe details:"+empid+" "+empname);
}
// EmployeeTest class
public class EmployeeTest {
public static void main(String[] args) {
Employee e = new Employee();
e.empid=20;
e.empname="jerry";
Employee.empid=10;
Employee.empname="tom";
}
}
}
Chaque fois que je cours Employee class j'obtiens la même valeur
print employe details:0 null
Bien que je ne suive pas le concept d’encapsulation et que je ne sois pas en mesure de modifier la valeur d’instance publique de la classe employé.
Oui, cela peut être un peu déroutant parfois. Allons-y pas à pas: il faut d’abord comprendre
- Qu'est-ce que l'encapsulation et pourquoi est-il utilisé?
L'encapsulation est l'un des quatre concepts fondamentaux OOP. L'encapsulation est la technique de rendre les champs d'une classe privée et de leur donner accès via des méthodes publiques. Si un champ est déclaré privé, il ne peut être consulté par personne en dehors de la classe, masquant ainsi les champs de la classe. Pour cette raison, l’encapsulation est également appelée masquage de données.
L'encapsulation peut être décrite comme une barrière protectrice qui empêche l'accès aléatoire au code et aux données par un autre code défini en dehors de la classe. L'accès aux données et au code est étroitement contrôlé par une interface.
Le principal avantage de de l'encapsulation est la possibilité de modifier notre code implémenté sans rompre le code de ceux qui utilisent notre code. Avec cette fonctionnalité, Encapsulation donne à notre code une maintenabilité, une flexibilité et une extensibilité.
Prenons un petit exemple:
public class EncapTest{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public String getIdNum(){
return idNum;
}
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
public void setIdNum( String newId){
idNum = newId;
}
}
Les méthodes ci-dessus sont appelées accesseurs (getters et setters). Maintenant, vous pourriez demander,
- Pourquoi devriez-vous utiliser des accesseurs ..? Il y a en fait beaucoup de bonnes raisons pour envisager d'utiliser des accesseurs plutôt que d'exposer directement les champs d'une classe. Getter et Setters rendent les API plus stables.
Par exemple, considérons un champ public dans une classe accessible par d'autres classes. Maintenant, plus tard, vous voulez ajouter une logique supplémentaire lors de la récupération et de la définition de la variable. Cela aura un impact sur le client existant qui utilise l'API. Ainsi, toute modification de ce champ public nécessitera une modification de chaque classe qui le réfère. Au contraire, avec les méthodes d’accesseurs, on peut facilement ajouter une logique telle que mettre en cache certaines données, l’initialiser paresseusement plus tard. De plus, il est possible de déclencher un événement de propriété modifiée si la nouvelle valeur est différente de la valeur précédente. Tout cela sera transparent pour la classe qui obtient de la valeur en utilisant la méthode d'accès.
Il y a tellement de tutoriels et d'explications sur comment et quoi sont-ils. Google eux.
Quant à votre problème actuel:
- Vous avez deux classes différentes, chacune avec un principal. C'est faux. Ils auront des propriétés différentes.
- Le changement de code suggéré par @Subhrajyoti Majumder est le bon. Cochez la réponse pour résoudre le problème.
En attendant, lisez sur
pour une meilleure compréhension des concepts. J'espère que ça aide. :)
Il semble que vous exécutiez deux classes différentes séparément et en supposant que les modifications apportées aux attributs lorsque vous exécutez EmployeeTest seront reflétées dans Employee run. Notez que les modifications seront reflétées dans la même instance de JRE. Excusez-moi au cas où j'aurais mal compris votre problème.
EDIT: Selon l'entrée de l'utilisateur. Voici le code pour accéder et mettre à jour les valeurs des membres statiques:
class Employee {
public static int empid;
public static String empname;
public static void main(String[] args) {
System.out.println("print employe details:" + empid + " " + empname);
}
}
// EmployeeTest class
public class EmployeeTest {
public static void main(String[] args) {
Employee e = new Employee();
e.empid = 20;
e.empname = "jerry";
Employee.empid = 10;
Employee.empname = "tom";
Employee.main(null);
}
}
Les champs public static sont associés à une classe et non à un objet, ils enfreignent la règle d'encapsulation de l'objet.
Employee classe avec deux champs encapsulés empid & empname.
public class Employee {
private int empid;
private String empname;
public int getEmpid(){
return this.empid;
}
public void setEmpid(int empid){
this.empid = empid;
}
...
}
public class EmployeeTest {
public static void main(String[] args) {
Employee e = new Employee();
e.setempId(1);
Employee e1 = new Employee();
e1.setempId(2);
}
}
Documentation pour une meilleure compréhension de l'encapsulation
L'encapsulation peut être décrite comme une barrière de protection empêchant l'accès au code et aux données par d'autres codes définis en dehors de la classe.L'accès aux données et au code est étroitement contrôlé par une interface.
L'encapsulation en Java est la technique permettant de rendre les champs d'une classe privés et de fournir un accès aux champs via des méthodes publiques.
Si un champ est déclaré privé, personne ne se trouvant en dehors de la classe ne pourra y accéder, masquant ainsi les champs de la classe. Pour cette raison, l'encapsulation est également appelée masquage des données.
Exemple en temps réel: voitures et propriétaires. _ Tous les fonctions de voitures sont encapsulés avec les propriétaires. Par conséquent, personne d'autre ne peut y accéder.
Le code ci-dessous correspond à cet exemple.
public class Main {
public static void main(String[] args) {
Owner o1=new Car("SONY","Google Maps");
o1.activate_Sunroof();
o1.getNavigationSystem();
o1.getRadioSytem();
}
}
//Interface designed for exposing car functionalities that an owner can use.
public interface Owner {
void getNavigationSystem();
void getRadioSytem();
void activate_Sunroof();
}
/*
Car class protects the code and data access from outside world access by implementing Owner interface(i.e, exposing Cars functionalities) and restricting data access via private access modifier.
*/
public class Car implements Owner {
private String radioSystem;
private String gps;
public Car(String radioSystem, String gps) {
super();
this.radioSystem = radioSystem;
this.gps = gps;
}
public String getRadioSystem() {
return radioSystem;
}
public void setRadioSystem(String radioSystem) {
this.radioSystem = radioSystem;
}
public String getGps() {
return gps;
}
public void setGps(String gps) {
this.gps = gps;
}
@Override
public void getNavigationSystem() {
System.out.println("GPS system " + getGps() + " is in use...");
}
@Override
public void getRadioSytem() {
System.out.println("Radio system " + getRadioSystem() + " activated");
}
@Override
public void activate_Sunroof() {
System.out.println("Sunroof activated");
}
}
encapsulation = VARIABLES (laissez private a, b, c) + METHODES (setA & getA, setB & getB ....) nous pouvons encapsuler en utilisant le modificateur private . considérons votre variable publique créée et votre variable privée dans votre classe ... au cas où vous deviez donner ces variables à une autre classe en lecture seule (seuls ceux-ci peuvent voir et utiliser ne peuvent pas être modifiés), il n’ya aucune possibilité avec des variables ou méthodes publiques, mais nous pouvons faire cela en privé en fournissant la méthode get . Ainsi, les variables ou méthodes privées de votre classe sont sous votre contrôle. mais en public il n'y a aucune chance .... je pense que vous pouvez comprendre.
Encapsulation means combining data and code together(class). The main purpose of encapsulation is you would have full control on data by using the code.
class Encap{
private int amount;
public void setAmount(int amount)
{
this.amount = amount;
}
Here, you can set the amount using the setAmount method, but value should be more than 100. So, i have the control on it.
public void setAmount(int amount)
{
if(amount>100)
this.amount = amount;
}
Le concept d’encapsulation est une technique design qui se rapporte à la dissimulation d’informations. Le principe sous-jacent est de fournir un accès protégé aux attributs de classe, via une interface bien conçue. Le but de l'encapsulation est d'imposer les invariants de la classe.
Pour suivre votre exemple, considérons l'interface de cette classe:
class Employee
private final String firstName;
private final String lastName;
public Employee(final firstName, final lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getName() {
return firstName + " " + lastName;
}
}
Notez qu'en déclarant les attributs comme privés, cette classe empêche les clients d'accéder directement à l'état des instances d'objet employé. Les clients ne peuvent y accéder que via la méthode getName (). Cela signifie que ces attributs sont encapsulés par la classe. Notez également qu'en déclarant les attributs en tant que final et en les initialisant dans le constructeur, nous créons une classe effectivement immuable, c'est-à-dire dont l'état ne peut pas être modifié après la construction.
Une autre implémentation serait la suivante:
class Employee
private String firstName;
private String lastName;
public Employee(firstName, lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getName() {
return firstName + " " + lastName;
}
public String setName(String firstName, String lastName) {
if (firstName == null) {
throw new IllegalArgumentException("First name cannot be null");
}
if (lastName == null) {
throw new IllegalArgumentException("Last name cannot be null");
}
this.firstName = firstName;
this.lastName = lastName;
}
}
Dans cet exemple, l'objet n'est pas immuable, mais son état est encapsulé, car l'accès ne s'effectue que par l'intermédiaire d'accesseurs et de modificateurs. Notez ici comment l'encapsulation peut vous aider à protéger les invariants de l'état de l'objet. En contraignant les modifications via une méthode, vous obtenez un meilleur contrôle de la modification de l'état de l'objet, en ajoutant des validations pour vous assurer que les modifications sont cohérentes avec la spécification de la classe.
bien sûr, les modifications sur un objet n'auront pas d'impact sur un autre objet. Supposons que vous avez une classe étudiant et que tous les enfants de votre école sont des objets. si l’un quitte l’école, cela ne veut pas dire que tous les autres élèves (objet de la classe d’élèves) doivent également quitter l’école.
L'encapsulation est le concept qui consiste à avoir vos variables de classe sous la forme private, de sorte que personne ne puisse jouer directement avec vos données membres du monde extérieur. mais vous fournissez la méthode public, pour laisser le monde extérieur jouer avec vos données membres, comme vous le souhaitez. l'exemple d'encodage de Nice est donné ci-dessus par Subhrajyoti Majumder.
(les membres statiques sont les mêmes pour tous les objets de la classe. Par exemple: variable de décompte statique, pour compter le nombre d'objets de classe d'élèves. (nombre d'élèves à l'école)).
Modifier comme vous l'avez demandé:
Exemple:
public class student{
public String name;
public student() {}
}
et dans votre fonction principale, le monde extérieur peut jouer avec les attributs de votre classe tels que:
student s = new student();
s.name = "xyz";
supposons que vous ne vouliez pas laisser le monde extérieur modifier votre attribut de nom d'objet. alors vous devriez rendre le nom 'name' privé, et fournir une méthode publique pour afficher uniquement le nom (get).
Exemple:
public class student{
private String name;
public student() {}
public String getName(){
return this.name;
}
}
et maintenant, dans votre méthode principale, vous pouvez uniquement obtenir l'objet name et ne pouvez pas le définir sur une nouvelle valeur, comme vous pourriez le faire dans le premier exemple.
student s = new student();
String sname = s.getName();
et si vous essayez:
s.name = "newname";
le compilateur ne vous permettra pas cela. puisque vous n'avez pas la permission d'accéder aux membres privés.
Voulez-vous dire que la valeur de empid devrait être 10 et empname tom au lieu de 0 et null, Si oui, alors:
1) La mémoire des variables est allouée au moment de l'exécution et également désallouée une fois le programme terminé.
2) Par conséquent, si vous pensez qu'une fois si vous donnez 10 à empid, il devrait toujours être 10, il n'en est rien, car empid est simplement une référence à une mémoire qui stocke "10".
3) Donc, par désallocation, je veux dire qu'empid ne pointe plus vers la zone de mémoire stockant 10, après la fin du programme
4) chaque fois que vous exécutez un nouveau programme, l’empid pointe maintenant sur une autre zone de mémoire et cette mémoire est affectée à la valeur par défaut en fonction du type de données respectif, dans le cas de la variable statique .
ENCAPSULATION est un mécanisme permettant de combiner des méthodes et des variables en une seule unité. par exemple une capsule, c'est-à-dire un mélange de plusieurs médicaments.
les variables d'une classe seront cachées des autres classes car elles seront déclarées privées et ne seront accessibles que par les méthodes de leur classe actuelle
Pour réaliser l’encapsulation en Java − * Déclarez les variables d’une classe comme privées. classe encapsulée.
La raison pour laquelle vous obtenez le résultat "Détails sur les employés d'impression: 0 null" lors de l'exécution de la classe Employee est due au fait que ces variables ne sont pas initialisées. En d'autres termes, vous ne leur attribuez aucune valeur dans la classe Employee.
Quoi que vous fassiez dans la classe EmployeeTest n'affectera pas les valeurs des variables dans Employee lors de sa prochaine exécution. Considérez chaque exécution d’un programme Java comme une "table rase".
En ce qui concerne l’encapsulation, vous ne devriez vraiment pas utiliser le mot clé static. Si vous optez pour l’encapsulation, consultez l’autre réponse à cette question. Elle contient un exemple de code Nice.
L'encapsulation est un concept OOP . La classe est considérée comme une capsule contenant des données + comportement . Les données doivent être privées et ne doivent être accessibles qu'à l'aide de méthodes publiques appelées getters and setters ..__ Vous pouvez vérifier ce tutoriel encapsulation pour plus d’informations sur ce concept.