Version vom 11. März 2016, 17:38 Uhr

Blöcke gehören zu den sogenannten Kontrollstrukturen.

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.

Syntaxdiagramm

Verwendung

Ein Block wird durch eine sich ö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 Blocks Variablennamen außerhalb des Blocks überdecken. Dies geschieht, indem der Name der äußeren Variablen innerhalb des Blocks neu deklariert wird. Damit hat der Name der Variablen innerhalb eines Blockes eine neue Bedeutung. Wird der Block jedoch verlassen, sind alle innerhalb des Blocks deklarierten Variablen nicht mehr sichtbar und damit praktisch gelöscht. Variablen, deren Namen innerhalb des Blocks überdeckt wurden, sind nun wieder sichtbar und haben ihre ursprüngliche Bedeutung außerhalb des Blocks.

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 Programms 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 Blocks von der neu deklarierten Variablen gleichen Namens innerhalb des Blocks durch den Befehl shadow überdeckt. Anders, als wenn man eine Variable innerhalb des gleichen Blocks mehrfach deklariert, ist dies kein Fehler.

Wird innerhalb des Blocks auf eine Variable mit dem Namen x zugegriffen, so wird zuerst nach einer Variablen gesucht, die da drin deklariert wurde. Findet sich eine solche nicht, so wird nach einer Variable außerhalb des Blocks mit diesem Namen gesucht. Da hier die Variable x innerhalb des Blocks 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 zweite Ausgabe ist 5.

Negativbeispiel

[...]
    { /* 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 Blocks nicht sichtbar ist. Sie müsste irgendwo außerhalb des Blocks, 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 Blocks in der gleichen Ebene wird diese Variable nicht wieder sichtbar!