Wat is zichtbaarheid in de context van Java-programmering?

In de context van Java (ook wel bekend als scope) bepaalt de zichtbaarheid de toegankelijkheid van een variabele, methode, constructor of klasse vanuit andere delen van het programma. Het wordt beheerd door toegangsspecificators.

Java kent vier niveaus van zichtbaarheid:

1. public: Toegankelijk vanaf elke plek binnen en buiten het pakket.
2. protected: Toegankelijk binnen hetzelfde pakket en in subclasses (zelfs in andere pakketten).
3. Standaardmodus (default of package-private): Alleen toegankelijk binnen hetzelfde pakket. Wordt niet expliciet aangegeven met een modifier.
4. private: Alleen toegankelijk binnen dezelfde klasse.

Modifier	Klasse	Pakket	Subklasse (buiten pakket)	Elke klasse (buiten pakket)
public	Ja	Ja	Ja	Ja
protected	Ja	Ja	Ja	Nee
Default	Ja	Ja	Nee	Nee
private	Ja	Nee	Nee	Nee

Het gebruik van zichtbaarheid modifiers speelt een belangrijke rol in encapsulatie en toegangscontrole tot programmastructuren.

Voorbeeld van het gebruik van modifiers:

// Klasse A in pakket com.example.package1
package com.example.package1;

public class ClassA {
    public int publicVar;
    protected int protectedVar;
    int defaultVar; // Standaard modifier
    private int privateVar;

    public void publicMethod() {
        // Kan toegang krijgen tot alle variabelen van klasse ClassA
        System.out.println("Public method in ClassA");
    }

    protected void protectedMethod() {
        System.out.println("Protected method in ClassA");
    }

    void defaultMethod() {
        System.out.println("Default method in ClassA");
    }

    private void privateMethod() {
        System.out.println("Private method in ClassA");
    }

    public void accessMembers() {
        publicVar = 1;
        protectedVar = 2;
        defaultVar = 3;
        privateVar = 4; // OK, binnen de klasse
        privateMethod(); // OK, binnen de klasse
    }
}

// Klasse B in hetzelfde pakket com.example.package1
package com.example.package1;

public class ClassB {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 10; // OK, public
        objA.protectedVar = 20; // OK, protected (zelfde pakket)
        objA.defaultVar = 30; // OK, default (zelfde pakket)
        // objA.privateVar = 40; // Compile-fout, private
        objA.publicMethod(); // OK, public
        objA.protectedMethod(); // OK, protected (zelfde pakket)
        objA.defaultMethod(); // OK, default (zelfde pakket)
        // objA.privateMethod(); // Compile-fout, private
    }
}

// Klasse C in een ander pakket com.example.package2
package com.example.package2;
import com.example.package1.ClassA;

public class ClassC extends ClassA { // ClassC is een subclass van ClassA
    public void accessClassAMembersFromSubclass() {
        publicVar = 100; // OK, public
        protectedVar = 200; // OK, protected (subklasse, zelfs in ander pakket)
        // defaultVar = 300; // Compile-fout, default (ander pakket)
        // privateVar = 400; // Compile-fout, private

        publicMethod(); // OK, public
        protectedMethod(); // OK, protected (subklasse, zelfs in ander pakket)
        // defaultMethod(); // Compile-fout, default (ander pakket)
        // privateMethod(); // Compile-fout, private
    }
}

// Klasse D in een ander pakket com.example.package2 (geen subclass van ClassA)
package com.example.package2;
import com.example.package1.ClassA;

public class ClassD {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 1000; // OK, public
        // objA.protectedVar = 2000; // Compile-fout, protected (ander pakket, geen subclass)
        // objA.defaultVar = 3000; // Compile-fout, default (ander pakket)
        // objA.privateVar = 4000; // Compile-fout, private

        objA.publicMethod(); // OK, public
        // objA.protectedMethod(); // Compile-fout, protected (ander pakket, geen subclass)
        // objA.defaultMethod(); // Compile-fout, default (ander pakket)
        // objA.privateMethod(); // Compile-fout, private
    }
}

Het begrijpen van zichtbaarheid helpt bij het creëren van betrouwbaardere en meer modulaire code, door ongewenste toegang tot interne details van klassen te beperken.