Die bedingte Ausführung in Java 

Diese Lektion wird derzeit (2020) gerade überarbeitet. Während der Überarbeitung kann sie noch Mängel aufweisen.

Syntax der bedingten Ausführung

Die if-Anweisung ist eine Anweisung. Sie wird mit dem Schlüsselwort »if« eingeleitet.

Die if-Anweisung

if-Anweisung
     .--.      .-.     .-----------.     .-.     .------------.
--->( if )--->( ( )--->| Ausdruck  |--->( ) )--->| Anweisung  |--->
     '--'      '-'     '-----------'     '-'     '------------'

Anweisungen

Anweisung
        .--------------------------------------.
---.--->| Ausgabeanweisung                     |----.--->
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Aufrufanweisung                      |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Zuweisungsanweisung                  |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Block                                |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Variablendeklarationsanweisung       |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Rueckgabeanweisung                   |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| if-Anweisung                         |----'
        '--------------------------------------'

Nach ihrem einleitenden Schlüsselwort if  wird die Anweisung zur bedingten Ausführung auch if-Anweisung  oder kurz „if “ genannt.

Die Anweisung hinter der runden Klammer zu »)« wird auch die innere Anweisung  oder der Rumpf  der if-Anweisung genannt. Diese innere Anweisung darf keine Variablendeklarationsanweisung  sein.

“if ” /ɪf/ „wenn“

Die if-Anweisung ohne den Rumpf nennen wir auch den Kopf  der if-Anweisung.

Der if-Kopf

if-Kopf
     .--.      .-.     .-----------.     .-.
--->( if )--->( ( )--->| Ausdruck  |--->( ) )--->
     '--'      '-'     '-----------'     '-'

Typanforderungen

Der Ausdruck muß den Typ »boolean« haben.

Semantik (Verhalten) der if-Anweisung: der Ausdruck

Bei der Ausführung einer Anweisung dieser Art wird zunächst der Ausdruck ausgewertet.

Im Falle des folgende Programms ist der Ausdruck der if-Anweisung gleich »druckHallo()«.

Main.java

public final class Main
{
  public static boolean druckHallo()
  { java.lang.System.out.println( "Hallo" ); return false; }
  public static void main( final java.lang.String[] args)
  { if( druckHallo() ){} }}

transcript

Hallo

Das obenstehende Hauptprogramm demonstriert übrigens deutlich, daß die oft zu lesende Aussage „Jede Anweisung in Java  muß mit einem Semikolon abgeschlossen werden.“ falsch  ist.

Zum Vergleich, dasselbe mit der Aufrufanweisung:

Main.java

public final class Main
{
  public static boolean druckHallo()
  { java.lang.System.out.println( "Hallo" ); return false; }
  public static void main( final java.lang.String[] args)
  { druckHallo(); }}

transcript

Hallo

Semantik (Verhalten) der if-Anweisung: die innere Anweisung

Die innere Anweisung wird genau dann ausgeführt, wenn der Ausdruck den Wert true  hat.

Beispiel

{ if( false )java.lang.System.out.println( "false" );
  if( true  )java.lang.System.out.println( "true"  ); }

Das obige Beispiel gibt »true« aus.

Die innere Anweisung wird also nur unter einer bestimmten Bedingung ausgeführt – sie wird bedingt  ausgeführt.

Die if-Anweisung mit beschreibenden Begriffen

Anweisung
     .--.      .-.     .-----------.     .-.     .------------.
--->( if )--->( ( )--->| Ausdruck  |--->( ) )--->| Anweisung  |--->
     '--'      '-'     '-----------'     '-'     '------------'
                         Bedingung                 Konsequenz 

Schlüsselwörter

»if« ist ein Schlüsselwort.

Die bisher behandelte Schlüsselwörter

»boolean«, »double«, »final«, »if«, »int«, »long«, »public«, »return«, »static«, »void«

Der Block als innere Anweisung

Main.java

public final class Main
{ public static void main( final java.lang.String[] args)
  { if( true  )
    { java.lang.System.out.println( "Haus"   );
      java.lang.System.out.println( "Hof"    ); }
    if( false )
    { java.lang.System.out.println( "Garten" );
      java.lang.System.out.println( "123"    ); }}}

transcript

Haus
Hof

Beispiel Statischer Ein- oder Ausschluß von Anweisungen ⃗

