Anforderungen an final-Variablendeklarationen in Java 

Ein Programm muß gemäß der Syntax (Syntaxdiagramme) aufgebaut sein. Darüber hinaus werden aber auch noch weitere Anforderungen an ein Programm gestellt. Diese Lektion behandelt Anforderungen, die an eine final-Variablendeklaration gestellt werden.

Leerraum in einer final-Variablendeklaration

Der Typ einer final-Variablendeklaration muß vom folgenden Bezeichner durch Leerraum  getrennt werden.

Hier fehlt Leerraum

final inta = 2;
final doublex = 2.724;
final java.lang.Stringtext = "abc";

Eine Implementation versucht beim Lesen von Quelltext immer möglichst lange  lexikalische Einheiten zu bilden. Daher würde der Typ »int« mit einem ihm direkt folgenden Bezeichner »a« (dem Leerraum folgt) zu einer lexikalischen Einheit »inta« verbunden werden. Um dies zu verhindern, ist Leerraum hinter »int« notwendig.

Zwischen dem »a« und dem folgenden Gleichheitszeichen »=« in »final int a = 2;« wird jedoch kein Leerraum benötigt, da es keine Möglichkeit gibt, eine lexikalische Einheit »a« mit einem Gleichheitszeichen zu einer lexikalischen Einheit zu verbinden, da es in Java  keine lexikalische Einheit gibt, die mit »a=« beginnt. Der ist vor dem Gleicheitszeichen »=« kein Leerraum nötig und die final-Variablendeklarationsanweisung »final int a= 2;« ist möglich.

Auch das Wort »final« muß vom folgenden Typ durch Leerraum  getrennt werden.

Auch hier fehlt Leerraum

finalint a = 2;
finaldouble x = 2.724;
finaljava.lang.String text = "abc";

Allgemein müssen zwei Bezeichnerzeichenfolgen immer durch Leerraum getrennt werden, wenn sie sonst direkt aufeinander folgen würden und nicht zu einem einzigen Bezeichnerzeichenfolge verschmelzen sollen.

Anforderungen an den Typnamen im Syntaxdiagramm

final-Variablendeklaration (vereinfachtes Syntaxdiagramm)

final-Variablendeklaration
     .-----.         .-----.        .------------.      .-.      .----------.
--->( final )---.--->| Typ |---.--->| Bezeichner |---->( = )---->| Ausdruck |--->
     '-----'    |    '-----'   ^    '------------'      '-'      '----------'
                |     .---.    |
                '--->( var )---'
                      '---'
Typ
          .---.
---.---->( int )---->.--->
   |      '---'      ^
   |     .------.    |
   '--->( long   )---'
   |     '------'    |
   |     .------.    |
   '--->( double )---'
   |     '------'    |
   |     .------.    |
   '---->| Name |----'
         '------'

Der »Name« im obenstehenden Syntaxdiagramm muß der Name eines Typs sein.

Die Angabe »void« ist kein  möglicher Variablentyp.

Typ des Initialisierungsausdrucks

Der Typ  eines zur Initialisierung einer Variablen verwendete Initialisierungsausdrucks muß ein Untertyp  des Typs der Variablen sein (so wie der Typ eines Arguments  ein Untertyp des Typs des dazugehörigen Parameters  sein muß).

Dies erlaubt es, einen int-Ausdruck zur Initialisierung einer double-Variablen zu verwenden.

Das folgende Programmbeispiel zeigt, wie von solchen Umwandlungen Gebrauch gemacht wird: Ein Literal vom Datentyp »int« wird zur Initialisierung einer Variablen vom Typ »double« verwendet.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double d = 300; 
    java.lang.System.out.println( d ); }}

java.lang.System.out

300.0

Das folgende Beispiel zeigt, daß ein Versuch zur Initialisierung einer int-Variablen mit einem double -Literal scheitert, weil hier Nachkommastellen verloren gehen würden (selbst wenn sie alle gleich 0 sind).

Main.java

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

Konsole

Main.java:3: error: possible loss of precision
  { final int i = 300.0;
                  ^
  required: int
  found:    double

Aus Sicht der Sprachspezifikation besteht der Grund für den Fehler darin, daß laut Sprachspezifikation »double« kein Untertyp von »int« ist.

Von den bisher behandelten Typen ist jeder Typ Untertyp seiner selbst, und der Typ »int« ist Untertyp von »double«. Andere Untertypbeziehungen existieren bei diesen Typen nicht.

Tabelle

    Variablentyp   Typ des Initialisierungsausdrucks
          double   int, long, double
            long   int, long
             int   int
java.lang.String   java.lang.String

ℛ Substitutionsregel Wird ein Ausdruck eines Typs (wie beispielsweise »double«) erwartet, so kann ein Ausdruck eines Untertyps  (wie beispielsweise »int«) angegeben werden.

Allgemein muß beim Kopieren eines Wertes der Typ des Ausdrucks, der die Quelle  des Wert angibt, eine Untertyp  des Typs des Ausdrucks, der das Ziel  des Kopierens angibt, sein. Als Spezialfälle dieser Regel ergeben sich:

• Der Typ eines Argumentausdrucks  muß ein Untertyp des Parametertyps sein.
• Der Typ eines Initialisierungsausdrucks  in einer Variablendeklaration muß ein Untertyp des Typs der Variablen sein.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double x = 3; 
    final long   l = 5; 
    final double y = l; 
    java.lang.System.out.println( x );
    java.lang.System.out.println( l );
    java.lang.System.out.println( y ); }}

Protokoll

3.0
5
5.0