Java: Sichtbarkeiten – Das Geheimnisprinzip einfach erklärt

Java • 10. November 2025 • Lesezeit: 5 Minuten

In der objektorientierten Programmierung geht es nicht nur darum, was ein Programm kann, sondern auch darum, wer was wissen darf. Genau hier setzt das sogenannte Geheimnisprinzip an – oder etwas technischer formuliert: die Sichtbarkeit von Variablen, Methoden und Klassen in Java.

Das Ziel ist einfach: Eine Klasse soll nur so viel preisgeben, wie wirklich nötig ist. Alles andere bleibt intern und damit geschützt vor unbeabsichtigtem Zugriff von außen. Das ist ein wichtiger Teil von sauberem Code und schützt vor Fehlern, die durch falsche Nutzung entstehen könnten.

Warum das Geheimnisprinzip wichtig ist

Stell dir vor, du hast ein Auto. Du kannst es starten, lenken und bremsen – aber du brauchst keinen direkten Zugriff auf den Motor oder die Elektronik im Hintergrund. Du vertraust darauf, dass das Auto funktioniert, solange du es richtig bedienst.

Genauso ist es in Java: Andere Klassen sollen nur die Dinge nutzen können, die wirklich für sie gedacht sind. Alles, was intern passiert, bleibt versteckt. Das nennt man Information Hiding.

Dafür bietet Java verschiedene Sichtbarkeitsmodifikatoren: private, protected, public und die sogenannte package-private (auch package friendly) Sichtbarkeit (wenn man keinen Modifikator angibt).

Ein einfaches Beispiel

Nehmen wir eine Klasse Auto, die eine Geschwindigkeit verwaltet. Die Geschwindigkeit soll nicht einfach von außen verändert werden können, sonst könnte man das Auto „kaputt machen“. Stattdessen wird sie über Methoden gesteuert:

public class Auto {
    private int geschwindigkeit;

    public void beschleunigen() {
        geschwindigkeit = geschwindigkeit + 10;
    }

    public void bremsen() {
        if (geschwindigkeit >= 10) {
            geschwindigkeit = geschwindigkeit - 10;
        }
    }

    public int getGeschwindigkeit() {
        return geschwindigkeit;
    }
}

Hier siehst du: Die Variable geschwindigkeit ist private – also nur innerhalb der Klasse Auto sichtbar. Andere Klassen können darauf nicht direkt zugreifen. Stattdessen stellen wir Methoden bereit, um die Geschwindigkeit zu ändern oder auszulesen.

Damit kann niemand aus Versehen etwas Falsches tun wie:

// Das funktioniert nicht:
Auto a = new Auto();
a.geschwindigkeit = 9999; // Fehler! Variable ist privat

Die Klasse selbst bleibt also der „Hüter“ ihrer Daten. Der Zugriff erfolgt nur über kontrollierte Methoden. Das ist das Herzstück des Geheimnisprinzips.

public, private, protected und ohne Modifikator

In Java gibt es vier mögliche Sichtbarkeiten. Die Namen sind leicht zu merken, aber der Unterschied ist wichtig. Hier ein kleines Beispiel mit vier Klassen in einem Paket:

// Datei: fahrzeuge/Auto.java
package fahrzeuge;

public class Auto {
    public String marke = "VW";
    protected String farbe = "Rot";
    String modell = "Golf";
    private int kilometerstand = 12000;

    public void info() {
        System.out.println("Marke: " + marke);
        System.out.println("Farbe: " + farbe);
        System.out.println("Modell: " + modell);
        System.out.println("Kilometer: " + kilometerstand);
    }
}

Nun erstellen wir eine zweite Klasse im selben Paket:

// Datei: fahrzeuge/TestImPaket.java
package fahrzeuge;

public class TestImPaket {
    public static void main(String[] args) {
        Auto a = new Auto();
        System.out.println(a.marke);        // funktioniert (public)
        System.out.println(a.farbe);        // funktioniert (protected)
        System.out.println(a.modell);       // funktioniert (package-private)
        // System.out.println(a.kilometerstand); // Fehler! private
    }
}

Wenn wir nun eine Klasse TestAusserhalb in einem anderen Paket schreiben:

// Datei: test/TestAusserhalb.java
package test;
import fahrzeuge.Auto;

public class TestAusserhalb {
    public static void main(String[] args) {
        Auto a = new Auto();
        System.out.println(a.marke);   // funktioniert (public)
        // System.out.println(a.farbe); // Fehler! protected
        // System.out.println(a.modell); // Fehler! package-private
        // System.out.println(a.kilometerstand); // Fehler! private
    }
}

Wenn wir das Programm TestImPaket starten, lautet die Ausgabe:

VW
Rot
Golf

Die private-Variable bleibt unsichtbar. Genau das wollen wir – interne Details sollen nicht von außen verändert oder eingesehen werden.

protected – ein kleiner Sonderfall

Der Modifikator protected erlaubt Zugriff innerhalb des gleichen Pakets und zusätzlich für Unterklassen, auch wenn sie in einem anderen Paket liegen.

package test;
import fahrzeuge.Auto;

public class Rennwagen extends Auto {
    public void lackiereNeu() {
        farbe = "Blau"; // funktioniert, weil Rennwagen von Auto erbt
    }
}

Damit kann man z. B. Vererbung gezielt steuern: Eine Unterklasse darf bestimmte Felder oder Methoden anpassen, andere aber nicht.

Getter und Setter – der kontrollierte Zugriff

In der Praxis sind private Variablen fast immer der Normalfall. Um auf sie zuzugreifen, verwendet man Getter und Setter. Das sind einfache Methoden, die das Lesen und Schreiben erlauben, aber dabei zusätzliche Logik enthalten können - in der JavaEE Welt aber nicht enthalten sollten.

public class Konto {
    private double kontostand;

    public double getKontostand() {
        return kontostand;
    }

    public void setKontostand(double betrag) {
        if (betrag >= 0) {
            kontostand = betrag;
        } else {
            System.out.println("Negativer Betrag ist nicht erlaubt!");
        }
    }
}

Verwendung:

Konto k = new Konto();
k.setKontostand(100.50);
System.out.println(k.getKontostand());
k.setKontostand(-50);

Ausgabe:

100.5
Negativer Betrag ist nicht erlaubt!

So bleibt der innere Zustand der Klasse geschützt, und trotzdem können andere Teile des Programms sicher darauf zugreifen.

Fazit

Das Geheimnisprinzip ist einer der wichtigsten Grundsätze in der objektorientierten Programmierung. Es sorgt dafür, dass Klassen nicht „durchlässig“ werden, sondern ihre eigenen Daten schützen. Mit den Sichtbarkeiten private, protected, public und der Standard-Sichtbarkeit bestimmst du genau, wer Zugriff hat – und wer nicht.

Kurz gesagt: Vertraue deinen Klassen, aber kontrolliere den Zugriff! Wenn du das früh verinnerlichst, wirst du sauberen, robusten und wartbaren Code schreiben – und genau das unterscheidet gute Entwickler von großartigen.