Gültigkeitsbereich von Variablen in Java

Thema in Kurzform

• Instanzvariablen sind in der gesamten Klasse verfügbar. Parameter- und lokale Variablen dagegen sind auf die Methode beschränkt, in der sie deklariert wurden.
• Instanzvariablen erhalten ohne explizite Initialisierung je nach Datentyp einen Standardwert zugewiesen (z.B. null, 0, 0.0, false)

Inhaltsverzeichnis

1. Wo werden Variablen deklariert?
2. Welchen Wert haben Variablen nach dem Deklarieren?
3. Der Gültigkeitsbereich von Variablen (scope)
4. Übungen

Wo werden Variablen deklariert?

Wir unterscheiden zwischen drei verschiedenen Variablen-Typen, die sich danach unterscheiden, wo sie im Code der jeweiligen Klasse deklariert werden. Der Ort, wo wir eine Variable erzeugen, hat nämlich entscheidenden Einfluss auf ihren Gültigkeitsbereich.

• Instanzvariablen: Werden auch Objektvariablen genannt. Diese werden direkt zu Beginn einer Klasse deklariert. Wir können diese Variablen in der gesamten Klasse verwenden.
• Parameter-Variablen: Diese Variablen werden als Parameter von Methoden innerhalb der runden Klammern im Methoden-Kopf deklariert. Sie können nur in der entsprechenden Methode verwendet werden.
• Lokale Variablen: Werden innerhalb eines Methoden-Körpers deklariert. Sie können von der Zeile ihrer Deklaration an bis zum Ende der Methode verwendet werden. Aber Achtung: Es gibt hier auch Ausnahmen (die sehen wir uns weiter unten an).

Es gibt noch einen weiteren Variablentyp, den wir aber erst im nächsten Kapitel kennenlernen: die statische Klassenvariable.

Ein einfaches Beispiel

Es ist am besten, wenn wir uns das Prinzip einmal konkret anhand einer kleinen Java-Klasse anschauen:

public class Fahrzeug {

    // Instanzvariablen:
    private String bezeichnung;
    private double geschwindigkeit;

    // Konstruktor mit 2 Parameter-Variablen:
    public Fahrzeug(String bezeichnungP, double geschwindigkeitP){
        bezeichnung = bezeichnungP;
        geschwindigkeit = geschwindigkeitP;
    }

    // Methode mit einer Parameter-Variablen und
    // einer lokalen Variablen:
    public double getFahrtdauer(int fahrtstrecke){
        double zeit = (fahrtstrecke / geschwindigkeit) * 60;
        return zeit;
    }
}

Folgende Variablen kommen in dieser Beispielklasse vor:

• Instanzvariablen: Die Klasse Fahrzeug hat insgesamt drei Instanzvariablen, nämlich bezeichnung, geschwindigkeit und kilometerstand.
  Wir können auf diese drei Variablen von überall aus in unserer Klasse zugreifen und das tun wir auch in unserem Code. Im Konstruktor nämlich initialisieren wir die beiden Instanzvariablen. Auch in der Methode getFahrtdauer() greifen wir auf die Instanzvariable geschwindigkeit zu. Wir können es also nochmal sagen: Instanzvariablen gehen immer!
• Parametervariablen: In unserer Beispielklasse gibt es drei Parametervariablen. Zwei werden im Kopf des Konstruktors (bezeichnungP, geschwindigkeitP) und die dritte (fahrtstrecke) im Kopf der Methode getFahrtDauer() deklariert.
  Jede Parameter-Variable ist ausschließlich in der Methode verfügbar, zu der sie gehört. Das ist ein Naturgesetz!
• Lokale Variablen: Kommen wir nun zum dritten Variablen-Typ, den lokalen Variablen. Von diesen haben wir genau eine in unserem Code - erkennen Sie, wo sie sich befindet? Richtig: zeit heißt sie und ist innerhalb der Methode getFahrtdauer() deklariert und mit dem Ergebniswert der Rechnung initialisiert.

Man könnte Parametervariablen und lokale Variablen auch "Methoden-Variablen" nennen, da sie ja fest zu den Methoden gehören, in denen sie erzeugt wurde und auch nur dort benutzbar bzw. sichtbar sind

