Syntaktische Einheiten in Java

Bei der Beschreibung einer Programmiersprache spricht man einerseits über den Quelltext und andererseits über das Laufzeitgeschehen (also das, was „zur Laufzeit“ passiert – das ist das, was passiert, wenn das Programm läuft).

Die Syntax der Sprache beschreibt nur den Quelltext, die Semantik der Sprache beschreibt die Regeln zur Bestimmung von Typen und die Bedeutung des Quelltextes für das Laufzeitgeschehen.

Ausdrücke und Anweisungen sind syntaktische Einheiten, also Bestandteile des Quelltexts.

In dieser Lektion wird das bisher über Ausdrücke und Anweisungen Gelernte noch einmal zusammengefaßt.

Ausdrücke können zur Laufzeit ausgewertet werden.

Anweisungen können zur Laufzeit ausgeführt werden.

Ausdrücke

Man kann Ausdrücke dadurch charakterisieren, daß ein Ausdruck als Argument, als Operand oder gegebenenfalls als Ausdruck einer Aufrufanweisung verwendet werden kann.

Ein Ausdruck ist eines der in diesem Abschnitt im folgenden beschriebenen Gebilde, also ein Literal, Wertname, Operatorausdruck oder ein Aufrufausdruck.

Ein Methodenname, wie »java.lang.Thread.dumpStack«, ist kein Ausdruck.

Die Auswertung eines Ausdrucks kann eine Wirkung haben und kann einen Wert ergeben.

Die Ausführung einer Anweisung kann eine Wirkung haben, sie ergibt aber nie einen Wert.

Wirkung bedeutet: die Veränderung eines Zustandes (Systems). Diese Veränderung muß nicht direkt beobachtbar sein.

Ein Wert erlangt seine Bedeutung dadurch, daß er als Wert eines Arguments oder Operanden letztendlich an der Bestimmung einer Wirkung teilnimmt. Werte dienen also der Bestimmung und Unterscheidung von Wirkungen.

Wertausdrücke

Ein Wertausdruck ist ein Ausdruck, der einen Wert hat.

Ein Wertausdruck kann auch als Teil eines größeren Ausdrucks vorkommen.

Ein Wertausdruck kann in die Ausgabeanweisung geschrieben werden, wenn eine Darstellung seines Wertes ausgegeben werden soll.

Ein Ausdruck mit Wert hat einen bestimmten Datentyp, der bereits durch den Quelltext bestimmt ist.

Literale

Ein Literal ist ein Wertausdruck, dessen Wert und Typ durch die Programmiersprache festgelegt ist. Ein Literal ist kein Name. Ein Literal enthält keine Operatoren oder Methodenaufrufe.

ganzzahlige Numeralia

0
1
24

Numeralia mit Punkt

1.23
.4
0.

Numeralia mit E

12E3

Zeichenfolgenliterale

"alpha"
""

Wertnamen

Wertnamen bestehen aus Buchstaben, Ziffern, Grundstrichen und Punkten. (Sie beginnen aber nie mit einer Ziffer.)

java.lang.Math.PI
java.lang.Integer.MAX_VALUE

Wertnamen sind Wertausdrücke.

Methodennamen, wie »java.lang.Math.random«, und Typnamen, wie »java.lang.String«, sind keine Ausdrücke.

Ob ein Name ein Wertname, Typnamen oder ein Methodenname ist, kann der Dokumentation entnommen werden.

Der Wert eines Literals wird durch die Sprache definiert, der Wert eines Wertnamens durch die Bibliothek.

Operatorausdrücke

Wertausdrücke mit unären Präfixoperatoren

-2
-1.3

Wertausdrücke mit unären Zirkumfixoperatoren

( 1 )
( "a" )

Wertausdrücke mit binären Operatoren

1/1
1/1.
1 + 1
1 + "1"
1 - 1
1 * 1

Aufrufausdrücke mit Wert

java.lang.Math.random()
java.lang.Math.rint( 2.3 )
java.lang.Math.abs( 5 )
java.lang.System.setProperty( "x", "2" )

Der letzte Aufrufausdruck aus der obigen Liste von Beispielen hat neben dem Wert auch noch eine Wirkung.

Der Aufruf einer Methode hat dann einen Wert, wenn diese in ihrer Dokumentation nicht mit dem Worte »void« vor dem Namen gekennzeichnet ist, sondern an dieser Stelle ein Name eines Datentyps (wie »int«) steht.

Ausdrücke ohne Wert

Ein Ausdruck ohne Wert kann nicht direkt als Teil eines anderen Ausdrucks vorkommen. Beispiele für solche Ausdrücke finden sich weiter unten.

