Typen in Java 

Wir haben bisher schon verschiedene Literale, wie »65«, »12.82« oder »"Alpha"« kennengelernt. Diese gehören offensichtlich verschiedenen Typen an: Das erste Literal steht für eine Zahl ohne  Nachkommastellen, der zweite für eine Zahl mit  Nachkommastellen und der dritte ist gar keine Zahl, sondern eine Zeichenfolge. Tatsächlich ordnet man solchen Literalen in Java  verschiedene sogenannte Typen zu (die man auch Datentypen  nennt). Beispielsweise hat das Literal »65« den Typ ›int‹, und das Literal »12.82« den Typ ›double‹.

Ein Typ ist eine Entität des Quelltextmodells.

Jedem Ausdruck (und damit auch jedem Literal) wird durch Regeln der Programmiersprache ein bestimmter Typ  zugeordnet. Der Typ eines Ausdrucks legt fest, an welchen Stellen eines Programmes der Ausdruck verwendet werden kann, und was diese Verwendung dann bedeutet.

Das Wort „Datentyp“ bedeutet dasselbe wie „Typ“, es ist ein Synonym.

Intern legt der Typ eines Wertes auch die interne Sprache fest, mit der die Werte von Ausdrücken jenes Typs im Speicher einer Java -Implementation festgehalten werden. Jedoch muß sich ein Programmierer normalerweise nicht mit diesen internen Sprachen von Java -Implementation beschäftigen.

›int‹

Ein Numerale ohne Punkt ».« aus dem Bereich von «0» bis «2_147_483_647» hat den Typ ›int‹.

Der Datentyp ›int‹ wird auch als ein ganzzahliger Typ  bezeichnet, da seine Literale ganzzahlig sind, also keine Nachkommastellen haben.

Ein Numerale vom Datentyp ›int‹ ist ein ganzzahliges Numerale.

Für jeden int-Wert stehen 32 Bit zur Verfügung. Dadurch ist die Anzahl der möglichen int-Werte begrenzt.

Ein Typ kann einen Namen  haben. Beispielsweise ist »int« der Name des Typs ›int‹.

›long‹

Der Datentype ›long‹ wird in diesem Grundkurs nicht  ausführlich vorgestellt, jedoch begegnet er uns in einigen Fällen. Man kann sich vorstellen, daß ›long‹ eine Variante von ›int‹ ist, die aber noch größere Werte, bis «9_223_372_036_854_775_807», also ‹ 2⁶³-1 ›, das heißt zirka neun Trillionen (‹ 9×10¹⁸ ›), zuläßt.

Für jeden long-Wert stehen 64 Bit zur Verfügung. Deswegen gibt es mehr long-Werte als int-Werte.

›double‹ – physikalische Zahlen

Ein Numerale mit einem Punkt ».« hat den Typ ›double‹. Der Datentyp ›double‹ enthält Werte, die auch Nachkommastellen haben können.

Dieser Typ ist im allgemeinen der Typ von Literalen mit Nachkommastellen, jedoch wird dieser Typ einem Literal auch dann zugewiesen, wenn das Literal gar keine richtigen Nachkommastellen hat, wie bei »2.0«, da es einfacher ist, das formale Kriterium heranzuziehen, welches am Anfang dieses Abschnitts genannt wurde. Werte des Typs ›int‹ haben hingegen niemals Nachkommastellen.

Der Datentyp ›double‹ wird auch als Gleitkommatyp  bezeichnet, da seine Zahlen intern normalerweise in einer sogenannten „Gleitkommadarstellung“ abgespeichert werden.

Ein Numerale vom Datentyp ›double‹, wie beispielsweise »2.0«, ist ein Gleitkommanumerale.

Für jeden double-Wert stehen 64 Bit zur Verfügung. Dadurch ist die Genauigkeit und Größe der Werte begrenzt.

Ausgabe von double-Werten

Zahlen vom Typ ›double‹ werden stets mit einem Punkt  ».« ausgegeben. So kann man sie in der Ausgabe von Zahlen vom Typ ›int‹ unterscheiden.

Main.java

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

Konsole

2.0

Ungenauigkeiten bei ›double‹-Werten

Bei Gleitkommawerten sind kleine Abweichungen von den Literalwerten gestattet und möglich.

Bei der Ausgabe eines double-Wertes wird dieser manchmal auf ein bestimmte Anzahl von Stellen abgeschnitten. Dies liegt daran, daß die Java -Implementation nur eine begrenzte Anzahl von Stellen verarbeiten und speichern kann. Für jeden double-Wert stehen 64 Bit zur Verfügung. Daher werden an Stelle von Werten eigentlich immer nur weniger genaue Wertebereiche gespeichert, so daß jeder double-Wert ungenau  ist.

