Jetzt anmelden...

Login
Passwort
Registrieren

Java Tutorial #10

Gültigkeitsbereich von Variablen in Java

Wir beschäftigen uns in diesem Kapitel mit dem Gültigkeitsbereich von Variablen. Da es für die Lebensdauer von Variablen wichtig ist, wo im Quellcode einer Klasse diese deklariert werden, wird es vor allem um den Unterschied zwischen Instanzvariablen sowie, Parameter- und lokalen Variablen gehen.

Kommentare [0]

Stefan 12.10.2018

Infos zum Artikel

Kategorie Java
Autor Stefan
Datum 12.10.2018

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)

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 außschließ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 heisst 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 (nocht) nicht initialisiert wird, erhält diese dennoch automatisch einen Standardwert zugewiesen. Dieser Wert unterscheidet sich je nach Datentyp:

Datentyp Standardwert
Objekttyp (z.B. String) null
byte, short, int, long 0
float, double 0.0
boolean false
char Nullzeichen \u0000

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 Variable 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 Variable.

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.

Sehen wir uns das mal in einem Beispiel an: Was meinen Sie ist der Gültigkeitsbereich der Variablen strafzettel innerhalb der Methode blitzer()?

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

einfach

Welchen Wert hat die Variable int nummer, ohne dass wir sie explizit initialisiert haben (also ohne Anweisung für Wertzuweisung)?

Lösung ein-/ausblenden

mittel

Welche Aussagen zu dem folgenden Code sind richtig?

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;

    }
}

A. Es gibt einen Fehler in Zeile 15, weil die Variable v1 vor der Nutzung nicht initialisiert wurde.
B. Es gibt einen Fehler in Zeile 18, weil die Variable v3 vor der Nutzung nicht initialisiert wurde.
C. Es gibt einen Fehler sowohl in Zeile 15 als auch in Zeile 18
D. Der Code läuft fehlerfrei!

Lösung ein-/ausblenden

schwer

In welcher Zeile befindet sich im folgenden Code der Fehler?

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");
         }
    }
}
Lösung ein-/ausblenden

Kommentar schreiben

Nur angemeldete und aktivierte Benutzer können kommentieren.

Alle Kommentare

Es gibt bislang noch keine Kommentare zu diesem Thema.

Objekte vergleichen

Was ist der Unterschied zwischen == und equals()?

Initializer

Eher selten aber praktisch!

Schleifen in Java

Schleifenstrukturen gehören zu den wichtigsten Grundlagen in der Programmierung überhaupt.

FALCONBYTE.NET

Handmade with 🖤️

© 2018, 2019 Stefan E. Heller

Impressum | Datenschutz

facebook programmieren lernen twitter programmieren lernen youtube programmieren lernen