Als Ausdruck ohne Wert kommt nur ein Methodenaufruf in Frage, denn Literale, Namen und Operatorausdrücke haben immer einen Wert.

Der Aufruf einer Methode hat dann keinen Wert, wenn diese in ihrer Dokumentation mit dem Worte »void« vor dem Namen gekennzeichnet ist.

Wirkausdrücke

Wirkausdrücke ohne Wert

java.lang.Thread.dumpStack()
java.lang.System.exit( 99 )

Wirkausdrücke mit Wert

java.lang.System.setProperty( "x", "2" )

Ausdrücke ohne Wirkung

Beispiele für Ausdrücke ohne Wirkung sind Literale und Wertnamen sowie Aufrufe solcher Methoden, für die keine Wirkung dokumentiert ist.

java.lang.Math.abs( 2 )

Ausdrücke ohne Wert und ohne Wirkung

Ausdrücke ohne Wert und ohne Wirkung könnte man in Java zwar schreiben (wie später behandelt werden wird), aber sie werden selten benötigt.

Anweisungen

Eine Anweisung ist eine syntaktische Einheit der im folgenden beschriebenen Form, also eine Ausgabeanweisung, Aufrufanweisung oder ein Block.

Für jede Anweisung ist jeweils festgelegt, was bei ihrer Ausführung passiert.

Ausgabeanweisung

Die Ausführung einer Ausgabeanweisung bewirkt die Ausgabe einer Darstellung des Wertes des in den Klammern enthaltenen Wertausdrucks, der in den folgenden Rahmen durch drei Punkte »…« angedeutet ist.

java.lang.System.out.print( … );

Die ln -Variante gibt anschließend noch ein Zeilenende aus und schließt damit die ausgegebene Zeile ab.

java.lang.System.out.println( … );

Bei der ln -Variante ist auch ein Aufruf ohne Argumente möglich, um nur ein Zeilenende auszugeben.

java.lang.System.out.println();

Aufrufanweisungen

Eine Aufrufanweisung besteht aus einem Aufruf und einem folgenden Semikolon.

Die Ausführung einer Aufrufanweisung bewirkt die Auswertung ihres Aufrufs, dabei ist es egal, ob dieser einen Wert und/oder eine Wirkung hat, jedoch sind hier im allgemeinen nur Wirkausdrücke sinnvoll, da ein eventueller Wert des Aufrufausdrucks ohnehin verloren geht.

Eine Aufrufanweisung ist praktisch eine Anweisung, welche eine Methode aufruft – daher könnte man sie auch „Aufrufanweisung“ nennen.

java.lang.Thread.dumpStack();
java.lang.Math.random();
java.lang.System.setProperty( "x", "2" );

Block

Ein Block besteht aus in geschweiften Klammern eingeschlossenen Anweisungen.

Die Ausführung eines Blocks bewirkt die Ausführung der eingeschlossenen Anweisungen in der gegebenen Reihenfolge.

{ java.lang.System.out.print( 4 ); java.lang.System.out.println( 3 ); }

Semantik

Die Semantik eines Operators oder einer Methode beschreibt den Typ einer Anwendung jenes Operators beziehungsweise eines Aufrufs jener Methode sowie den Wert und die Wirkung einer Auswertung jener Anwendung beziehungsweise jenes Ausdrucks.

Die Semantik einer Anweisung beschreibt die Wirkung der Ausführung jener Anweisung.

Syntaxdiagramme

Eine lexikalische Einheit in den folgenden Syntaxdiagrammen ist jedes gerundete Kästchen, sowie Literale und Namen.

Syntax von Ausdrücken und ihrer Bestandteile

Name
   .-----------------------.
   |    .------.    .-.    v    .------------. 
---'--->| Name |-->( . )---'--->| Bezeichner |--->
        '------'    '-'         '------------'
Ausdruckliste
   .---------------------------.            
   |        .----------.       v
---'---.--->| Ausdruck |---.---'--->
       ^    '----------'   |
       |        .-.        |
       '-------( , )<------'
                '-'
Aufruf
    .-------.     .-.     .---------------.     .-.    
--->| Name  |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '-------'     '-'     '---------------'     '-'
Primaerausdruck
          .-.     .----------.     .-.    
--->.--->( ( )--->| Ausdruck |--->( ) )--->.--->
    |     '-'     '----------'     '-'     ^
    |             .----------.             |
    '------------>| Literal  |-------------'
    |             '----------'             |
    |             .----------.             |
    '------------>| Aufruf   |-------------'
                  '----------'