Main.java

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

transcript

3.141592653589793

Main.java

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

Konsole

2.0

Die Abweichung der Ausgabe vom mathematischen Wert des Numerales beträgt beim zweiten Programm nur 0,05 Billiardstel. Dies zeigt auch erneut deutlich den Unterschied zwischen einem Numerale und seinem Wert.

Oft sind nur die ersten zirka 16 Stellen eines double-Wertes bedeutsam, während weiter hinten liegende Stellen ignoriert werden sollten.

Daher können double-Werte gut für prinzipiell ohnehin ungenaue Werte verwendet werden, wie beispielsweise Meßwerte kontinuierlicher Größen (wie Länge, Geschwindigkeiten oder Temperaturen), die sowieso nie ganz genau gemessen werden können - wer kann beispielsweise seine genaue Körpergröße in Nanometern angeben?

Wegen der Ungenauigkeiten sind double-Werte für Währungsbeträge aber nur mit Einschränkungen verwendbar, denn bei Währungsbeträgen sollten gar keine  Abweichungen von den mathematischen Werten ihrer Numeralia auftreten. Java  bietet verschiedene Möglichkeiten, auch Währungsbeträge korrekt darzustellen, doch können diese hier noch nicht ausführlicher behandelt werden.

Wir nennen double-Werte hier physikalische Zahlen, da die verwendeten Näherungen solche Zahlen besonders für physikalische Zahlenwerte geeignet macht, weil bei diesen die hinteren Stellen tatsächlich nicht wichtig sind.

E-Numeralia

In einem Numerale steht »E« für „mal Zehn hoch“. »2E3« bedeutet also beispielsweise ‹ 2 × 10³ ›.

‹ 10³ › bezeichnet den Wert, den man erhält, wenn man die Zahl Eins drei Mal mit 10 multipliziert. Allgemein bezeichnet für eine natürliche Zahl n  der Term ‹ 10ⁿ  › den Wert, den man erhält, wenn man die Zahl Eins n -mal mit 10 multipliziert. ‹ 2 × 10³ = 2 × 1 · 10 · 10 · 10 = 2 × 1000 = 2000 ›

Dies bedeutet praktisch, daß das Dezimalkomma bei »2.0« um drei Schritte nach rechts verschoben werden soll. Man erhält so »2000.0«.

»2E3« bedeutet also nicht  etwa „2³“, also die Zahl, welche man erhält indem man die Zahl Eins dreimal mit der Zahl 2 multipliziert (8).

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( 2E3 ); }}

Konsole

2000.0

Ein solches Numerale mit einem »E« hat den Datentyp »double«, selbst wenn es keinen  Punkt enthält.

Wir verzichten an dieser Stelle auf eine ausführliche Darstellung des Aufbaus von E-Numeralia, da E-Numeralia im weiteren Verlauf dieses Kurses nur selten als Teile des Quelltextes vorkommen. Zahlenwerte werden von Programmen zwar manchmal in der E-Schreibweise ausgegeben, aber um diese zu verstehen, reicht die obenstehende Erklärung bereits aus.

Beim Exponenten (dem Wert hinter »E«) ist ein Vorzeichen  erlaubt.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( 2E+3 ); }}

Protokoll

2000.0

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( 2E-3 ); }}

Protokoll

0.002

Grenzen des Wertebereiches ⃗

Werte des Typs »double« können größer  als Werte des Typs »int« sein. Ihre Ungenauigkeit kann sich aber auch schon in den Stellen vor  dem Komma zeigen, wie in dem folgenden Beispiel.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( 9_007_199_254_740_993. ); }}

Protokoll

9.007199254740992E15

Die Ausgabedarstellung »9.007199254740992E15« bedeutet ‹ 9,007199254740992 × 10¹⁵ ›, also ‹ 9007199254740992 ›.

»9_007_199_254_740_993.« und »9_007_199_254_740_992.« sind zwei verschiedene  Literale mit dem gleichen Wert.

Bei Zahlen bis zu «9_007_199_254_740_991.» (2⁵³-1, zirka 9×10¹⁵, 9 Billiarden) sind double-Werte aber genau, in dem Sinne, daß bis zu diesem Wert alle angegebenen double-Werte ohne Nachkommastellen auch mit genau demselben Wert ausgegeben werden, wie sie angegeben wurden, und sich umgekehrt von der Ausgabe auf den angegebenen Wert schließen läßt.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( 9_007_199_254_740_991. ); }}

Protokoll

9.007199254740991E15