Durch Voranstellen von »if( false )« kann eine Anweisung ausgeblendet werden, ähnlich wie ein Zeilenende durch Voranstellen von »//« auskommentiert werden kann.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args)
  { if( false )
    { java.lang.System.out.println( "Haus" ); 
      java.lang.System.out.println( "Hof" ); 
      java.lang.System.out.println( "Garten" ); }}}

java.lang.System.out

keine Ausgabe 

Die Verwendung von »if( false )« hat jedoch Eigenschaften, die manchmal als vorteilhaft angesehen werden können:

• Das »if( false )« bezieht sich immer auf die folgende innere Anweisung, so daß das Ende des Kommentars nicht mehr falsch gesetzt werden kann, wenn genau eine Anweisung auskommentiert werden soll.
• Die Java -Implementation prüft die Korrektheit der ausgeblendeten inneren Anweisung weiterhin, so daß Fehler – etwa nach einer Überarbeitung des Programms – eher bemerkt werden.
• Durch Austausch von »false« gegen »true« kann die ausgeblendete innere Anweisungen leicht wieder eingeblendet werden. – Beim Auskommentieren wären Veränderungen an mindestens zwei Stellen nötig (am Anfang und am Ende des Kommentars), und klassische Kommentare können – anders als if-Anweisungen – auch nicht verschachtelt werden.
• Durch Austausch von »false« gegen eine Wahrheits-Variable können mehrere zusammengehörige Anweisungen an verschiedenen Stellen eines Programms bequem gleichzeitig  ein- oder ausgeblendet werden.

Aussprache

Java 

if( x )java.lang.System.out.println( "z" );

auf deutsch:

„falls »x« (gilt), dann schreibe »z«“

Beispiel Ausgabe einer bestimmten Anzahl von Sternen

Die Methode »stern« gibt so viele Sterne aus, wie ihr Argumentwert angibt; allerdings geschieht dies nur, falls der Argumentwert nicht größer als 4 ist.

Main.java

public final class Main
{ 
  public static void stern( final int n )
  { if( n > 0 )java.lang.System.out.print( "*" ); 
    if( n > 1 )java.lang.System.out.print( "*" ); 
    if( n > 2 )java.lang.System.out.print( "*" ); 
    if( n > 3 )java.lang.System.out.print( "*" ); }
  public static void main( final java.lang.String[] args)
  { stern( 2 ); stern( 1 ); java.lang.System.out.println(); }}

transcript

***

Kombinationen ⃗

Kombination der if-Anweisung mit einem Parameter ⃗

Main.java

public final class Main
{ 
  public static void m( final boolean b )
  { if( b )
    java.lang.System.out.println( b ); }
  public static void main( final java.lang.String[] args)
  { m( false );
    m( true  ); }}

transcript

true

Kombination der if-Anweisung mit einem Prädikat ⃗

Main.java

public final class Main
{ public static void main( final java.lang.String[] args)
  { java.lang.System.out.println( java.lang.Character.isLetter( 64 ));
    java.lang.System.out.println( java.lang.Character.isLetter( 65 )); }}

transcript

false
true

Main.java

public final class Main
{ 
  public static void check( final int c )
  { if( java.lang.Character.isLetter( c )== false )
    java.lang.System.out.println
    ( "Das Zeichen " + c + " ist kein Buchstabe." ); }
  public static void main( final java.lang.String[] args)
  { check( 64 );
    check( 65 ); }}

Protokoll

Das Zeichen 64 ist kein Buchstabe.

Übungsfragen

Übungsfrage (Syntax)

Was sind die inneren Anweisungen (Konsequenzen) in dem folgenden Programm?

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { if( 4 == 2 )java.lang.System.out.println( "A" ); java.lang.System.out.println( "B" );
    if( 3 == 3 )java.lang.System.out.println( "C" ); }}

Übungsfrage

Was gibt das folgende Programm aus?

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { if( 4 == 2 )java.lang.System.out.println( "A" ); java.lang.System.out.println( "B" );
    if( 3 == 3 )java.lang.System.out.println( "C" ); }}

Übungsfrage

Soll »a« und »b« ausgeben, dann und nur dann wenn »x == 12«

if( x == 12 )
  java.lang.System.out.println( "a" );
  java.lang.System.out.println( "b" );   

Wie kann man den Fehler der obigen if-Anweisung (mit möglichst wenig Änderungen) korrigieren?

/   Überprüfung eines Ergebnisses

