OOP Programmierung
Datenkapselung & Sichtbarkeit
Diese Seite erklärt dir die Datenkapselung und die verschiedenen Sichtbarkeitsstufen in Java – mit anschaulichen Beispielen, Tabellen und einem Erklärvideo.
Datenkapselung
Datenkapselung bedeutet, dass wichtige Daten in einer Klasse versteckt werden – sie sind nicht direkt von außen zugänglich.
Stattdessen greift man nur kontrolliert über Methoden darauf zu – meistens mit sogenannten Getter- und Setter-Methoden.
Warum ist das wichtig?
- Datenintegrität:
Du kannst verhindern, dass falsche oder ungültige Werte gesetzt werden.
→ Beispiel: Ein negativer Kontostand soll nicht erlaubt sein. - Wartbarkeit:
Wenn du später etwas am internen Aufbau änderst, müssen andere Teile deines Programms nicht angepasst werden – solange die Getter/Setter gleich bleiben. - Kontrolle & Logik einbauen:
Du kannst z. B. in einem Setter prüfen, ob ein Wert sinnvoll ist, oder eine Änderung protokollieren.
Beispiel: Bankkonto
class Bankkonto {
// Das Attribut ist privat – von außen nicht direkt zugänglich
private double kontostand;
// Getter: erlaubt den kontrollierten Zugriff zum Lesen
public double getKontostand() {
return kontostand;
}
// Methode zum Einzahlen (ein Beispiel für einen Setter mit Logik)
public void einzahlen(double betrag) {
if (betrag > 0) {
kontostand += betrag;
} else {
System.out.println("Ungültiger Betrag!");
}
}
}
Ohne Kapselung (unsicher):
public class KontoOhneKapselung {
public double kontostand; // direkt zugänglich – gefährlich!
}
KontoOhneKapselung k = new KontoOhneKapselung();
k.kontostand = -9999; // ❌ unlogisch und gefährlich!
Mit Kapselung (sicher):
Bankkonto k = new Bankkonto();
k.einzahlen(100); // ✅ korrekt
System.out.println(k.getKontostand()); // gibt den Kontostand zurück
Datenkapselung schützt deine Daten vor ungewolltem Zugriff und macht dein Programm robuster und leichter zu pflegen.
Sichtbarkeitsstufen
In Java kannst du bei Variablen, Methoden und Klassen festlegen, wer darauf zugreifen darf – also wie sichtbar etwas ist. Das nennt man Sichtbarkeitsstufe oder Zugriffsmodifizierer.
Warum ist das wichtig?
- Du kannst damit Daten und Funktionen schützen, die nicht von außen verändert werden sollen.
- Du steuerst, welche Teile deines Codes wie zusammenarbeiten dürfen.
- Es hilft dir, Fehler zu vermeiden und deinen Code klarer und wartbarer zu machen.
Übersicht der Modifizierer:
| Modifizierer | Sichtbar für... | Verwendung |
|---|---|---|
public | Alle Klassen – überall im Projekt | Wenn etwas überall genutzt werden soll, z. B. eine öffentliche Methode |
private | Nur innerhalb der Klasse selbst | Für interne Details, die niemand von außen sehen oder ändern darf |
protected | In der gleichen Klasse + in Unterklassen (Vererbung) | Wird oft bei Vererbung verwendet, wenn Unterklassen etwas brauchen |
| (kein Mod.) (package-private) | Nur im gleichen Paket (Ordner) | Standardzugriff – nützlich für zusammengehörige Klassen im selben Paket |
Beispiel zur Verdeutlichung:
public class Tier {
public String name; // kann überall gelesen werden
private int gewicht; // nur innerhalb der Klasse Tier
protected int alter; // sichtbar in Tier + allen Unterklassen
String farbe; // kein Modifizierer: sichtbar im selben Paket
}
Beispiel mit Zugriff:
package tiere;
public class Hund extends Tier {
public void zeigeAlter() {
System.out.println(alter); // ✅ geht – protected
System.out.println(name); // ✅ geht – public
// System.out.println(gewicht); // ❌ geht nicht – private
System.out.println(farbe); // ✅ geht – gleicher Package
}
}
package andere;
public class Main {
public static void main(String[] args) {
Tier t = new Tier();
System.out.println(t.name); // ✅ public – geht
// System.out.println(t.alter); // ❌ protected – nicht in anderem Paket
// System.out.println(t.gewicht); // ❌ private – kein Zugriff
// System.out.println(t.farbe); // ❌ package-private – anderes Paket
}
}