Scorri per mostrare il menu

Come nascondere campi e metodi da un'altra classe

I modificatori di accesso vengono utilizzati per controllare la visibilità e l'accessibilità di variabili e metodi in Java. Consentono di definire l'ambito e di limitare l'accesso a determinati membri di una classe.

Abbiamo già discusso dei modificatori di accesso nella sezione precedente. Ora, esaminiamo più da vicino il modificatore di accesso più comunemente utilizzato: private.

Come sapete, con il modificatore di accesso private, è possibile accedere a un campo/metodo solo dalla classe in cui si trova. Vediamo un esempio di utilizzo del modificatore private:

Ad esempio, se non si desidera che una variabile in una classe sia visibile o accessibile da un'altra classe, si può utilizzare il modificatore di accesso private:

Main.java


              123456789101112131415
            
package com.example;

public class Main {
    public static void main(String[] args) {
        Person bob = new Person();
        bob.name = "Bob";
        System.out.println(bob.name);
    }
}

class Person {
    private String name;
    private int age;
    private String gender;
}

Abbiamo dichiarato i campi della classe Person come private. Quando si tenta di inizializzare direttamente il campo, si ottiene un errore che indica che il campo name ha un modificatore di accesso private e non è accessibile per la chiamata o la modifica nel metodo main.

Come inizializzare un campo privato

Il modo più semplice per aggirare la protezione è utilizzare l'inizializzazione tramite un costruttore. Tuttavia, in questo modo, possiamo solo inizializzare i campi degli oggetti ma non accedere a tali campi. Vediamo un esempio:

Main.java


              123456789101112131415161718
            
package com.example;

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob");
        System.out.println(bob.name);
    }
}

class Person {
    private String name;
    private int age;
    private String gender;

    public Person(String name) {
        this.name = name;
    }
}

Siamo riusciti a inizializzare il campo name tramite il costruttore, ma non possiamo ancora accedere a questo campo e stamparlo utilizzando System.out.println(). Per ovviare a questo, possiamo sovrascrivere il metodo toString() in modo che, quando chiamiamo System.out.println(bob);, vengano visualizzate le informazioni sui suoi campi. Vediamo un esempio:

Main.java


              1234567891011121314151617181920212223
            
package com.example;

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob");
        System.out.println(bob);
    }
}

class Person {
    private String name;
    private int age;
    private String gender;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + '}';
    }
}

Siamo finalmente riusciti a visualizzare il valore del campo name dell'oggetto bob. Abbiamo ottenuto questo risultato utilizzando il metodo sovrascritto toString() nel quale abbiamo implementato la logica per visualizzare il campo name.

Sorge quindi la domanda: perché abbiamo bisogno di questo modificatore di accesso se dobbiamo scrivere così tanto codice aggiuntivo?

Talvolta, in classi diverse, ci sono variabili con stesso nome, e in tali casi è necessario nascondere le variabili di queste classi affinché altre classi non possano accedere a campi non necessari. Questo migliora notevolmente la comodità di scrittura del codice in generale, in quanto si comprende chiaramente a quale classe appartiene ciascun campo.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 12

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Sezione 1. Capitolo 12

Modificatore Private

Come nascondere campi e metodi da un'altra classe

Come inizializzare un campo privato