Java Language
Visibilità (controllo dell'accesso ai membri di una classe)

Sintassi

• nome del tipo pubblico [= valore];
• nome del tipo privato [= valore];
• nome del tipo protetto [= valore];
• nome del tipo [= valore];
• nome di classe pubblica {
• nome della classe{

Osservazioni

Membri dell'interfaccia

public interface MyInterface {
    public void foo();
    int bar();

    public String TEXT = "Hello";
    int ANSWER = 42;

    public class X {
    }

    class Y {
    }
}

I membri dell'interfaccia hanno sempre visibilità pubblica, anche se la parola chiave public viene omessa. Quindi sia foo() , bar() , TEXT , ANSWER , X e Y hanno visibilità pubblica. Tuttavia, l'accesso può essere ancora limitato dall'interfaccia contenente - poiché MyInterface ha visibilità pubblica, i suoi membri possono essere accessibili da qualsiasi luogo, ma se MyInterface avesse avuto visibilità del pacchetto, i suoi membri sarebbero stati accessibili solo all'interno dello stesso pacchetto.

Visibilità pubblica

Visibile alla classe, al pacchetto e alla sottoclasse.

Vediamo un esempio con il test di classe.

public class Test{
    public int number = 2;

    public Test(){

    }
}

Ora proviamo a creare un'istanza della classe. In questo esempio, possiamo accedere al number perché è public .

public class Other{
    
    public static void main(String[] args){
        Test t = new Test();
        System.out.println(t.number);
    }

}

Visibilità privata

private visibilità private consente a una variabile di accedere solo alla sua classe. Essi sono spesso usati in combinazione con public getter e setter.

class SomeClass {
    private int variable;

    public int getVariable() {
        return variable;
    }

    public void setVariable(int variable) {
        this.variable = variable;
    }
}

public class SomeOtherClass {
    public static void main(String[] args) {
        SomeClass sc = new SomeClass();
        
        // These statement won't compile because SomeClass#variable is private:
        sc.variable = 7;
        System.out.println(sc.variable);

        // Instead, you should use the public getter and setter:
        sc.setVariable(7);
        System.out.println(sc.getVariable());
    }
}

Visibilità del pacchetto

Senza alcun modificatore , l'impostazione predefinita è la visibilità del pacchetto. Dalla documentazione Java, "[visibilità pacchetto] indica se le classi nello stesso pacchetto della classe (indipendentemente dalla loro parentela) hanno accesso al membro." In questo esempio di javax.swing ,

package javax.swing;
public abstract class JComponent extends Container … {
    …
    static boolean DEBUG_GRAPHICS_LOADED;
    …
}

DebugGraphics trova nello stesso pacchetto, quindi DEBUG_GRAPHICS_LOADED è accessibile.

package javax.swing;
public class DebugGraphics extends Graphics {
    …
    static {
        JComponent.DEBUG_GRAPHICS_LOADED = true;
    }
    …
}

Questo articolo fornisce alcune informazioni sull'argomento.

Visibilità protetta

Cause di visibilità protetta significa che questo membro è visibile per il suo pacchetto, insieme a una qualsiasi delle sue sottoclassi.

Come esempio:

package com.stackexchange.docs;
public class MyClass{
    protected int variable; //This is the variable that we are trying to access
    public MyClass(){
        variable = 2;
    };
}

Ora estenderemo questa classe e proveremo ad accedere a uno dei suoi membri protected .

package some.other.pack;
import com.stackexchange.docs.MyClass;
public class SubClass extends MyClass{
    public SubClass(){
        super();
        System.out.println(super.variable);
    }
}

Sarai anche in grado di accedere a un membro protected senza estenderlo se accederai dallo stesso pacchetto.

Nota che questo modificatore funziona solo sui membri di una classe, non sulla classe stessa.

Riepilogo dei modificatori di accesso ai membri della classe

C'era una volta un modificatore private protected (entrambe le parole chiave contemporaneamente) che poteva essere applicato a metodi o variabili per renderli accessibili da una sottoclasse esterna al pacchetto, ma renderli privati ​​delle classi in quel pacchetto. Tuttavia, questo è stato rimosso nella versione di Java 1.0 .