Was ist Sichtbarkeit im Kontext der Java-Programmierung?

Die Sichtbarkeit im Kontext von Java (auch Sichtbarkeitsbereich genannt) bestimmt die Zugänglichkeit einer Variablen, Methode, eines Konstruktors oder einer Klasse aus anderen Teilen des Programms. Sie wird durch Zugriffsmodi gesteuert.

In Java gibt es vier Sichtbarkeitsstufen:

1. public: Überall innerhalb und außerhalb des Pakets zugänglich.
2. protected: Innerhalb desselben Pakets und in Unterklassen (auch in anderen Paketen).
3. Standardmodus (default oder package-private): Nur innerhalb desselben Pakets zugänglich. Wird nicht explizit durch einen Modifikator angegeben.
4. private: Nur innerhalb derselben Klasse zugänglich.

Modifikator	Klasse	Paket	Unterklasse (außerhalb des Pakets)	Jede Klasse (außerhalb des Pakets)
public	Ja	Ja	Ja	Ja
protected	Ja	Ja	Ja	Nein
Default	Ja	Ja	Nein	Nein
private	Ja	Nein	Nein	Nein

Die Verwendung von Sichtbarkeitsmodifikatoren spielt eine wichtige Rolle bei der Kapselung und Zugriffskontrolle auf Programmelemente.

Beispiel für die Verwendung von Modifikatoren:

// Klasse A im Paket com.example.package1
package com.example.package1;

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

    public void publicMethod() {
        // Kann auf alle Variablen der Klasse ClassA zugreifen
        System.out.println("Öffentliche Methode in ClassA");
    }

    protected void protectedMethod() {
        System.out.println("Geschützte Methode in ClassA");
    }

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

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

    public void accessMembers() {
        publicVar = 1;
        protectedVar = 2;
        defaultVar = 3;
        privateVar = 4; // OK, Zugriff innerhalb der Klasse
        privateMethod(); // OK, Zugriff innerhalb der Klasse
    }
}

// Klasse B im selben Paket com.example.package1
package com.example.package1;

public class ClassB {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 10; // OK, öffentlich
        objA.protectedVar = 20; // OK, geschützt (gleiches Paket)
        objA.defaultVar = 30; // OK, Standard (gleiches Paket)
        // objA.privateVar = 40; // Kompilierungsfehler, privat
        objA.publicMethod(); // OK, öffentlich
        objA.protectedMethod(); // OK, geschützt (gleiches Paket)
        objA.defaultMethod(); // OK, Standard (gleiches Paket)
        // objA.privateMethod(); // Kompilierungsfehler, privat
    }
}

// Klasse C in einem anderen Paket com.example.package2
package com.example.package2;
import com.example.package1.ClassA;

public class ClassC extends ClassA { // ClassC ist eine Unterklasse von ClassA
    public void accessClassAMembersFromSubclass() {
        publicVar = 100; // OK, öffentlich
        protectedVar = 200; // OK, geschützt (Unterklasse, auch in anderem Paket)
        // defaultVar = 300; // Kompilierungsfehler, Standard (anderes Paket)
        // privateVar = 400; // Kompilierungsfehler, privat

        publicMethod(); // OK, öffentlich
        protectedMethod(); // OK, geschützt (Unterklasse, auch in anderem Paket)
        // defaultMethod(); // Kompilierungsfehler, Standard (anderes Paket)
        // privateMethod(); // Kompilierungsfehler, privat
    }
}

// Klasse D in einem anderen Paket com.example.package2 (KEINE Unterklasse von ClassA)
package com.example.package2;
import com.example.package1.ClassA;

public class ClassD {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 1000; // OK, öffentlich
        // objA.protectedVar = 2000; // Kompilierungsfehler, geschützt (anderes Paket, keine Unterklasse)
        // objA.defaultVar = 3000; // Kompilierungsfehler, Standard (anderes Paket)
        // objA.privateVar = 4000; // Kompilierungsfehler, privat

        objA.publicMethod(); // OK, öffentlich
        // objA.protectedMethod(); // Kompilierungsfehler, geschützt (anderes Paket, keine Unterklasse)
        // objA.defaultMethod(); // Kompilierungsfehler, Standard (anderes Paket)
        // objA.privateMethod(); // Kompilierungsfehler, privat
    }
}

Das Verständnis der Sichtbarkeit hilft dabei, robusteren und modulareren Code zu erstellen, indem unerwünschter Zugriff auf die internen Details von Klassen eingeschränkt wird.