Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 4 - Datentypen

## 4.3 Variablen

- 4.3 Variablen
  - 4.3.1 Grundeigenschaften
  - 4.3.2 Deklaration von Variablen
  - 4.3.3 Lebensdauer/Sichtbarkeit

### 4.3.1 Grundeigenschaften

Variablen dienen dazu, Daten im Hauptspeicher eines Programms abzulegen und gegebenenfalls zu lesen oder zu verändern. In Java gibt es drei Typen von Variablen:

- Instanzvariablen, die im Rahmen einer Klassendefinition definiert und zusammen mit dem Objekt angelegt werden.
- Klassenvariablen, die ebenfalls im Rahmen einer Klassendefinition definiert werden, aber unabhängig von einem konkreten Objekt existieren.
- Lokale Variablen, die innerhalb einer Methode oder eines Blocks definiert werden und nur dort existieren.

Daneben betrachtet die Sprachdefinition auch Array-Komponenten und die Parameter von Methoden und Exception-Handlern als Variablen.

|  | Eine Variable in Java ist immer typisiert. Sie ist entweder von einem primitiven Typen oder von einem Referenztypen. Mit Ausnahme eines Spezialfalls bei Array-Variablen, auf den wir später zurückkommen, werden alle Typüberprüfungen zur Compile-Zeit vorgenommen. Java ist damit im klassischen Sinne eine typsichere Sprache. |  |
Hinweis

Um einer Variablen vom Typ `T` einen Wert `X` zuzuweisen, müssen `T` und `X` zuweisungskompatibel sein. Welche Typen zuweisungskompatibel sind, wird am Ende dieses Kapitels in Abschnitt 4.6 erklärt.

Variablen können auf zwei unterschiedliche Arten verändert werden:

- durch eine Zuweisung
- durch einen Inkrement- oder Dekrement-Operator

Beide Möglichkeiten werden in Kapitel 5 ausführlich erklärt.

### 4.3.2 Deklaration von Variablen

Die Deklaration einer Variable erfolgt in der Form

    Typname Variablenname;

Dabei wird eine Variable des Typs `Typname` mit dem Namen `Variablenname` angelegt. Variablendeklarationen dürfen in Java an beliebiger Stelle im Programmcode erfolgen. Das folgende Beispielprogramm legt die Variablen `a`, `b`, `c` und `d` an und gibt ihren Inhalt auf dem Bildschirm aus:

    001 /* Listing0402.java */
    002
    003 public class Listing0402
    004 {
    005   public static void main(String[] args)
    006   {
    007     int a;
    008     a = 1;
    009     char b = 'x';
    010     System.out.println(a);
    011     double c = 3.1415;
    012     System.out.println(b);
    013     System.out.println(c);
    014     boolean d = false;
    015     System.out.println(d);
    016   }
    017 }
| Listing0402.java

Listing 4.2: Einfache Variablen ausgeben

Die Ausgabe des Programms ist:

    1
    x
    3.1415
    false

|  |  |  | Wie in diesem Beispiel zu sehen ist, dürfen Variablen gleich bei der Deklaration initialisiert werden. Dazu ist einfach der gewünschte Wert hinter einem Zuweisungsoperator an die Deklaration anzuhängen:
    char b = 'x';
    double c = 3.1415;
    boolean d = false;
Listing 4.3: Initialisieren von Variablen |  |
Tip

### 4.3.3 Lebensdauer/Sichtbarkeit

Die Sichtbarkeit lokaler Variablen erstreckt sich von der Stelle ihrer Deklaration bis zum Ende der Methode, in der sie deklariert wurden. Falls innerhalb eines Blocks lokale Variablen angelegt wurden, sind sie bis zum Ende des Blocks sichtbar. Die Lebensdauer einer lokalen Variable beginnt, wenn die zugehörige Deklarationsanweisung ausgeführt wird. Sie endet mit dem Ende des Methodenaufrufs. Falls innerhalb eines Blocks lokale Variablen angelegt wurden, endet ihre Lebensdauer mit dem Verlassen des Blocks. Es ist in Java nicht erlaubt, lokale Variablen zu deklarieren, die gleichnamige lokale Variablen eines weiter außen liegenden Blocks verdecken. Das Verdecken von Klassen- oder Instanzvariablen ist dagegen zulässig.

Instanzvariablen werden zum Zeitpunkt des Erzeugens einer neuen Instanz einer Klasse angelegt. Sie sind innerhalb der ganzen Klasse sichtbar, solange sie nicht von gleichnamigen lokalen Variablen verdeckt werden. In diesem Fall ist aber der Zugriff mit Hilfe des `this`-Zeigers möglich: `this.name` greift immer auf die Instanz- oder Klassenvariable `name` zu, selbst wenn eine gleichnamige lokale Variable existiert. Mit dem Zerstören des zugehörigen Objektes werden auch alle Instanzvariablen zerstört.

Klassenvariablen leben während der kompletten Laufzeit des Programms. Die Regeln für ihre Sichtbarkeit entsprechen denen von Instanzvariablen.

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de