Schreiben Sie ein Programm, welches überprüft, ob eine von »java.lang.Math.random()« gelieferte Zufallszahl wirklich im Bereich von 0 (einschließlich) bis 1 (ausschließlich) liegt, indem Sie dabei folgendermaßen vorgehen: Rufen Sie eine solche Zufallszahl ab und geben Sie das Wort »Fehler!« aus, falls diese sich nicht in jenem Bereich befindet.

Übungsfrage *

Weiter oben wurde die folgende main-Methode gezeigt. Fehlt am Ende der if-Anweisung nicht ein Semikolon?

  public static void main( final java.lang.String[] args)
  { if( druckHallo() ){} }

Übungsfrage *

Welche Anweisung muß man am Ende des Rumpfs der Deklaration der Methode »stern« noch hinzufügen, damit diese nicht nur bis zum Wert 4, sondern bis zu beliebig großen Werten des Parameters n, n  Sterne ausgibt?

?   Übungsfrage 13

Welche Ausgabe erzeugt das folgende Programm?

(Falls eine Rückgabeanweisung in einer if-Anweisung enthalten ist, dann muß sie nicht unbedingt die letzte Anweisung in einer Methodendeklaration sein. Durch die Ausführung einer if-Anweisung wird die Methode aber wie bisher verlassen und der Wert des Rückgabeausdrucks wird zum Wert des zugehörigen Aufrufs.)

Main.java

public final class Main
{ 
  public static int f( final boolean b )
  { if( b )return 4;
    return 2; }
  public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( f( true  ));
    java.lang.System.out.println( f( false )); }}

Übungsaufgaben

/   Schreiben einer if-Anweisung (Syntax) 0

Schreiben Sie eine if-Anweisung mit der Bedingung »a« und der Konsequenz »java.lang.System.out.println( n );«.

Die if-Anweisung mit beschreibenden Begriffen

Anweisung
     .--.      .-.     .-----------.     .-.     .------------.
--->( if )--->( ( )--->| Bedingung |--->( ) )--->| Konsequenz |--->
     '--'      '-'     '-----------'     '-'     '------------'

Die Lösung soll auf einer von Leerzeilen umgebenden Zeile für sich stehen.

/   Schreiben einer if-Anweisung (Syntax) 1

Schreiben Sie eine if-Anweisung mit der Bedingung »a < 0« und der Konsequenz »{ java.lang.System.out.println( n ); java.lang.System.out.println( m ); }«.

Die if-Anweisung mit beschreibenden Begriffen

Anweisung
     .--.      .-.     .-----------.     .-.     .------------.
--->( if )--->( ( )--->| Bedingung |--->( ) )--->| Konsequenz |--->
     '--'      '-'     '-----------'     '-'     '------------'

Die Lösung soll auf einer von Leerzeilen umgebenden Zeile für sich stehen.

/   Schreiben einer Methodendeklaration

Schreiben Sie eine Deklaration einer void-Methode »printHallo«, die einen Parameter »p« vom Typ »boolean« besitzt und »Hallo« ausgibt, genau dann wenn »p« »true« ist. In der Methode soll eine if-Anweisung (kein ternärer Operator) verwendet werden, um »Hallo« genau dann auszugeben, wenn »p« gleich »true« ist.

(„Genau dann“ bedeutet „dann und nur dann“.)

/   Schreiben einer Methodendeklaration

Schreiben Sie eine Deklaration einer void-Methode »printFalse«, die einen Parameter »p« vom Typ »boolean« besitzt und »Falsch« ausgibt, genau dann wenn »p« »false« ist. In der Methode soll eine if-Anweisung (kein ternärer Operator) verwendet werden, um »Falsch« genau dann auszugeben, wenn »p« gleich »false« ist.

/   Erweiterung einer Methodendeklaration

Erweitern Sie die folgende Methodendeklaration so, daß sie (zusätzlich zu »n«) ausgibt: „Vorrat verbraucht, nachbestellen!“, genau dann wenn »n« kleiner als »1« ist. Verwenden Sie hierzu nicht den ternären Operator »?:«, sondern eine if-Anweisung, die hinter der derzeit vorhandenen Ausgabeanweisung eingefügt werden soll.

Paraphrase der zu erstellenden if-Anweisung (Pseudocode)

Wenn n kleiner als Eins ist, dann schreibe „Vorrat verbraucht, nachbestellen!“

Methodendeklaration

public static void vorratAusgeben( final int n )
{ java.lang.System.out.println( n ); }

/   Schreiben einer Methodendeklaration

