Concetto di incapsulamento Java non chiaro

Sì, questo può essere un po ' confuso a volte. Andiamo passo dopo passo: in primo luogo, è necessario capire

• Cos'è l'incapsulamento e perché viene utilizzato.?

L'incapsulamento è uno dei quattro concetti fondamentali dell'OOP .L'incapsulamento è la tecnica per rendere i campi in una classe privati e fornire l'accesso ai campi tramite metodi pubblici. Se un campo è dichiarato privato, non è possibile accedervi da nessuno al di fuori della classe, nascondendo così campi all'interno della classe. Per questo motivo, l'incapsulamento è anche indicato come nascondiglio dei dati.

L'incapsulamento può essere descritto come una barriera protettiva che impedisce l'accesso casuale del codice e dei dati da parte di un altro codice definito al di fuori della classe. L'accesso ai dati e al codice è strettamente controllato da un'interfaccia.

Il vantaggio principale di dell'incapsulamento è la possibilità di modificare il nostro codice implementato senza rompere il codice di altri che usano il nostro codice. Con questo caratteristica Incapsulamento dà manutenibilità, flessibilità ed estensibilità al nostro codice.

Fai un piccolo esempio:

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

I metodi di cui sopra sono chiamati Accessors(aka getter e setter). Ora si potrebbe chiedere,

• Perché dovresti usare accessors..? In realtà ci sono molte buone ragioni per considerare l'utilizzo di accessor piuttosto che esporre direttamente i campi di una classe.Getter e Setter rendono le API più stabili.

Ad esempio, si consideri un campo pubblico in una classe a cui si accede da altre classi . Ora in seguito, si desidera aggiungere qualsiasi logica aggiuntiva mentre si ottiene e si imposta la variabile. Ciò avrà un impatto sul client esistente che utilizza l'API. Quindi qualsiasi modifica a questo campo pubblico richiederà modifiche a ciascuna classe a cui si riferisce. Al contrario, con i metodi di accesso, si può facilmente aggiungere una logica come la cache di alcuni dati, inizializzarla pigramente in un secondo momento. Inoltre, è possibile attivare un evento modificato dalla proprietà se il nuovo valore è diverso dal valore precedente. Tutto questo sarà senza soluzione di continuità alla classe che ottiene valore utilizzando il metodo accessor.

Ci sono così tanti tutorial e spiegazioni su come e cosa sono. Cercali su Google.

Per quanto riguarda il tuo problema attuale:

1. Hai due classi diverse, ognuna con una principale. E ' sbagliato. Avranno proprietà diverse.
2. La modifica del codice suggerita da @Subhrajyoti Majumder è quella corretta. Controlla la risposta per risolvere il problema.

Nella nel frattempo, continua a leggere

• Incapsulamento
• Accessori

Per una migliore comprensione dei concetti. Spero che aiuti. :)

Sembra che tu stia eseguendo due classi diverse separatamente e supponendo che le modifiche apportate agli attributi quando esegui EmployeeTest si rifletteranno in Employee run. Si noti che le modifiche si rifletteranno nella stessa istanza JRE. Scusami se ho frainteso il tuo problema.

MODIFICA: Secondo l'input dell'utente. Ecco il codice come è possibile accedere e aggiornare i valori dei membri statici:

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 i campi sono associati alla classe non all'oggetto, interrompono la regola di incapsulamento dell'oggetto.

Employee classe con due campi incapsulati 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);
      }
}

Documentazione per una migliore comprensione dell'incapsulamento

L'incapsulamento

Può essere descritto come una barriera protettiva che impedisce l'accesso casuale del codice e dei dati da parte di altri codici definiti al di fuori della classe. L'accesso ai dati e al codice è strettamente controllato da un'interfaccia.

L'incapsulamento in Java è la tecnica per rendere privati i campi in una classe e fornire l'accesso ai campi tramite metodi pubblici.

Se un campo è dichiarato privato, non è possibile accedervi da nessuno al di fuori della classe, così nascondere i campi all'interno della classe. Per questo motivo, l'incapsulamento è anche indicato come data hiding .

Esempio in tempo reale: auto e proprietari.Tutte le funzioni delle auto sono incapsulate con i proprietari. Quindi, nessun altro può accedervi..

Il seguente è il codice per questo esempio.

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

Il concetto di incapsulamento è una tecnica di design che si relaziona con l'occultamento delle informazioni. Il principio di base è quello di fornire un accesso protetto agli attributi di classe, attraverso un'interfaccia ben progettata. Lo scopo dell'incapsulamento è quello di far rispettare gli invarianti della classe.

Per seguire il tuo esempio considera l'interfaccia di questa 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;
  }
}

Si noti che dichiarando gli attributi come privati questa classe limita i client dall'accesso diretto allo stato di istanze di oggetti dipendenti. L'unico modo per i client di accedervi è tramite il metodo getName (). Ciò significa che quegli attributi sono incapsulati dalla classe. Si noti inoltre che dichiarando gli attributi come finali e inizializzandoli nel costruttore creiamo una classe effettivamente immutabile, ovvero quella il cui stato non può essere modificato dopo la costruzione.