Postfixausdruck
         .-----------------.
--->.--->| Primaerausdruck |---.--->
    |    '-----------------'   ^
    |    .-----------------.   |
    '--->| Name            |---'
         '-----------------'
Vorzeichenausdruck
                 .--------------------.
---.------------>| Postfixausdruck    |----.---->
   |             '--------------------'    ^
   |     .-.     .--------------------.    |
   '--->( - )--->| Vorzeichenausdruck |----'
   |     '-'     '--------------------'    |
   |     .-.     .--------------------.    |
   '--->( + )--->| Vorzeichenausdruck |----'
         '-'     '--------------------'
Multiplikativausdruck
        .-----------------------.
---.--->| Vorzeichenausdruck    |--------------------------------------.--->
   |    '-----------------------'                                      ^
   |    .-----------------------.     .-.     .--------------------.   |
   '--->| Multiplikativausdruck |--->( * )--->| Vorzeichenausdruck |---'
   |    '-----------------------'     '-'     '--------------------'   |
   |    .-----------------------.     .-.     .--------------------.   |
   '--->| Multiplikativausdruck |--->( / )--->| Vorzeichenausdruck |---'
        '-----------------------'     '-'     '--------------------'
Additivausdruck
        .-----------------------.
---.--->| Multiplikativausdruck |-----------------------------------------.--->
   |    '-----------------------'                                         ^
   |    .-----------------------.     .-.     .-----------------------.   |
   '--->| Additivausdruck       |--->( + )--->| Multiplikativausdruck |---'
   |    '-----------------------'     '-'     '-----------------------'   |
   |    .-----------------------.     .-.     .-----------------------.   |
   '--->| Additivausdruck       |--->( - )--->| Multiplikativausdruck |---'
        '-----------------------'     '-'     '-----------------------'
Ausdruck
    .-----------------.
--->| Additivausdruck |--->
    '-----------------'

Zusätzliche Anforderungen an Namen in Ausdrücken (läßt sich nicht den Syntaxdiagrammen entnehmen)

Wenn ein Name als Ausdruck verwendet werden soll, so muß dies ein Name einer Variablen sein. Der Name einer Methode, einer Klasse, eines Paketes oder eines Moduls ist kein Ausdruck.

Wenn ein Name am Anfang eines Aufrufs verwendet werden soll, so muß dies der Name einer Methode sein.

Ausgabeanweisung (Syntaxdiagramm)

Ausgabeanweisung
      .----.      .-.      .----.      .-.      .------.      .-.   
---->( java )--->( . )--->( lang )--->( . )--->( System )--->( . )---.
      '----'      '-'      '----'      '-'      '------'      '-'    |
.--------------------------------------------------------------------'
|     .---.      .-.      .-------.     
'--->( out )--->( . )--->( println )---.
      '---'      '-'      '-------'    |
.--------------------------------------'  
|     .-.         .----------.         .-.      .-.
'--->( ( )---.--->| Ausdruck |---.--->( ) )--->( ; )--->
      '-'    |    '----------'   ^     '-'      '-'
             '-------------------'

Ausgabeanweisung (Syntaxdiagramm)

Ausgabeanweisung
      .----.      .-.      .----.      .-.      .------.      .-.   
---->( java )--->( . )--->( lang )--->( . )--->( System )--->( . )---.
      '----'      '-'      '----'      '-'      '------'      '-'    |
.--------------------------------------------------------------------'
|     .---.      .-.      .-----.     
'--->( out )--->( . )--->( print )---.
      '---'      '-'      '-----'    |
.--------------------------------------'  
|     .-.     .----------.     .-.      .-.
'--->( ( )--->| Ausdruck |--->( ) )--->( ; )--->
      '-'     '----------'     '-'      '-'

Aufrufanweisung

Aufrufanweisung
     .--------.      .-.
---->| Aufruf |---->( ; )---->
     '--------'      '-'

Block

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

Anweisung

Anweisung
         .------------------.
----.--->| Ausgabeanweisung |----.--->
    |    '------------------'    |
    |    .------------------.    |
    '--->| Aufrufanweisung  |----'
    |    '------------------'    |
    |    .------------------.    |
    '--->| Block            |----'
         '------------------'

Aussprachen

int ɪnt

thread θrɛd

property ˈprɑp ɚ ti

Übungen

Zur Lösung von Übungsaufgaben sollten immer nur die bisher schon behandelten Syntaxregeln der Sprache verwendet werden. Es dürfen aber alle Einträge der Standardbibliothek verwendet werden.