Schreiben Sie eine Deklaration einer void-Methode, die ausgibt „bestanden“, falls der Wert ihres int-Argumentes größer als 4 ist, und sonst „nicht bestanden“. Verwenden Sie hierzu nicht den ternären Operator »?:«, sondern eine oder mehrere if-Anweisungen.

Graphische Darstellungen Programmablaufpläne *

Das folgende Beispiel zeigt die Veranschaulichung einer if -Anweisungen mit einem Programmablaufplan (DIN 66001), auch „Flußdiagramm“ genannt.

Java -Anweisung

if( n == 0 )java.lang.System.out.print( "*" );

Programmablaufplan

                     |
                     |
                     |
                     v
                   .-'-.
                .-'     '-.
             .-'           '-.  true
            -     n == 0      -----------------.
             '-.           .-'                 |
                '-.     .-'                    |
                   '-.-'                       |
                     | false                   |
                     |                         v
                     |                    ---------------
                     |                   /              /
                     |                  / Ausgabe "*"  /
                     |                 /              /
                     |                 ---------------
                     |                         |
                     |                         |
                     |                         |
                     |                         |
                     |<------------------------'
                     |
                     |
                     v

Graphische Darstellungen Struktogramme *

Das folgende Struktogramm (gemäß DIN 66261 nach Nassi und Shneiderman ACM SIGPLAN Notices 8, August 1973) zeigt die Darstellung der folgenden Java -Anweisung als Struktogramm.

Java -Anweisung

if( n == 0 )java.lang.System.out.print( "*" );

Struktogramm

.-----------------------------------------.
|'-.                                   .-'|
|   '-.                             .-'   |
|      '-.        n == 0         .-'      |
|         '-.                 .-'         |
|   true     '-.           .-'   false    |
|               '-.     .-'               |
|------------------'-.-'------------------|
| Ausgabe "*"        |                    |
'-----------------------------------------'

Struktogramm (vereinfachte Form)

.-----------------------------------------.
|                 n == 0                  |
| true               | false              |
|--------------------|--------------------|
| Ausgabe "*"        |                    |
'-----------------------------------------'

Programmablaufpläne und Struktogramme können nur die if-Anweisungen, nicht aber den ?:-Operator bildlich darstellen. Daher kann ihre Verwendung zu einem Programmierstil führen, der if-Anweisungen auch dann verwendet, wenn der ?:-Operator eine bessere Lösung wäre. Wegen dieser schlechten Einflüsse solcher bildlicher Darstellungen auf den Programmierstil, ist es vielleicht besser, auf sie zu verzichten.

Der bedingte Rücksprung / Verlassen von void-Methoden mit »return;« *

In einer void -Methode kann die Rückgabeanweisung »return;« ohne Rückgabeausdruck zum „Verlassen“ der Methode verwendet werden.

In dem folgenden Programmbeispiel wird dadurch erreicht, daß eine bestimmte Anweisung (»java.lang.System.out.println( b );«) ausgeführt wird, wenn eine bestimmte Bedinung (»b«) nicht  gleich »true« ist.

Main.java

public final class Main
{ 
  public static void m( final boolean b )
  { if( b )return; /* zur Negation! */
    java.lang.System.out.println( b ); }
  public static void main( final java.lang.String[] args)
  { m( false );
    m( true  ); }}

transcript

false

Main.java

public final class Main
{ 
  public static void m( final int i )
  { if( i == 0 )return;
    java.lang.System.out.println( "Der Wert ist nicht 0." ); }
  public static void main( final java.lang.String[] args)
  { m( 2 ); 
    m( 1 ); 
    m( 0 ); }}

transcript

Der Wert ist nicht 0.
Der Wert ist nicht 0.

Kombination aus Block als innerer Anweisung und bedingtem Rücksprung:

Main.java

public final class Main
{ 
  public static void m( final int i )
  { if( i == 0 ){ java.lang.System.out.println( "Der Wert ist 0." ); return; }
    java.lang.System.out.println( "Der Wert ist nicht 0." ); }
  public static void main( final java.lang.String[] args)
  { m( 2 ); 
    m( 1 ); 
    m( 0 ); }}

transcript

Der Wert ist nicht 0.
Der Wert ist nicht 0.
Der Wert ist 0.

Viele if-Anweisungen können kürzer mit dem ternären Operator  geschrieben werden. Dieser kann jedoch keine Anweisungen, wie die return-Anweisung enthalten, sondern nur Ausdrücke. Daher ist die Steuerung einer return-Anweisung ein Beispiel für einen Fall, in dem man wirklich eine if-Anweisung braucht.