Es gibt in der Verwendung von Parametervariablen und lokalen Variablen aber einen feinen Unterschied: Auf Parametervariablen können in der gesamten Methode zugegriffen können. Lokale Variablen dagegen innerhalb "ihrer" Methode erst in den Code-Zeilen nach der Initialisierung (also nachdem sie einen passenden Wert erhalten haben).

Welchen Wert haben Variablen nach dem Deklarieren?

Oder anders gefragt: Welchen Wert haben Variablen, wenn sie nicht initialisiert werden? Haben Sie überhaupt einen Wert?

Eigentlich verhält es sich damit ganz einfach. Wir müssen aber zwischen Instanzvariablen und lokalen Variablen unterscheiden.

Werte von Instanzvariablen ohne explizite Initialisierung

Wenn eine Instanzvariable vom Programmierer deklariert, aber (noch) nicht initialisiert wird, erhält diese dennoch automatisch einen Standardwert zugewiesen. Dieser Wert unterscheidet sich je nach Datentyp:

Die Konsequenz daraus ist praktisch: Wir können auf eine Instanzvariable nach ihrer Deklarierung nicht nur überall im Klassen-Code zugreifen. Sie ist außerdem sofort "einsatzbereit".

und lokale Variablen?

Bei diesen Variablen-Typen ist das anders. Lokale Variablen erhalten nämlich nach der Erzeugung/ Deklaration keinen Standardwert zugewiesen. Wir können diese daher erst dann benutzen, nachdem sie explizit einen Wert zugewiesen bekommen haben.

Der folgende Code verursacht deshalb einen Compiler-Fehler:

public void eineMethode(){
  String lokaleVariable;
  System.out.println(lokaleVariable); //Fehler!
}

Die lokale Variable bekommt keinen Standardwert, das arme Ding! Somit können wir sie auch nicht einsetzen. Während eine Instanzvariable standardmäßig einen Null-Wert hat (siehe Tabelle), den wir auch am Bildschirm ausgeben könnten, hat eine lokale Variable ohne Initialisierung überhaupt nichts! Verstehen Sie jetzt, warum Null nicht Nichts ist? :-)

Der Gültigkeitsbereich von Variablen (scope)

Mit Gültigkeitsbereich einer Variablen ist gemeint, wo im Quellcode der Klasse wir diese einsetzen können. Im Englischen heißt das scope, was die Sache gut beschreibt, nämlich den "Spielraum" bzw. den möglichen "Aktionsradius" einer Variablen.

Wie wir wissen, können wir eine Instanzvariable überall im Code einer Klasse einsetzen. Auf Parameter-Variablen können wir schon in der gesamten Methode zugreifen.

Spannend wird es bei den lokalen Variablen. Diese können nach ihrer Deklaration einen Gültigkeitsbereich prinzipiell für den Rest der Methode haben, in der sie erzeugt wurden. "Können"? Ja, denn das ist nicht immer der Fall. Oftmals kann auf eine Variable nämlich nur auf einen Teilbereich der Methode zugegriffen werden.

public String blitzer(){

if(geschwindigkeit>120){
    String strafzettel; //die lokale Variable
    strafzettel = "Zu schnell! Gemessene Geschwindigkeit " + geschwindigkeit;
    return strafzettel;
    }

else{
    //
    }
}

Die Variable strafzettel ist nicht überall innerhalb der Methode gültig, sondern nur in den Zeilen 4-7 zwischen den beiden geschweiften Klammern { und }. Das ist nämlich der Block des if-Bereichs. Eben dieser Bereich ist der Scope der Variable, ihr Gültigkeitsbereich, und den darf sie nicht verlassen! Ein Zugriff auf die Variable von außerhalb ist nicht möglich.

• Der Gültigkeitsbereich einer Variablen wird markiert durch die geschweiften Klammern { und }. Eine Variable ist außerhalb dieses Bereichs nicht gültig.

Übungen

public class EineKlasse {

    private String v1;
    private double v2;

    public EineKlasse(){
        v2 = 2.2;
    }

    public void eineMethode(){

        int v3;

        System.out.println(v1);

        double v4;
        v4 = v2 + v3;

    }
}

public class Duell {

    private String name = "Obi-Wan Kenobi";

    public void laserschwertduell(){

    if(name.equals("Obi-Wan Kenobi")){
        String gegner1 = "Anakin";
    }

    else{
        String gegner2 = "Joda";
        System.out.println(gegner1 + "kämpft nicht");
         }
    }
}