Zugriffsmodifikatoren, Sichtbarkeit von Variablen

1. Einführung

In Java gilt wie im Leben: Nicht alles sollte für alle und jederzeit zugänglich sein. Stell dir eine Wohnung vor: Du möchtest nicht, dass die Nachbarn durch dein Schlafzimmer laufen, oder? Genauso wollen wir in Programmen manchmal „die Tür schließen“ zu bestimmten Variablen oder Methoden, damit man von außen nicht auf sie zugreifen kann.

Dafür gibt es in Java Zugriffsmodifikatoren – spezielle Wörter, die angeben, wo eine Variable oder Methode verwendet werden darf, zum Beispiel public oder private.

Wesentliche Zugriffsmodifikatoren

public

private

(kein Modifikator)

Es gibt noch weitere Modifikatoren, aber darüber sprechen wir später, wenn wir zur Vererbung kommen.

Praxisbeispiel

public class User 
{
    public String name;           // für alle sichtbar
    private int age;              // nur innerhalb der Klasse User sichtbar

    public void sayHello() 
    {
        System.out.println("Hallo, ich heiße " + name);
    }

    private void secretMethod() 
    {
        System.out.println("Das ist eine geheime Methode!");
    }
}

Erläuterung:

• name – ist überall sichtbar, wo die Klasse User verwendet werden kann.
• age – ist nur innerhalb der Klasse User sichtbar.
• sayHello() – öffentliche Methode; sie kann von jeder anderen Klasse aus aufgerufen werden.
• secretMethod() – private Methode; sie kann von außen nicht aufgerufen werden.

Wie funktioniert das in realen Aufgaben?
Angenommen, wir haben eine Klasse, die ein Bankkonto beschreibt. Wir wollen eindeutig nicht, dass irgendwer den Kontostand direkt ändern kann! Deshalb wird die Kontostandsvariable private sein, und für die Arbeit damit gibt es spezielle Methoden.

Warum sollte man nicht alles public machen?

Es mag verlockend sein: „Machen wir doch einfach alles public, dann haben wir keine Mühe!“ Aber das führt ins Chaos. Stell dir vor, jeder könnte deinen Kontostand ändern, den Benutzernamen anpassen oder sogar eine Methode aufrufen, die nur intern gedacht war. In großen Programmen führt das zu Fehlern und „magischen“ Bugs.

Goldene Regel für Java-Entwickler:
Mach zunächst alles private und öffne nach außen nur das, was wirklich nötig ist.

2. Geltungsbereich (Scope) von Variablen

Der Geltungsbereich ist der Bereich des Codes, in dem eine Variable „existiert“ und verwendet werden kann. Verlässt man diesen Bereich, „verschwindet“ die Variable – als hätte es sie nie gegeben.

In Java gibt es hinsichtlich des Geltungsbereichs mehrere Arten von Variablen:

• Lokale Variablen – werden innerhalb einer Methode oder eines Codeblocks { ... } deklariert.
• Methodenparameter – werden in den runden Klammern der Methode deklariert.
• Felder der Klasse – werden innerhalb der Klasse, aber außerhalb von Methoden deklariert.

Wenn eine Variable innerhalb { eines Blocks } deklariert wird,
ist sie nur innerhalb dieses Blocks sichtbar
und außerhalb davon nicht zugänglich.

Lokale Variablen

Eine lokale Variable lebt nur innerhalb der Methode oder des Blocks, in dem sie deklariert wurde.

void printSum(int a, int b) 
{
    int sum = a + b; // lokale Variable
    System.out.println(sum);
}
// sum existiert hier bereits nicht mehr!

Der Versuch, außerhalb der Methode auf sum zuzugreifen, führt zu einem Kompilierfehler: „Kann die Variable sum nicht finden“.

Methodenparameter

Parameter sind ebenfalls Variablen, aber sie leben nur innerhalb der Methode.

void greet(String name) 
{
    System.out.println("Hallo, " + name);
}
// name existiert hier bereits nicht mehr!

Klassenfelder (Membervariablen)

Felder der Klasse werden innerhalb der Klasse, aber außerhalb von Methoden deklariert. Sie sind in allen Methoden dieser Klasse sichtbar.

public class Counter 
{
    private int count = 0; // Klassenfeld

    public void increment() 
    {
        count++; // wir können das Feld verwenden
    }

    public int getCount() 
    {
        return count; // wir können das Feld ebenfalls verwenden
    }
}

3. Variablen-Schatten (Shadowing)

Shadowing (Schatten) ist die Situation, wenn in einem Geltungsbereich eine Variable (oder ein Parameter) mit demselben Namen wie in einem äußeren Bereich deklariert wird. Innerhalb dieses Blocks überdeckt der „neue“ Name den alten, und auf den äußeren Wert kann nicht mehr direkt zugegriffen werden.