Bedingte Rückgaben *

Früher haben wir festgestellt, daß es nicht erlaubt ist, daß einer return-Anweisung in einer Methode noch Anweisungen folgen, da diese ohnehin nicht ausgeführt werden würden. Das folgende Programmbeispiel zeigt nun jedoch, daß es auch Fälle gibt, in denen einer return-Anweisung noch andere Anweisungen sinnvoll folgen können, weil ein in einer if-Anweisung enthaltenes »return« möglicherweise nicht immer ausgeführt wird.

Die folgende Methode »istNegativ« gibt true  zurück genau dann, wenn ihr Argumentwert negativ ist: Bei der eventuellen Ausführung der ersten return -Anweisung wird die Ausführung der Methode abgebrochen, und die zweite return -Anweisung wird dann nicht  ausgeführt.

Main.java

public final class Main
{
  public static boolean istNull( final int a )
  { if( a == 0 )return true;
    return false; }
  public static void print( final int a )
  { java.lang.System.out.println
    ( a + " ist " +( istNull( a )? "" : "nicht " )+ "Null." ); }
  public static void main( final java.lang.String[] args )
  { print( -1 ); print( 0 ); print( 1 ); }}

transcript

-1 ist nicht Null.
0 ist Null.
1 ist nicht Null.

Strukturierte Programmierung *

Man bezeichnet Anweisungen, welche die Ausführung eines Blocks beenden, als Ausgänge  des Blocks. Das Ende des Blocks, also »}«, gilt ebenfalls als Ausgang des Blocks.

Mehrere Ausgänge eines einzigen Blocks erschweren das das Anfügen von Test von Nachbedingunge und das Auslagern von Code-Blöcken in eine extra Methode.

Die strukturierte Programmierung  verlangt daher:

Jeder Block darf nur einen Ausgang haben!

Im Falle der return-Anweisung ergibt sich daraus: „Jede Wertmethode sollte nur eine return-Anweisung haben, und diese sollte die letzte Anweisung im Methodenrumpf sein.“

Jedoch sind Probleme mit der Übersichtlichkeit bei kurzen  Methoden weniger schwerwiegend. Daher haben es heute einige Programmierer aufgegeben, immer streng strukturiert zu programmieren und beherzigen eher die Regel: „Eine Methode sollte nicht zu groß sein!“. Die genaue Grenze der Größe einer Methode ist dabei nicht festgelegt, aber oft hört man, daß eine Methode, die nicht mehr auf den Bildschirm paßt, zu groß sei.

Das folgende Programm zeigt, wie sich das Prädikat »istNull« auch mit nur einem  Ausgang implementieren läßt.

Main.java

public final class Main
{
  public static boolean istNull( final int a )
  { boolean result = false;
    if( a == 0 )result = true;
    return result; }
  public static void print( final int a )
  { java.lang.System.out.println
    ( a + " ist " +( istNull( a )? "" : "nicht " )+ "Null" ); }
  public static void main( final java.lang.String[] args )
  { print( -1 ); print( 0 ); print( 1 ); }}

transcript

-1 ist nicht Null
0 ist Null
1 ist nicht Null

Java  stellt sicher, daß eine Methode in jedem Fall  einen Wert des deklarierten Rückgabetyps liefert.

Main.java

public final class Main
{
  public static int zahl()
  { if( java.lang.Math.floor( java.lang.Math.random() * 2 )== 1 )return 1; }
  public static void main( final java.lang.String[] args ){} }

transcript

Main.java:5: error: missing return statement
  { if( java.lang.Math.floor( java.lang.Math.random() * 2 )== 1 )return 1; }
                                                                           ^
1 error

Die beste Art, eine »istNull«-Methode zu schreiben, zeigt aber der folgende Quelltext. Die vorher gezeigte Beispiele waren unnötig umständlich, da sie auch noch eine if-Anweisung und eine return-Anweisung enthalten sollten.

public static boolean istNull( final int a ){ return a == 0; }

Anweisungen und Blockeinträge *

Da eine Variablendeklaration nicht als innere Anweisung einer if-Anweisung verwendet werden darf, entziehen wir ihr hier den Status einer Anweisung und bezeichnen sie als Blockeintrag.