Damit kann der Datentyp ›double‹ doch noch größere ganze Zahlen korrekt darstellen als der Datentyp ›int‹.

Der größte Wert des Datentyps »long« beträgt »9_223_372_036_854_775_807L«. Dies sind 2⁶³-1, zirka 9×10¹⁸, also 9 Trillionen, somit noch zirka tausendmal mehr als der zuvor genannte Wert. Daher könne große long-Werte von ›double‹ nur noch näherungsweise  dargestellt werden.

›java.lang.String‹

Ein Zeichenfolgenliteral hat den Typ ›java.lang.String‹.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( "Alpha" ); }}

Protokoll

Alpha

Ein “string ” ist ein “character string ”, also – wörtlich – eine Kette (Verkettung) von Schriftzeichen, eine Zeichenkette  (Zeichenfolge).

Der Speicherbedarf einer Zeichenfolge besteht aus einer festen Anzahl von Bits (zirka 320) zuzüglich einer variablen Anzahl von Bits (zirka 16 pro Zeichen).

Ausgabedarstellung

Das folgende Programm gibt eine Darstellung der Zahl 12 aus und verwendet ein Literal »12« vom Typ ›int‹.

Main.java

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

java.lang.System.out

12

Die Ausgabe des folgenden Programms läßt sich nicht von der Ausgabe des vorigen Programms unterscheiden. Das folgende Programm verwendet ein Literal »"12"« vom Typ ›java.lang.String‹.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( "12" ); }}

java.lang.System.out

12

Ausgabedarstellungen lassen also keine  eindeutigen Rückschlüsse auf Werte und Typen zu.

Die Werte der beiden Ausdrücke »12« und »"12"« haben also unterschiedliche Datentypen (und es sind auch unterschiedliche Werte) aber beide Werte habe dieselbe Ausgabedarstellung.

Zwei  verschiedene Werte, aber eine  Ausgabedarstellung:
Dies illustriert den Unterschied zwischen den Begriffen „Wert“ und „Ausgabedarstellung“.

Auch die Werte der beiden Ausdrücke »2.0« und »"2.0"« haben unterschiedliche Datentypen (und es sind auch unterschiedliche Werte) aber beide Werte habe dieselbe Ausgabedarstellung, wie die beiden folgenden Programm zeigen.

Main.java

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

Konsole

2.0

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( "2.0" ); }}

Konsole

2.0

Typen in Java 

In Java  unterscheidet man zwischen elementaren Typen  und Referenztypen. Elementare Typen werden auch „primitive Typen“ genannt, dies ist also in Java  kein Schimpfwort, sondern ein Fachbegriff! Das Wort „primitiv“ bedeutet darin soviel wie „elementar“ oder „fundamental“.

Die Namen elementarer Typen  werden vollständig mit Kleinbuchstaben  geschrieben, die eigentlichen Namen von Referenztypen  enthalten in der Regel mindestens einen großen Buchstaben. Wir kennen bisher zwei elementare Typen und einen Referenztyp.

Elementare Typen

int
long
double

Referenztypen

java.lang.String

Zahlentypen (wie ›int‹, ›long‹ und ›double‹) werden auch „numerische Typen“ genannt.

Sowohl elementare Typen als auch Referenztypen sind Typen.

Das Typsystem von Java

                               Typen
                                 ^
                                 |
                    .------------'------------.
                    |                         |
              elementare Typen           Referenztypen             

Typen im Quelltext

Bis auf weiteres schreiben wir Typen nicht  in Programme hinein. Sie dienen uns lediglich zur Beschreibung  von Programmteilen.

»int« ist keine Abkürzung, sondern ein vollständiges Wort. Daher umfaßt die richtige Aussprache des Wortes »int« nur eine  Silbe und endet mit einem /t/: /ɪnt/ (wie das Ende der Aussprache des Wortes “print ”).

Übungsfragen

?   Literaltypen

Ein Literal, das mit einem Anführungszeichen »"« beginnt, hat den Typ ›java.lang.String‹; sonst hat es den Typ ›double‹, wenn es einen Punkt ».« oder ein »E« enthält, und andernfalls den Typ ›int‹.

Welchen Typ haben die folgenden Literale jeweils?

1

1.2

2E3

"2"

?   Aussprache *

Wie lautet die Aussprache von »int«?

Wie die von “print ”, nur ohne “pr ”.

Wie die von “integer ”.

Ergänzungen zu Typen in Java  *

Elementare Datentypen und Codes *

Der Typ eines Ausdrucks sagt der Java -Implementation im Falle eines elementaren Typs auch jeweils, welcher Code  zur internen Darstellung von Werten des Typs verwendet werden soll.

