Version vom 7. Dezember 2015, 13:54 Uhr

Ein Block fasst mehrere sequenzielle Anweisungen zu einer syntaktischen Einheit zusammen. Dies vereinfacht die syntaktische Überprüfung von Programmen für den Compiler und hilft bei der Strukturierung von Programmen.

In den meisten imperativen Programmiersprachen helfen Blöcke auch dabei, Variablen zu überdecken. Dabei können Namen von Variablen mehr als ein mal verwendet werden. Jedoch sind dabei die überdeckten Variablen innerhalb des Blockes nicht mehr zu verwenden.

Syntaxdiagram

Verwendung

Ein Block wird durch eine öffnende und schließende geschweifte Klammer gekennzeichnet: { ... } Alle Anweisungen innerhalb dieses Blockes werden dann in der Syntaxanalyse des Compilers als eine einzelne Anweisung behandelt. Somit kann man z.B. alle im Block verwendeten Anweisungen bedingt oder wiederholt ausführen lassen.

Überdeckung

Man kann innerhalb eines Blockes, Variablennamen außerhalb des Blockes überdecken. Dies geschieht, indem der Name der äußeren Variablen innerhalb des Blockes neu deklariert wird. Damit hat der Name der Variablen innerhalb eines Blockes eine neue Bedeutung. Wird der Block jedoch verlassen, sind alle innerhalb des Blockes deklarierten Variablen nicht mehr sichtbar und sind damit praktisch gelöscht. Variablen, deren Namen innerhalb des Blockes überdekt wurden, sind nun wieder sichtbar und haben ihre ursprüngliche Bedeutung außerhalb des Blockes.

Beispiele

[...]
    int x = 5;
    { /* modify x and print */
        x = x + 10;
        System.out.println(x);
    }
    System.out.println(x);
[...]

Das obere Codefragment deklariert eine Variable x und fasst das Erhöhen dieser Variablen und ihre Ausgabe auf der Konsole in einem Block zusammen. In diesem Beispiel hat der Block keinen weiteren Nutzen als dem lesenden Programmierer die beiden Zeilen hervorzuheben. Die Ausgabe des Programmes ist daher zwei mal "15".

[...]
    int x = 5;
    { /* shadow x and print */
        int x = 10;
        System.out.println(x);
    }
    System.out.println(x);
[...]

In diesem Beispiel wird die Variable x außerhalb des Blockes von der neu deklarierten Variablen innerhalb des Blockes überdeckt. Anders, als wenn man eine Variable innerhalb des gleichen Blockes mehrfach deklariert, ist dies kein Fehler! Wird innerhalb des Blockes auf eine Variable mit dem Namen x zugegriffen, so wird zuerst nach einer Variablen gesucht, die innerhalb des Blockes deklariert wurde. Findet sich keine solche, so wird nach einer Variable außerhalb des Blockes mit diesem Namen gesucht. Da die Variable x innerhalb des Blockes mit dem Wert 10 deklariert und initialisiert wurde, ist die erste Ausgabe des Programmfragmentes "10". Die zweite Ausgabe des Programmfragmentes findet außerhalb des Blockes statt, wo die innere Variable des Blockes nicht mehr sichtbar^[1] ist. Somit wird auf die Variable x mit dem Wert 5 zugegriffen und die 2. Ausgabe ist "5".

[...]
    { /* declare and print x */
        int x = 10;
        System.out.println(x);
    }
    System.out.println(x);
[...]

Dieses Codefragment würde nicht compilieren, da die Variable x außerhalb des Blockes nicht sichtbar ist. Sie müsste irgendwo außerhalb des Blockes, vor Aufruf der println()-Methode deklariert und initialisiert worden sein.

Fußnoten

1. ↑ Sie ist ab diesem Moment sogar nicht mehr existent; Durch das öffnen eines weiteren Blockes in der gleichen Ebene wird diese Variable nicht wieder sichtbar!