Concept d'encapsulation Java non clair

Oui, cela peut parfois être un peu déroutant. Allons étape par étape: D'abord, vous devez comprendre

• qu'est-Ce que l'encapsulation et pourquoi est-il utilisé.?

L'encapsulation est l'un des quatre concepts fondamentaux de POO .L'encapsulation est la technique consistant à rendre les champs d'une classe privés et à fournir un accès aux champs via des méthodes publiques. Si un champ est déclaré privé, il n'est accessible à personne en dehors de la classe, cachant ainsi le champs au sein 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 le code et les données d'être accédés de manière aléatoire 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 l'encapsulation est la possibilité de modifier notre code implémenté sans casser le code des autres qui utilisent notre code. Avec cette l'encapsulation de la fonctionnalité donne la maintenabilité, la flexibilité et l'extensibilité à notre code.

Prenez 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(aka getters et setters). Maintenant, vous pourriez demander,

• Pourquoi devriez-vous utiliser des accesseurs..? Il existe en fait de nombreuses bonnes raisons d'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 l'obtention et 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 accessor, on peut facilement ajouter une logique comme mettre en cache certaines données, les initialiser paresseusement plus tard. De plus, on peut déclencher un événement de modification de propriété 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 accessor.

Il y a tellement de tutoriels et d'explications sur comment et quels sont-ils. Google eux.

Quant à votre problème actuel:

1. Vous avez deux classes différentes, chacune avec un principal. Ce qui est mauvais. Ils auront des propriétés différentes.
2. Le changement de code suggéré par @Subhrajyoti Majumder est le bon. Vérifiez la réponse pour résoudre le problème.

Dans le en attendant, lisez

• l'Encapsulation
• Accesseurs

Pour une meilleure compréhension des concepts. Espérons que cela aide. :)

Il semble que vous exécutez deux classes différentes séparément et en supposant que les modifications apportées aux attributs lorsque vous exécutez EmployeeTest se refléteront dans Employee run. Notez que les modifications se refléteront dans la même instance JRE. Excusez-moi au cas où j'aurais mal compris votre problème.

EDIT: Selon l'entrée de l'utilisateur. Voici le code comment vous pouvez accéder et mettre à jour les valeurs 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);
    }

}

public static les champs sont associés à la classe et non à l'objet, ils rompent la règle d'encapsulation de l'objet.

Employee classe avec deux encapsulé champ 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 qui empêche le code et les données d'être accédés de manière aléatoire 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.

L'encapsulation en Java est la technique consistant à rendre les champs d'une classe privés et à fournir un accès aux champs via des méthodes publiques.

Si un champ est déclaré privé, il n'est accessible à personne en dehors de la classe, ainsi cacher les champs à l'intérieur de la classe. Pour cette raison, l'encapsulation est également appelée masquage de données .

Exemple en temps réel: voitures et propriétaires.Toutes les fonctions des voitures sont encapsulées avec les propriétaires. Par conséquent, personne d'autre Ne peut y accéder..

Voici le code de 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");
                }
}

Le concept d'encapsulation est une technique de conception 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'appliquer 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é. Le seul moyen pour les clients d'y accéder est via la méthode getName (). Cela signifie que ces attributs sont encapsulés par la classe. Notez également qu'en déclarant les attributs comme finaux 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 l'état est encapsulé puisque l'accès à celui-ci se fait uniquement via des accesseurs et des modificateurs. Noter comment l'encapsulation peut vous aider à protéger les invariants de l'état de l'objet. En limitant les modifications via une méthode, vous obtenez un meilleur contrôle de la façon dont l'état de l'objet est modifié, en ajoutant des validations pour vous assurer que toutes les modifications sont cohérentes avec la spécification de la classe.

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;
}

Encapsulation =VARIABLES(let private a,b,c)+ MÉTHODES(setA&getA,setB&getB....) nous pouvons encapsuler en utilisant le modificateur privé. considérons votre création d'une variable publique et d'une variable privée dans votre classe... dans le cas où vous devez donner ces variables à une autre classe en lecture seule(elles seules peuvent voir et utiliser ne pas pouvoir modifier), il n'y a aucune possibilité avec des variables ou des méthodes publiques, mais nous pouvons le faire en privé en fournissant la méthode get. donc Votre classe private variables ou les méthodes sont sous votre contrôle. mais EN public, il n'y a aucune chance....je pense que vous pouvez comprendre.

Bien sûr, le changement sur un objet n'aura pas d'impact sur un autre objet. supposons que vous ayez un élève de classe et que tous les enfants de votre école soient des objets. si l'on quitte l'école, cela ne signifie pas que tous les autres élèves (objet de la classe des élèves) devraient également quitter l'école.

L'encapsulation est le concept d'avoir vos variables de classe comme privées , de sorte que personne ne puisse jouer directement avec vos membres de données du monde extérieur. mais vous fournissez le public méthode, pour laisser le monde extérieur jouer avec votre membre de données, la façon dont vous le souhaitez. le bel exemple de codage de l'encapsulation 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 comptage statique, pour compter le nombre d'objets de classe student. (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, outer world peut jouer avec vos attributs de classe comme:

student s = new student();
s.name = "xyz";

Supposons que vous ne vouliez pas laisser le monde extérieur changer votre attribut de nom d'objet. ensuite, vous devez 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 ne pouvez obtenir que 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 l'autorisation d'accéder aux membres privés.

La raison pour laquelle vous obtenez la sortie "print employe details:0 null" lors de l'exécution de la classe Employee est que ces variables ne sont pas initialisées. Autrement dit, 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 la prochaine fois qu'elle sera exécutée. Considérez chaque exécution d'un programme Java comme une "table rase".

Sur le point d'encapsulation, vous ne devriez vraiment pas utiliser le static mot-clé. Si vous optez pour l'encapsulation, consultez l'autre réponse à cette question, il a un bon exemple de code à utiliser.

L'encapsulation est un concept de POO. La classe est considérée comme une capsule contenant des données + comportement. Les données devraient être privées qui doivent être accessibles qu'à l'aide de méthodes publiques appelées accesseurs et mutateurs. Vous pouvez consulter ce tutoriel encapsulation pour plus d'informations sur ce concept.

L'ENCAPSULATION est un mécanisme d'encapsulation de méthodes et de variables ensemble en une seule unité. par exemple capsule c'est-à-dire mélangé de plusieurs médicaments.

Les variables d'une classe seront masquées des autres classes car elles seront déclarées privées et ne seront accessibles que via les méthodes de leur classe actuelle

Pour réaliser l'encapsulation en Java - * Déclarer les variables d'une classe comme privées. * Fournir des méthodes setter et getter publiques pour modifier et afficher les valeurs des variables. * Le La classe Java Bean est l'exemple de classe entièrement encapsulée.

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 après la fin du programme.

2)Par conséquent, si vous pensez qu'une fois si vous donnez 10 à empid , il devrait toujours être 10, ce n'est pas le cas, car empid est juste une référence à une mémoire qui stocke "10".

3) Donc, par désallocation, je veux dire que empid ne pointe plus vers la zone mémoire stockage 10, après la fin du programme

4)chaque fois que vous exécutez un nouveau programme , l'empid pointe maintenant vers une autre zone de mémoire , et cette mémoire est allouée à la valeur par défaut en fonction du type de données respectif,en cas de variable statique. par conséquent toujours 0 et null.