Cos'è la visibilità nel contesto della programmazione…

La visibilità nel contesto di Java (chiamata anche ambito di visibilità) determina l'accessibilità di una variabile, metodo, costruttore o classe da altre parti del programma. È controllata dai modificatori di accesso.

In Java ci sono quattro livelli di visibilità:

public: Accessibile da qualsiasi luogo all'interno e all'esterno del package.
protected: Accessibile all'interno dello stesso package e nelle sottoclassi (anche in altri package).
Modo di default (default o package-private): Accessibile solo all'interno dello stesso package. Non viene specificato esplicitamente con un modificatore.
private: Accessibile solo all'interno della stessa classe.

Modificatore	Classe	Package	Sottoclasse (fuori dal package)	Qualsiasi classe (fuori dal package)
`public`	Sì	Sì	Sì	Sì
`protected`	Sì	Sì	Sì	No
Default	Sì	Sì	No	No
`private`	Sì	No	No	No

L'uso dei modificatori di visibilità svolge un ruolo importante nell'incapsulamento e nel controllo degli accessi agli elementi del programma.

Esempio di utilizzo dei modificatori:

// Classe A nel package com.example.package1
package com.example.package1;

public class ClassA {
    public int publicVar;
    protected int protectedVar;
    int defaultVar; // Modificatore di default
    private int privateVar;

    public void publicMethod() {
        // Può accedere a tutte le variabili della classe ClassA
        System.out.println("Metodo pubblico in ClassA");
    }

    protected void protectedMethod() {
        System.out.println("Metodo protetto in ClassA");
    }

    void defaultMethod() {
        System.out.println("Metodo di default in ClassA");
    }

    private void privateMethod() {
        System.out.println("Metodo privato in ClassA");
    }

    public void accessMembers() {
        publicVar = 1;
        protectedVar = 2;
        defaultVar = 3;
        privateVar = 4; // OK, accesso all'interno della classe
        privateMethod(); // OK, accesso all'interno della classe
    }
}

// Classe B nello stesso package com.example.package1
package com.example.package1;

public class ClassB {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 10; // OK, pubblico
        objA.protectedVar = 20; // OK, protetto (stesso package)
        objA.defaultVar = 30; // OK, di default (stesso package)
        // objA.privateVar = 40; // Errore di compilazione, privato
        objA.publicMethod(); // OK, pubblico
        objA.protectedMethod(); // OK, protetto (stesso package)
        objA.defaultMethod(); // OK, di default (stesso package)
        // objA.privateMethod(); // Errore di compilazione, privato
    }
}

// Classe C in un altro package com.example.package2
package com.example.package2;
import com.example.package1.ClassA;

public class ClassC extends ClassA { // ClassC è una sottoclasse di ClassA
    public void accessClassAMembersFromSubclass() {
        publicVar = 100; // OK, pubblico
        protectedVar = 200; // OK, protetto (sottoclasse, anche in altro package)
        // defaultVar = 300; // Errore di compilazione, di default (altro package)
        // privateVar = 400; // Errore di compilazione, privato

        publicMethod(); // OK, pubblico
        protectedMethod(); // OK, protetto (sottoclasse, anche in altro package)
        // defaultMethod(); // Errore di compilazione, di default (altro package)
        // privateMethod(); // Errore di compilazione, privato
    }
}

// Classe D in un altro package com.example.package2 (NON sottoclasse di ClassA)
package com.example.package2;
import com.example.package1.ClassA;

public class ClassD {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 1000; // OK, pubblico
        // objA.protectedVar = 2000; // Errore di compilazione, protetto (altro package, non sottoclasse)
        // objA.defaultVar = 3000; // Errore di compilazione, di default (altro package)
        // objA.privateVar = 4000; // Errore di compilazione, privato

        objA.publicMethod(); // OK, pubblico
        // objA.protectedMethod(); // Errore di compilazione, protetto (altro package, non sottoclasse)
        // objA.defaultMethod(); // Errore di compilazione, di default (altro package)
        // objA.privateMethod(); // Errore di compilazione, privato
    }
}

Comprendere la visibilità aiuta a creare un codice più robusto e modulare, limitando l'accesso indesiderato ai dettagli interni delle classi.

Cos'è la visibilità nel contesto della programmazione Java?