Bei einem Referenztyp kann die interne Darstellung hingegen durch das Programm  festgelegt werden. Die dazu nötige Vorgehensweise wird aber erst im Aufbaukurs  behandelt werden.

Im Falle des Typs »java.lang.String« wird die Darstellung durch ein Programm der Standardbibliothek  festgelegt. Da dieser Typ aber für Java  eine besondere Bedeutung hat, ist hier auch die Java -Implementation noch beteiligt.

Ergänzungen zu »double« Der größte ganzzahlige und genaue Wert *

Für Werte, deren Nachkommastellen alle ganz genau bestimmt sein sollen, wie beispielsweise Währungsbeträge, ist der Datentyp ›double‹ nicht  gedacht. Den Währungsbetrag von „1,68 Euro“ kann man daher besser als ganzzahligen Wert „168 Cents“ mit dem Datentyp ›int‹ abspeichern, jedoch kann es hier auch Probleme geben, falls der Betrag zu groß wird. Es gibt Techniken, welche auch die genaue Darstellung großer Währungsbeträge gestatten, die aber an dieser Stelle des Kurses noch nicht behandelt wurden.

Bei ganzen Zahlen bis zu 9,007,199,254,740,991 (2⁵³-1) sind double-Werte genau. In diesem Rahmen kann der Typ ›double‹ auch zur Darstellung großer ganzer Zahlen verwendet werden.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 9_007_199_254_740_991. ); }}

transcript

9.007199254740991E15

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 9_007_199_254_740_992. ); }}

transcript

9.007199254740992E15

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 9_007_199_254_740_993. ); }}

transcript

9.007199254740992E15

Ergänzungen zu ›double‹ Der größte Wert *

Das folgende Programm enthält eine Darstellung des größten double-Wertes.

Main.java

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

Protokoll

1.7976931348623157E308

Da der größte double-Wert noch andere Literale hat, ergibt sich nicht sofort ein Fehler, wenn man das Literal noch etwas vergrößert (indem man »8.« durch »9.« ersetzt – dies ändert nichts am Wert des Ausdrucks!), aber das Literal in dem folgenden Programm ist dann auf jeden Fall zu groß.

Main.java

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

Protokoll

Main.java:4: error: floating point number too large
    ( 179769313486231580800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. ); }}
      ^
1 error

Zitate zu ›double‹ *

“A floating-point literal (…) its type is double ”, JLS8, 3.10.2 Floating-Point Literals

Was ist ein Typ? *

Ein Typ (oder „Datentyp“) ist eine freie Entität eines Modells (das wir hier „Typmodell“ nennen).

Ein Typ ist nicht  mit seiner Schreibweise (wie »int«) gleichzusetzen, vielmehr ist er die Bedeutung  dieser Schreibweise – daher schreiben wir „›int‹“ für den Typ ›int‹. (Dies liegt daran, daß unterschiedliche  Schreibweise, wie »String« und »java.lang.String«, den gleichen  Typ bedeuten können; aber andererseits eine bestimmte Schreibweise, wie »String«, an unterschiedlichen Stellen eines Programms verschiedene  Typen bezeichnen kann.)

Das Typmodell gehört in Java  sowohl zum Quelltext-  als auch zum Laufzeitmodell.

Die oft gehörte Erklärung, derzufolge ein Typ eine Menge von Werten  sei, ist falsch, da es Gegenbeispiele dazu gibt. In Java  kann man Referenztypen beispielsweise oft gar nicht sinnvoll eine bestimmte Wertmenge zuordnen, außerdem gibt es Fälle, in denen Typen trotz gleicher Wertmenge als unterschiedlich  gelten. Richtig ist es, daß elementare Typen eine Menge von Werte besitzen.

Typen in der deutschen Sprache *

Man kann Typnamen auch als prädikative Adjektive gebrauchen, obwohl dies nicht besonders schön klingt: „Dieses Literal ist int.“ bedeutet „Dieses Literal hat den Typ ›int‹.“ Man kann Typnamen auch als Präfixoid gebrauchen: „int -Literal“ bedeutet „Literal mit dem Typ ›int‹“. Der Akkusativ Singular von „Typ“ im Sinne von „Typus“ lautet „Typ“ (nicht „Typen“ wie bei „Typ“ im Sinne von „Kerl, Bursche“).

Elementare Typen und Referenztypen *

Man kann sich die Unterscheidung zwischen elementare Typen  und Referenztypen  vorläufig in etwa folgendermaßen erklären.