Beispiel für Shadowing:

class ShadowDemo 
{
    int value = 10; // Klassenfeld

    void printValue() 
    {
        System.out.println(value);  // 10 – gibt das Klassenfeld aus
        int value = 5; // die lokale Variable überdeckt das Klassenfeld
        System.out.println(value); // gibt 5 aus, nicht 10
    }
}

In diesem Beispiel deklarieren wir mit int value = 5; eine neue lokale Variable, die Vorrang vor dem Klassenfeld mit demselben Namen hat. Beim Zugriff auf value innerhalb der Methode printValue() wird die lokale Variable verwendet, nicht das Klassenfeld.

Wenn du dennoch auf ein statisches Klassenfeld zugreifen musst, verwende den Klassennamen als Präfix:

class ShadowDemo 
{
    static int value = 10; // statisches Klassenfeld 

    void printValue() 
    {
        System.out.println(value);      // 10 – Klassenfeld
        int value = 5;
        System.out.println(value);      // 5 – lokale Variable
        System.out.println(ShadowDemo.value); // 10 – statisches Klassenfeld, Zugriff über 'ShadowDemo'
    }
}

Wenn du auf ein nichtstatisches Klassenfeld zugreifen musst, wird das Schlüsselwort this verwendet. Es verweist auf die aktuelle Objektinstanz.

class ShadowDemo 
{
    int value = 10;

    void printValue() 
    {
        System.out.println(value);      // 10 – Klassenfeld
        int value = 5;
        System.out.println(value);      // 5 – lokale Variable
        System.out.println(this.value); // 10 – Klassenfeld, Zugriff über 'this'
    }
}

4. Praxis: Zugriffsmodifikatoren und Geltungsbereich

Lass uns die Übungsanwendung weiterentwickeln: ein einfaches System zur Verwaltung von Studierenden. Wir versehen Felder und Methoden mit unterschiedlichen Zugriffsmodifikatoren.

Beispiel: Klasse Student

public class Student 
{
    public String name;        // Name des Studenten (für alle sichtbar)
    private int age;           // Alter (nur innerhalb der Klasse sichtbar)

    public Student(String name, int age) 
    {
        this.name = name;
        this.age = age;
    }

    public void sayHello() 
    {
        System.out.println("Hallo, ich heiße " + name);
    }

    private void printSecret() 
    {
        System.out.println("Mein Alter: " + age);
    }

    public void revealSecret() 
    {
        printSecret(); // private Methode kann innerhalb der Klasse aufgerufen werden
    }
}

Verwendung der Klasse Student

public class Main 
{
    public static void main(String[] args) 
    {
        Student s = new Student("John", 20);
        s.sayHello();       // OK: öffentliche Methode
        s.revealSecret();   // OK: öffentliche Methode, die intern die private Methode aufruft

        s.age = 30;      // Fehler! Das Feld age ist privat

        s.printSecret(); // Fehler! Die Methode printSecret ist privat
    }
}

5. Typische Fehler beim Umgang mit Zugriffsmodifikatoren und Geltungsbereich

Fehler Nr. 1: Alles public – und hallo Chaos!
Wenn du alle Felder und Methoden öffentlich machst, verlierst du schnell die Kontrolle darüber, wer wie deine Daten verändert. Mach die Felder private und öffne nach außen nur das Notwendige.

Fehler Nr. 2: Versuch, eine Variable außerhalb ihres Geltungsbereichs zu verwenden.
Wenn du eine Variable innerhalb einer Methode deklarierst und dann versuchst, außerhalb darauf zuzugreifen, erhältst du einen Kompilierfehler. Lokale Variablen leben nur in ihrem Block { ... }.

Fehler Nr. 3: Namenskonflikt (Shadowing von Variablen).
Wenn du in einer Methode eine Variable mit demselben Namen wie ein Klassenfeld deklarierst, ist es leicht, den Überblick zu verlieren, welche Variable du verwendest. Verwende this, um explizit auf das Klassenfeld zu verweisen: this.value.

Fehler Nr. 4: Versuch, auf eine private Methode oder ein privates Feld aus einer anderen Klasse zuzugreifen.
Wenn eine Methode oder ein Feld als private markiert ist, ist es nur innerhalb derselben Klasse zugänglich. Der Versuch, von außen darauf zuzugreifen, führt zu einem Kompilierfehler.

Fehler Nr. 5: Geltungsbereich in einer Schleife oder einem Block vergessen.
Eine Variable, die innerhalb einer Schleife oder eines beliebigen Blocks { } deklariert wird, lebt nur innerhalb dieses Blocks. Außerhalb des Blocks existiert sie nicht.

1

Umfrage/Quiz

Methoden, Level 8, Lektion 5

Nicht verfügbar

Methoden

Deklaration und Aufruf von Methoden

Öffnen