dh-Materialien
Java Tutorial
 

Literale

Ganzzahlige Literale   Fließkommaliterale   Boole’sche Literale   character-Literale   String-Literale   Textblöcke

Ein von null verschiedenes Literal repräsentiert im Quellcode eines Programms entweder einen Wert von elementarem Typ oder ein String-Objekt. Das null-Literal null repräsentiert die Nullreferenz, die gegeben ist, wenn eine Referenzvariable „ins Leere zeigt“, also kein Objekt referenziert (vgl. Referenzvariable ohne Referenz).

Ganzzahlige Literale

Ein ganzzahliges Literal (integer literal) kann in dezimaler Form (zur Basis 10), in hexadezimaler Form (zur Basis 16), in oktaler Form (zur Basis 8) oder in dualer Form (zur Basis 2) geschrieben werden. Ein Literal in hexadezimaler Form beginnt immer mit dem Präfix 0x und besteht ansonsten aus den Ziffern 0 bis 9 und den Buchstaben a bis f oder A bis F. Ein Literal in oktaler Form beginnt mit 0, gefolgt von oktalen Ziffern von 0 bis 7. Ein Literal in dualer Form beginnt mit 0b, gefolgt von binären Ziffern 0 und 1. Es ist gestattet, Ziffernfolgen zur besseren Lesbarkeit mit dem Unterstrich _ in Ziffernblöcke zu unterteilen.

Besitzt ein ganzzahliges Literal ein aus den Zeichen L oder l bestehendes Suffix, so präsentiert dieses Literal einen Wert vom Typ long (vgl. Elementare Datentypen).

Beispiel 1.
Die Literale 982367, 982367L, 0xefd5f, 03576537 bzw. 0b1110_1111_1101_0101_1111 repräsentieren dieselbe ganze Zahl.

// liefert die Dezimalzahl 982367:
int i = Integer.valueOf(03576537);

Beispiel 2.
Mit 2147483647 oder 0x7fff_ffff bzw. 0b0111_1111_1111_1111_1111_1111_1111_1111 wird die größte ganze Zahl repräsentiert, die in Java als integer-Wert darstellbar ist.

// maximaler Wert vom Typ int:
int i = Integer.valueOf(Integer.MAX_VALUE);


Fließkommaliterale

Ein (dezimales) Fließkommaliteral (floating-point literal) besteht aus einem Vorkommateil (whole-number part), einem Dezimalpunkt, einem Nachkommateil (fraction part), einem mit dem Zeichen E oder e gekennzeichneten Exponenten und gegebenfalls aus einem Suffix. Einzelne dieser Teile dürfen weggelassen werden, sofern es von einem ganzzahligen Literal unterscheidbar ist. Allerdings muss das Literal mindestens ein Vorkommateil oder ein Nachkommateil beinhalten. Besteht das Suffix aus den Zeichen F oder f, handelt es sich um ein Fließkommaliteral vom Typ float; fehlt das Suffix oder besteht es aus den Zeichen D oder d, so ist es vom Typ double.

Die folgende Liste beinhaltet also nach dieser Definition korrekte Fließkommaliterale:
.6E2f
, .7, 1E0, 123d, 2., 2.f, 0d.

340282346638528859811704183484516925440 ist die größte Zahl, die als float-Wert darstellbar ist. Es handelt sich hierbei um die Zahl (2−2−23)·2127 (vgl. Elementare Datentypen).

Boole’sche Literale

Es gibt nur zwei Boole’sche Literale (boolean literals): true und false. Sie repräsentieren die Wahrheitswerte der 2-wertigen Logik.

character-Literale

Ein character-Literal besteht aus einer von Apostrophs umschlossenen Zeichenfolge. Diese Zeichenfolge ist entweder ein einzelnes Sprachzeichen (ein Schriftzeichen, ein Zahlzeichen, ...), eine Unicode-Escape-Sequenz (mit der ein solches Zeichen in der Form \uxxxx hexadezimal kodiert werden kann) oder eine Standard-Escape-Sequenz (mit der ein solches Zeichen in der Form \xxx oktal kodiert werden kann oder mit der ein bestimmtes Zeichen maskiert ist oder mit der ein definierter Vorgang ausgelöst werden kann).

Das, was zwischen den Apostrophs steht, ist der Inhalt des Literals. Besteht der Inhalt eines character-Literals nur aus einem einzelnen Zeichen, so darf dieses Zeichen weder ' noch \ sein. Zudem darf ein character-Literal die folgenden Unicode-Escape-Sequenzen  nicht beinhalten: \u000a (linefeed), \u000d (carriage return), \u0027 (apostrophe).

Häufig verwendete Escape-Sequenzen: \b (backspace),  \t (horizontal tab), \n (linefeed), \f (formfeed).

Beispiel 1.
Die Literale '\u0077', '\167' und 'w' repräsentieren alle das gleiche Zeichen, nämlich den Buchstaben w (per ASCII-Tabelle dezimal mit 119 kodiert).

Beispiel 2.
Korrekte und nicht korrekte Zuweisungen:

char letter_a = 'a';   // korrekt
char abc = 'abc';      // nicht korrekt
char digit_7 = '7';    // korrekt
char apostroph = '\''; // korrekt
char hochkomma = ''';  // nicht korrekt
char backslash = '\\'; // korrekt
char space = ' ';      // korrekt


String-Literale

String-Literale sind Zeichenketten.

Es ist möglich, eine Zeichenkette durch Summation einer bereits vorhandenen Zeichenkette und Literalen unterschiedlichen Typs zu bilden. Bevor die neue Zeichenkette erzeugt wird, werden automatisch implizite Typumwandlungen durchgeführt:

//liefert "a = 6.0":
String str = 'a' + " = " + .06E2f;

Soll zum Text, den eine Zeichenkette beinhaltet, ein Anführungszeichen gehören, so ist dieses zu maskieren:

//liefert "a = 6.0":
String str = "...\"...";


Textblöcke

Textblöcke (text blocks) sind vom Typ String und repräsentieren einen zeilenstrukturierten Text. Der Inhalt eines Textblocks beginnt mit zwei aufeinanderfolgenden Anführungszeichen und endet mit zwei aufeinanderfolgenden Anführungszeichen. Der Sinn und Zweck eines solchen Textblocks erschließt sich am schnellsten anhand eines Beispiels:

String textblock = """
    Soll ein mehrzeiliger Text ausgegeben
    werden, dann ist es übersichtlicher,
    diesen in einen Textblock zu schreiben,
    anstatt ihn als "Summe" einzelner
    Zeichenketten zu definieren:

       "erste Zeile\\n" +
       "zweite Zeile\\n" +
       "dritte Zeile"
    """;

Die Ausgabe dieses Textblocks im Konsolenfenster oder irgendwo sonst liefert das folgende Ergebnis:

Textblock