Encapsulamento Java

In questo tutorial, imparerai a utilizzare esempi per imparare l'incapsulamento e il mascheramento dei dati in Java.

Encapsulamento Java

L'incapsulamento è una delle funzioni importanti del programmazione orientata agli oggetti. L'incapsulamento significa vincolare campi e metodi in un singolo classe.

Incapsulare campi e metodi simili in una classe aiuta anche a nascondere i dati.

Incapsulamento di campi e metodi

Di solito, l'incapsulamento è il processo di impacchettare codice simile in un unico luogo.

In Java, possiamo incollare insieme i campi e i metodi che operano insieme in un singolo classe. Ad esempio:

class Rectangle {
　　　int length;
　　　int breadth;
　　　public void getArea() {}
}

Nel programma sopra, il metodo getArea() calcola l'area del rettangolo. Per calcolare l'area, ha bisogno della lunghezza (length) e della larghezza (breadth). Pertanto, i campi di dati length, breadth e il metodo getArea() sono messi nella classe Rectangle.

Mascheramento dei dati Java

Il mascheramento dei dati è un metodo per limitare l'accesso ai membri dei dati attraverso l'oscuramento dei dettagli.

L'incapsulamento fornisce anche un metodo per nascondere i dati.

La mascheramento dei dati può essere realizzato tramite modificatori di accesso. In Java ci sono quattro modificatori di accesso:

• pubblico - L'attributo o il metodo decorato è pubblico e può essere acceduto ovunque, tutti gli attributi e i metodi sono pubblici per default

• privato - L'attributo o il metodo decorato è privato e non può essere acceduto al di fuori della classe in cui è dichiarato

• protetta - The attributes or methods modified are protected. It is similar to private, the difference is that it is also accessible in subclasses.

• default - Without any access modifier, usually called the "default access mode". In this mode, access is allowed only within the same package.

For more information, please visitModificatori Java.

Example 1: Using private data hiding

class　Person　{
　　　private　int　age;
　　　public int getAge() {
　　　　　　return age;
　　　}
　　　public　void　setAge(int　age)　{
　　　　　　this.age　=　age;
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Person p1 = new Person();
　　　　　　p1.setAge(24);
　　　　　　System.out.println("My age is " + p1.getAge());
　　　}
}

Output result

My age is 24

In the above example, we have a private field age. Since it is private, it cannot be accessed from outside the class. To access age, we used public methods getAge() and setAge(). These methods are called getter and setter methods.

An error message will appear if you try to access the age field from the Main class.

p1.age = 24; // error: age has private access in Person

Setting age to private can limit unauthorized access from outside the class. This is data hiding.

Example 2: Using protected data hiding

class　Person　{
　protected String profession;
　protected void displayInfo() {
　　　System.out.println("I am a " + profession);
　}
}
class Teacher extends Person {
　　　public static void main(String[] args) {
　　　　　　Teacher t1 = new Teacher();
　　　　　　t1.profession = "teacher";
　　　　　　t1.displayInfo();
　　　}
}

Output result

I am a teacher

In the above program, we created a Person class that contains a protected field profession and a protected method displayInfo().

We have accessed these members from the Teacher class (a subclass of Person).

Why encapsulation?

• In Java, encapsulation helps us keep related fields and methods together, making our code cleaner and easier to read.

• Aiuta a controllare le modifiche ai nostri campi di dati. Consideriamo una situazione in cui vogliamo che il campo age della nostra classe sia un numero non negativo. Qui possiamo rendere age privato e applicare la logica all'interno del metodo setAge(). Ad esempio,

class　Person　{
　　　private　int　age;
　　　public　void　setAge(int　age)　{
　　　　　if　(age　>=　0)　{
　　　　　　　　this.age　=　age;
　　　　　}
　　　}
}

• I metodi getter e setter forniscono accesso in sola lettura o scrittura ai campi della nostra classe. Ad esempio:

getName()　　　// Fornisce accesso lettura
setName()　　　// Fornisce accesso scrittura

• Aiuta a decouplare i componenti del sistema. Questi componenti decouplati possono essere sviluppati, testati e debuggati indipendentemente e contemporaneamente. E qualsiasi modifica a un componente specifico non avrà alcun impatto sugli altri componenti.

Mascheramento dei dati e Encapsulation

La gente tende a pensare che l'encapsulation sia il mascheramento dei dati, ma questo non è completamente vero.

L'encapsulation implica l'unione di campi e metodi correlati.Questo ci permette di implementare il mascheramento dei dati.L'encapsulation non è necessariamente la mascheramento dei dati.