Kapselung und Zugriffskontrolle (Getter & Setter)
Diese Lektion ist fundamental, weil sie erklärt, warum man Felder nicht öffentlich macht,
wie man Daten sicher kapselt, und wie Klassen miteinander kommunizieren, ohne sich gegenseitig kaputtzumachen.
Wir machen es komplett ausführlich, technisch korrekt, praxisnah und in deinem Stil – keine Icons, keine unnötigen Abkürzungen, einfach klare Didaktik.
Warum Kapselung?
Bisher waren die Felder in deinen Klassen öffentlich sichtbar, z. B.:
public class Hund {
String name;
int alter;
}
Das hat zwei Probleme:
Daten können von außen direkt verändert werden – auch auf ungültige Werte.
Beispiel:
Hund h1 = new Hund();
h1.alter = -5; // Unsinniger Wert – Hund kann kein negatives Alter haben
2. Änderungen in der internen Struktur der Klasse könnten anderen Code beschädigen,
weil alle direkt auf die Variablen zugreifen.
Deshalb gilt in der objektorientierten Programmierung ein Grundprinzip:
Felder sollten privat sein, Verhalten sollte öffentlich sein.
So steuert die Klasse selbst, wie und wann Daten verändert werden dürfen.
Zugriffskontrolle in Java
Java bietet sogenannte Zugriffsmodifikatoren, um genau zu definieren,
wer auf was zugreifen darf.
| Schlüsselwort | Zugriff von außen | Beschreibung |
|---|---|---|
public | überall | komplett sichtbar |
private | nur innerhalb derselben Klasse | volle Kapselung |
protected | in Unterklassen (Vererbung) und im selben Paket | eingeschränkter Zugriff |
| (kein Modifikator) | innerhalb desselben Pakets | „package-private“ |
Für Felder sollte fast immer private genutzt werden.
Für Methoden (die genutzt werden sollen) meist public.
Getter und Setter
Wenn Felder private sind, kann man sie nicht mehr direkt ansprechen.
Stattdessen nutzt man Getter (zum Lesen) und Setter (zum Schreiben).
Beispiel:
public class Hund {
private String name;
private int alter;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAlter(int alter) {
if (alter >= 0) { // Schutz gegen falsche Werte
this.alter = alter;
}
}
public int getAlter() {
return alter;
}
}
Damit steuerst du zentral, wie auf Daten zugegriffen wird.
Verwendung:
public class Main {
public static void main(String[] args) {
Hund h1 = new Hund();
h1.setName("Ava");
h1.setAlter(4);
System.out.println("Name: " + h1.getName());
System.out.println("Alter: " + h1.getAlter());
}
}
Ausgabe:
Name: Ava
Alter: 4
Warum das wichtig ist:
Wenn du später etwas am Inneren änderst (z. B. Validierung, Datenbankanbindung),
bleibt der Rest des Codes unverändert, weil er nur Getter/Setter nutzt.Du kannst ungültige Zustände verhindern (z. B. kein negatives Alter, keine leeren Namen).
Du kannst Berechnungen hinzufügen, ohne die Schnittstelle zu verändern.
Beispiel: Logik im Setter
Setter müssen nicht einfach nur zuweisen – sie dürfen Logik enthalten, um Daten zu prüfen oder automatisch zu ändern.
public void setName(String name) {
if (name != null && !name.isEmpty()) {
this.name = name;
} else {
this.name = "Unbekannt";
}
}
Kombination mit Methoden
Kapselung funktioniert oft zusammen mit Methoden, die bestimmte Aktionen ausführen.
Beispiel: Eine Methode, die das Alter automatisch erhöht.
public void altern() {
alter++;
System.out.println(name + " ist jetzt " + alter + " Jahre alt.");
}
Verwendung:
h1.altern();
Kapselung in der Praxis
Das folgende Beispiel kombiniert alle Konzepte in einer realistischen Mini-Klasse:
public class Konto {
private String inhaber;
private double kontostand;
public Konto(String inhaber, double startguthaben) {
this.inhaber = inhaber;
this.kontostand = startguthaben;
}
public String getInhaber() {
return inhaber;
}
public double getKontostand() {
return kontostand;
}
public void einzahlen(double betrag) {
if (betrag > 0) {
kontostand += betrag;
}
}
public void abheben(double betrag) {
if (betrag > 0 && betrag <= kontostand) {
kontostand -= betrag;
} else {
System.out.println("Abhebung nicht möglich!");
}
}
}
Verwendung:
public class Main {
public static void main(String[] args) {
Konto k1 = new Konto("Ricky", 100.0);
k1.einzahlen(50);
k1.abheben(30);
System.out.println("Kontostand: " + k1.getKontostand() + " €");
}
}
Ausgabe:
Kontostand: 120.0 €
Interaktive Visualisierung: Konto mit Kapselung
Diese kleine Simulation zeigt, wie man ein Konto anlegt, Geld einzahlt, abhebt
und wie Getter/Setter den Zugriff kontrollieren.
Interaktive Visualisierung: Konto mit Kapselung
– Ausgabe der Java-Konsole –
Häufige Fehlerquellen
| Fehler | Ursache | Lösung |
|---|---|---|
Felder sind public | Direkter Zugriff möglich | Felder immer private machen |
| Kein Zugriff auf Daten | Getter/Setter fehlen | Für benötigte Werte Getter/Setter schreiben |
| Endlosschleife in Setter | Setter ruft sich selbst auf (this.setName(name)) | Direkt auf Feld zugreifen (this.name = name) |
| Unvollständige Validierung | Setter prüft Eingaben nicht | Bedingungen ergänzen (if (wert > 0)) |