Ein Blockeintrag ist alles, was wir bisher „Anweisung“ nannten. Ab jetzt nennen wir nun noch diejenigen Blockeinträge „Anweisung “, die keine Variablendeklarationen sind.

Als innere Anweisung  einer if-Anweisung sind nicht beliebige Blockeinträge erlaubt, sondern nur Anweisungen.

Nicht alle Blockeinträge sind Anweisungen! Eine Variablendeklaration ist beispielsweise ein Blockeintrag, aber keine Anweisung.

Daß eine Variablendeklaration ein Blockeintrag, aber keine Anweisung, ist, bedeutet, daß sie zwar in einem Block wie eine Anweisung als Eintrag verwendet werden darf, aber nicht unbedingt an anderen Stellen, an denen eine Anweisung erwartet wird.

Als Anweisung in einer bedingten Ausführung ist eine Variablendeklaration beispielsweise nicht gestattet; dort wird ausdrücklich eine „Anweisung“, und nicht ein „Blockeintrag“ verlangt.

Der folgende Beispieltext zeigt ein Beispiel für die nicht  mögliche Verwendung eines Blockeintrags an Stelle einer Anweisung.

Main.txt

public final class Main
{ public static void main( final java.lang.String[] args )
  { if( true )int x; }}

Blöcke und Variablendeklarationen

Wir haben schon gelernt, daß ein Block Anweisungen enthalten darf. Aber ist eine Variablendeklaration eine Anweisung?

Ja und Nein! Genauer gesagt ist es so, daß ein Block sogenannte Blockeinträge  enthalten darf. Diese umfassen nicht nur die bisher vorgestellten klassischen Anweisungen, sondern auch Variablendeklarationen. Eine Variablendeklaration ist keine  Anweisung, aber ein Blockeintrag  (englisch “block statement ”). Jedenfalls darf eine Variablendeklaration in einem Block enthalten sein, weil sie ein Blockeintrag  ist (auch, wenn sie keine Anweisung ist) und ein Block Blockeinträge  enthalten darf. Alle anderen bisher vorgestellten Anweisungen sind ebenfalls auch Blockeinträge, so daß sie ebenfalls in einem Block enthalten sein dürfen. Die Gründe für diese merkwürdige Unterscheidung zwischen Anweisungen und Blockeinträge liegen darin, daß es in Java auch einige Stellen gibt, in denen nur Anweisungen, aber keine Blockeinträge, erlaubt sind. Diese Stellen werden aber erst in späteren Lektionen vorgestellt werden.

Ein Block kann ab jetzt nicht mehr nur Anweisungen enthalten, sondern auch andere Arten von Blockeinträge

final-Variablendeklarationseintrag [Syntaxdiagramm]

final-Variablendeklarationseintrag
    .----------------------------.     .-.
--->| final-Variablendeklaration |--->( ; )--->
    '----------------------------'     '-'

Blockeintrag (Syntaxdiagramm)

Blockeintrag
                    .-----------.
---.--------------->| Anweisung |----------------.--->
   |                '-----------'                |
   |    .------------------------------------.   |
   '--->| final-Variablendeklarationseintrag |---'
        '------------------------------------'

Block (Syntaxdiagramm)

Anweisung
      .-.                                      .-.
---->( { )----.-------------------------.---->( } )---->
      '-'     |                         |      '-'
              |    .--------------.     |
              '----| Blockeintrag |<----'
                   '--------------'

Blockeinträge

Ein Block kann ab jetzt nicht mehr nur Anweisungen enthalten, sondern auch andere Arten von Blockeinträge

Wir kennen nun die folgenden Arten von Blockeinträgen:

• Anweisungen (alle Anweisungen sind auch Blockeinträge)
• final-Variablendeklarationseintrag.

Hierarchie der Blockeinträge

                                                                          Blockeintrag
                                                                                |
                                                  .-----------------------------'-----------------------------.
                                                  |                                                           |
                                              Anweisung                                                       |
                                                  |                                                           |
        .-------------------.---------------------:-----------------.-------------------.                     |
        |                   |                     |                 |                   |                     |
Ausgabeanweisung      Aufrufanweisung       if-Anweisung   Zuweisungsanweisung        Block    final-Variablendeklarationseintrag

?   Interpretation von Festlegungen

Welche der folgenden mit einem Kommentar gekennzeichneten Zeilen sind

• Anweisungen,
• Deklarationen, beziehungsweise
• Blockeinträge ?

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { 
    final int v = 2;                   /**/
    java.lang.System.out.println( v ); /**/
    }}