Konstrukte zur Strukturierung

Elemente zur Strukturierung

Elemente zur Strukturierung von Java-Software

Anweisungen (statements)
Blöcke (blocks)
Methoden (methods)
Klassen (classes)
Pakete (packages)
Module (modules)
Java Archive (JAR)
Applikationen (applications)

Die hier aufgeführte Liste zeigt wieder die verschiedenen Stufen der Abstraktion. Während die Anweisungen das kleinste Element sind, aus dem man ein Java-Programm aufbauen kann, nimmt die Abstraktion von Stufe zu Stufe zu. Blöcke gruppieren mehrere Anweisungen, Methoden gruppieren mehrere Blöcke etc.

Klassen

In der objektorientierten Programmierung ist eine Klasse ein Bauplan oder eine Vorlage, die definiert, welche Attribute (Daten) und Methoden (Funktionen) ein Objekt haben wird, das auf Basis dieser Klasse erstellt wird.

Sie beschreibt, welche Eigenschaften und Verhaltensweisen die Objekte haben sollen, die auf Basis dieser Klasse erzeugt werden können. Die Methoden einer Klasse beschreiben, welche Aktionen ein Objekt ausführen kann. Dazu gehören beispielsweise Funktionen zum Verändern der Attribute eines Objekts oder zum Durchführen von Berechnungen.

Klassen sind Baupläne für Objekte, sie beschreiben

die Daten, die ein Objekt tragen kann (Variablen)
das Verhalten, das ein Objekt zeigen kann (Methoden)

Java-Klassen unterstützen objektorientierte Techniken

Abstraktion
Kapselung
Vererbung
Polymorphismus

Variablen

class Variablen {
    static int klassenVariable = 10;
    int member = 15;
    int empty;
    void methode(int i) {
        klassenVariable = 11;
        member++; empty++;
        int empty = 5;
        empty++;
        this.empty = 3;
        {
            int k = 5;
        }
        {
            int k = 6;
        }
    }
}

Wir unterscheiden:

Klassenvariablen – Sie werden in der Klasse mit dem Schlüsselwort static deklariert und existieren unabhängig von den Objekten der Klasse. Pro Klasse (und Classloader) und Klassenvariable gibt es genau einen Wert, unabhängig davon, wie viele Objekte erzeugt wurden. Klassenvariablen werden auch statische Felder (static fields) genannt.
Instanzvariablen – Sie werden in der Klasse deklariert und bestimmen die Daten, die die Objekte später tragen werden. Instanzvariablen werden auch Member-Variablen oder Feld (field) genannt.
Lokale Variablen – Sie können innerhalb einer Methode oder auch eines Blocks deklariert werden. Man nennt sie auch Stack-Variablen (stack variables) oder automatische Variablen (automatic variables).

Lokale Variablen müssen initialisiert werden, bei Klassenvariablen oder Instanzvariablen wird bei fehlender Initialisierung ein Standard-Wert benutzt.

Die Standard-Werte für Klassen und Instanzvariablen sind:

byte, short, int, long → 0
float, double → 0.0
char → '\u0000'
boolean → false
Referenzen → null

Lebensdauer und Sichtbarkeit

Lebensdauer

Klassenvariablen – während der gesamten Laufzeit des Programms
Instanzvariablen – während der Lebensdauer des Objekts
Lokale Variablen – von der Deklaration bis zum Ende des Blocks oder der Methode, in der sie deklariert wurden

Sichtbarkeit

Klassenvariablen, Instanzvariablen – in der gesamten Klasse
Lokale Variablen – von der Deklaration bis zum Ende des Blocks oder der Methode, in der sie deklariert wurden

Korrekterweise muss man sagen, dass Klassenvariablen nicht unbegrenzt leben, sondern beim Laden der Klasse durch den Classloader angelegt werden und beim Entladen der Klasse wieder zerstört werden. Da aber eine Klasse automatisch bei der ersten Verwendung geladen wird und erst entladen und zerstört werden kann, wenn sie nicht mehr in Benutzung ist, fühlt es sich so an, als ob Klassenvariablen während der gesamten Laufzeit des Programms vorhanden sind.

Instanzvariablen werden angelegt, wenn das Objekt mit new erzeugt wurde und sie werden zerstört, wenn das Objekt vom Garbage-Collector vernichtet wird.

Lokale Variablen werden beim Betreten der Methode von der Java-VM angelegt und vernichtet, wenn die Methode zurückkehrt. Der Compiler sorgt aber dafür, dass der Zugriff auf die Variablen erst nach der Deklaration erfolgen kann. Technisch wird die Erzeugung und Vernichtung von lokalen Variablen über einen Stack realisiert.

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. Auf verdeckte Instanzvariablen kann man mit der this-Referenz zugreifen, auf verdeckte Klassenvariablen mit dem Namen der Klasse. Das Thema Verdecken von Variablen wird später noch einmal aufgegriffen.

Die Sichtbarkeit von Klassen- und Instanzvariablen wird noch von den Schlüsselworten public, protected und private beeinflusst, die später eingeführt werden.

Beispiel: Scope und Speicherlayout

class Scope {
    int i = 1;
    void methode1() {
      int i = 4; int j = 5;
      this.i = i + j;
      methode2(7);
    }

    void methode2(int i) {
        int j=8;
        this.i = i + j;
    }

    public static void main(String[] args) {
        Scope s = new Scope();
        s.methode1();
    }
}

Das Bild zeigt, wie von der Java-VM für jeden Methodenaufruf ein Bereich auf dem Stack angelegt wird. In diesem Bereich finden sich sowohl die lokalen Variablen, als auch die Parameter der Methode. Aus Sicht des Stacks sind lokale Variablen und Parameter identisch. Beide werden beim Betreten der Methode angelegt und beim Verlassen abgeräumt.

Zusätzlich hat jede Methode (solange sie nicht statisch ist) eine Referenz auf das eigene Objekt (this).