Java Language
Zichtbaarheid (controle van de toegang tot leden van een klas)

Syntaxis

• openbare type naam [= waarde];
• naam privétype [= waarde];
• beschermde typenaam [= waarde];
• typ naam [= waarde];
• public class name {
• naam van de klasse{

Opmerkingen

Interface-leden

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

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

    public class X {
    }

    class Y {
    }
}

Interface-leden hebben altijd openbare zichtbaarheid, zelfs als het public trefwoord wordt weggelaten. Dus zowel foo() , bar() , TEXT , ANSWER , X en Y hebben openbare zichtbaarheid. Toegang kan echter nog steeds worden beperkt door de bevattende interface - omdat MyInterface openbare zichtbaarheid heeft, zijn de leden overal toegankelijk, maar als MyInterface had gehad, zouden de leden alleen toegankelijk zijn geweest vanuit hetzelfde pakket.

Publieke zichtbaarheid

Zichtbaar voor de klasse, het pakket en de subklasse.

Laten we een voorbeeld bekijken met de klasse Test.

public class Test{
    public int number = 2;

    public Test(){

    }
}

Laten we nu proberen een instantie van de klas te maken. In dit voorbeeld hebben we toegang tot het number omdat dit public .

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

}

Privé zichtbaarheid

private zichtbaarheid kan een variabele alleen worden geopend door zijn klasse. Ze worden vaak gebruikt in combinatie met public getters en setters.

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

Zichtbaarheid pakket

Zonder modificatie is de standaard zichtbaarheid van pakketten. Uit de Java-documentatie geeft "[pakketzichtbaarheid] aan of klassen in hetzelfde pakket als de klasse (ongeacht hun afkomst) toegang hebben tot het lid." In dit voorbeeld van javax.swing ,

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

DebugGraphics zit in hetzelfde pakket, dus DEBUG_GRAPHICS_LOADED is toegankelijk.

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

Dit artikel geeft enige achtergrondinformatie over het onderwerp.

Beschermd zicht

Beschermde zichtbaarheid veroorzaakt dat dit lid zichtbaar is voor zijn pakket, samen met een van zijn subklassen.

Als voorbeeld:

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

Nu zullen we deze klasse uitbreiden en proberen toegang te krijgen tot een van de protected leden.

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

U kunt ook toegang krijgen tot een protected lid zonder het uit te breiden als u het vanuit hetzelfde pakket gebruikt.

Merk op dat deze modifier alleen werkt op leden van een klasse, niet op de klasse zelf.

Samenvatting van Class Member Access Modifiers

Er was ooit een private protected (beide sleutelwoorden tegelijk) modificator die op methoden of variabelen kon worden toegepast om ze toegankelijk te maken vanuit een subklasse buiten het pakket, maar ze privé te maken voor de klassen in dat pakket. Dit werd echter verwijderd in de release van Java 1.0 .