Un'implementazione alternativa sarebbe la seguente:

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

In questo esempio l'oggetto non è immutabile ma il suo lo stato è incapsulato poiché l'accesso ad esso avviene solo tramite accessor e modificatori. Nota qui come l'incapsulamento può aiutarti a proteggere gli invarianti dello stato dell'oggetto. Vincolando le modifiche attraverso un metodo si ottiene un controllo migliore di come viene modificato lo stato dell'oggetto, aggiungendo convalide per assicurarsi che eventuali modifiche siano coerenti con le specifiche della 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 =VARIABILI(let private a,b,c)+ METODI(setA&getA,setB&getB....) possiamo incapsulare usando il modificatore privato. considera la tua variabile pubblica creata e una variabile privata nella tua classe... nel caso in cui tu debba dare quelle variabili a un'altra classe per sola lettura(solo loro possono vedere e usare non in grado di modificare) non c'è possibilità con variabili o metodi pubblici,ma possiamo farlo in privato fornendo il metodo get. quindi le variabili private della tua classe o i metodi sono sotto il tuo controllo. ma IN pubblico non c'è possibilità....penso che tu possa capire.

Naturalmente, la modifica su un oggetto non avrà alcun impatto su un altro oggetto. supponiamo di avere una classe studente e tutti i bambini della tua scuola sono oggetti. se uno lascia la scuola, questo non significa che anche ogni altro studente (oggetto della classe studentesca) dovrebbe lasciare la scuola.

L'incapsulamento è il concetto di avere le variabili di classe come private , in modo che nessuno possa giocare direttamente con i tuoi membri di dati dal mondo esterno. ma tu fornisci al pubblico metodo, per far giocare il mondo esterno con il tuo membro dei dati, nel modo desiderato. il bel esempio di codifica dell'incapsulamento è dato sopra da Subhrajyoti Majumder.

(i membri statici sono uguali per tutti gli oggetti della classe. ad esempio: variabile di conteggio statico, per contare il numero di oggetti della classe student. (numero di studenti a scuola)).

Modifica come richiesto:

Esempio:

public class student{
    public String name;
    public student() {}
 }

E nella tua funzione principale, outer world può giocare con i tuoi attributi di classe as:

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

Supponiamo che tu non voglia lasciare che il mondo esterno cambi il tuo attributo name dell'oggetto. quindi dovresti rendere name 'name' come privato e fornire un metodo pubblico per visualizzare solo il nome (get).

Esempio:

public class student{
    private String name;
    public student() {}
    public String getName(){
      return this.name;
      }
 }

E ora nel tuo metodo principale, puoi solo ottenere l'oggetto name e non puoi impostarlo su un nuovo valore, come potresti fare nel primo esempio.

student s = new student();
String sname = s.getName();

E se ci provi:

s.name = "newname";

Il compilatore non te lo permetterà. dal momento che non hai il permesso di accedere ai membri privati.

Il motivo per cui si ottiene l'output "print employee details:0 null" durante l'esecuzione della classe Employee è perché tali variabili non sono inizializzate. Cioè, non si assegnano valori a loro all'interno della classe Employee.

Qualunque cosa tu faccia all'interno della classe EmployeeTest non influenzerà i valori delle variabili in Employee la prossima volta che viene eseguito. Considera ogni esecuzione di un programma Java una "tabula rasa".

Sul punto di incapsulamento, non dovresti davvero usare il parola chiave static. Se stai andando per l'incapsulamento controlla l'altra risposta a questa domanda, ha un bell'esempio di codice da usare.

L'incapsulamento è un concetto OOP. La classe è considerata come una capsula che contiene dati + comportamento. I dati dovrebbero essere privati e dovrebbero essere accessibili solo utilizzando metodi pubblici chiamati getter e setter. Puoi controllare questo tutorial incapsulamento per maggiori informazioni su questo concetto.

L'INCAPSULAMENTO è un meccanismo di avvolgimento di metodi e variabili insieme come una singola unità. per esempio capsula cioè mista di parecchie medicine.

Le variabili di una classe saranno nascoste da altre classi in quanto saranno dichiarate private e si può accedere solo attraverso i metodi della loro classe corrente

Per ottenere l'incapsulamento in Java - * Dichiarare le variabili di una classe come private. * Fornire metodi setter e getter pubblici per modificare e visualizzare i valori delle variabili. * Il Java Bean classe è l'esempio di classe completamente incapsulato.

Vuoi dire che il valore di empid dovrebbe essere 10 e empname tom invece di 0 e null, se sì allora -:

1)la memoria alle variabili viene allocata in fase di esecuzione e anche deallocata dopo che il programma è terminato.

2)Quindi se pensi che una volta se dai 10 a empid dovrebbe sempre essere 10, non è così , perché empid è solo un riferimento a una memoria che sta memorizzando "10".

3) Quindi per deallocazione, intendo che empid non punta più all'area di memoria memorizzazione 10, dopo che il programma termina

4)ogni volta che si esegue un nuovo programma , l'empid ora punta ad un'altra area di memoria e a tale memoria viene assegnato il valore predefinito in base al rispettivo tipo di dati , in caso di variabile statica. quindi sempre 0 e null.