Werte elementare Typen können oft direkt und schnell von einem Prozessor (Teil einer Implementation, Hardware) verarbeitet werden. Die Verarbeitung eines Wertes eines Referenztyps kann hingegen komplexer (und dadurch langsamer) sein; sie erfolgt oft durch Programme (Software).

Der für die Darstellung eines Wertes eines elementaren Typs benötigte Speicherplatz ist konstant (für jeden Wert eines Typs derselbe), während der Speicherplatz eines Wertes eines Referenztyps bei jedem Wert anders sein kann. Während alle int-Zahlen beispielsweise immer denselben Speicherplatz benötigen, hängt der Speicherplatzbedarf einer Zeichenfolge von ihrer Länge ab. Außerdem werden die elementaren Typen bereits durch die Programmiersprache (JLS ) definiert, während Referenztypen oft erst durch die Bibliothek (Java SE ) definiert werden. Der Programmierer kann selber neue Referenztypen definieren, aber keine neuen elementaren Typen.

Werte und ihre Textdarstellung *

Der Ausdruckrahmen gibt Textdarstellungen von Werten, nicht die Werte selber  aus.

Wir sprechen von der „Ausgabe einer Textdarstellung des Wertes «12» “, weil Werte im allgemeinen keine ausdruckbaren Zeichenfolgen sind. Eine ausgedruckte Zeichenfolge, wie »12«, ist also nicht ein Wert selber, sondern nur eine Darstellung  des Wertes durch einen Text. Beispielsweise kann der Wert «12.0» auch als «12.00» dargestellt werden, beides sind zwei verschiedene Textdarstellungen  desselben Wertes. Lesen oder Schreiben kann man nur Darstellungen von Werten, nicht die Werte selber.

Das Literal »12.0« und das Literal »12.00« haben beide denselben Wert «12.0» vom Datentyp ›double‹.

Main.java

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

java.lang.System.out

12.0

Main.java

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

java.lang.System.out

12.0

Die Ausgabedarstellung der Zahl «12.0» gleicht der Ausgabedarstellung der Zeichenfolge des Zeichenfolgenliterals »"12.0"«, obwohl intern beides verschiedene Werte sind: Die Zahl «12.0» ist ein Wert des Datentyps ›double‹, während die Zeichenfolge «"12.0"» den Datentyp ›java.lang.String‹ hat.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( "12.0" ); }}

java.lang.System.out

12.0

Zur Vereinfachung kann man aber auch von der „Ausgabe eines Wertes “ sprechen, wenn man weiß, daß dabei nicht wirklich  der Wert selber, sondern nur eine Textdarstellung  des Wertes ausgegeben wird.

Vom Quelltext zur Ausgabedarstellung

12.00      12.0            "12.0"        Literal im Quelltext (Text)
  |         |                |
  '----.----'                |           Auswertung des Literals
       |                     |
       v                     v
   Wert 12.0            Wert "12.0"      gedachter Wert 
   Datentyp               Datentyp       (nicht unbedingt ein Text)
    double            java.lang.String
       |                     |
       '----------.----------'
                  |
                  |                      Darstellung des Wertes als Text
                  |
                  v
                12.0                     Text
          Ausgabedarstellung

»int« ist nicht “integer ” *

Das Wort »int« sollte nicht  wie das englische Wort “integer ” ausgesprochen werden, da die übliche Aussprache gebildeter Programmierer wie am Ende der Aussprache von “print ” klingt.

Außerdem gibt es in Java  auch noch einen Datentyp, der wirklich »Integer« heißt. Wenn man das englische Wort “integer ” hört, würde man deswegen denken, daß jener Datentyp ›Integer‹ gemeint ist.

»int« hat auch eine andere Bedeutung als das englische Wort “integer ”. “integer ” heißt „ganzzahlig“ oder „eine ganze Zahl“, während »int« ein Datentyp der Programmiersprache Java  ist.

Beispielsweise ist der Wert des Literals »1.0« ganzzahlig, also auf englisch “integer ”, aber sein Typ ist nicht »int«. Genauso ist auch 9223372036854775807 eine ganze Zahl, also auf englisch “integer ”, aber dies ist kein Wert des Datentyps »int« (dafür ist diese Zahl zu groß).

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println
    ( 9_223_372_036_854_775_807 ); }}

Fehlermeldung

Main.java:32: error: integer number too large: 9223372036854775807
  { java.lang.System.out.println
    ( 9_223_372_036_854_775_807 ); }}
                                  ^
1 error

Fehlermeldung (Übersetzung)

Main.java:32: Fehler: ganze Zahl zu gross: 9223372036854775807
  { java.lang.System.out.println
    ( 9_223_372_036_854_775_807 ); }}
                                  ^
1 error