Untertypen in Java 

Man kann alle int-Zahlen auch als double-Zahlen ansehen, indem man ihnen den Nachkomma-Anteil ».0« zuschreibt. So kann beispielsweise der int-Wert »4« auch als der double-Wert »4.0« interpretiert werden. Dementsprechend kann man jedem int-Wert einen gleichwertigen double-Wert zuordnen, ohne daß dabei Informationen über den int-Wert verloren gehen.

Insbesondere verliert man bei einer Wandlung von »int« nach »double« und einer anschließenden Rückwandlung von »double« nach »int« keine Informationen über den Ausgangswert.

Die „kanonische Injektion“

      int                   double
                             ...
                      -2_147_483_648.25
                      -2_147_483_649.0
                      -2_147_483_648.5
                      -2_147_483_648.25
-2_147_483_648 ---->  -2_147_483_648.0       kleinster int-Wert
                      -2_147_483_647.75
                     ...
                                  -1.25
            -1 -----------------> -1.0
                                  -0.75
                                  -0.5
                                  -0.25
             0 ----------------->  0.0
                                   0.25
                                   0.5
                                   0.75
             1 ----------------->  1.0
                                   1.25
                                   1.5
                                   1.75
             2 ----------------->  2.0
                                   2.25

                     ...
                       2_147_483_646.25
 2_147_483_647 ----->  2_147_483_647.0       groesster int-Wert
                       2_147_483_647.25
                       2_147_483_647.5
                       2_147_483_647.75
                       2_147_483_648.0
                       2_147_483_648.25

                             ...

Damit sind die int-Werte praktisch alle im Datentyp »double« „enthalten“, kurz: »int« ist wie ein Teil von »double«. Man sagt auch, »int« sei ein Untertyp  des Typs »double« oder – umgekehrt – »double« sei ein Obertyp von »int« und schreibt „int < double“.

Eine Untertypbeziehung

.--------------.
| double       |
'--------------'
       ^
      /_\
       |
.--------------.
| int          |
'--------------'

Entsprechend ist es im allgemeinen zulässig, dort wo ein double-Ausdruck erlaubt ist, auch einen int-Ausdruck einzusetzen.

Da es außerdem natürlich zulässig ist, einen double-Ausdruck dort einzusetzen, wo ein double-Ausdruck erwartet wird, gilt der Typ »double« auch als Untertyp seiner selbst. Dies gilt auch für alle anderen Typen.

Untertypbeziehungen (siehe JLS8, 4.10.1 Subtyping among Primitive Types )

»int« ist Untertyp von »double«

(»int« ist Untertyp von »int«,
»double« ist Untertyp von »double«,
»java.lang.String« ist Untertyp von »java.lang.String«)

Der Typ »long«

Alle long-Werte können (wenigstens näherungsweise ) durch double-Werte dargestellt werden, und alle int-Werte durch long-Werte. Daher ist der Typ ›long‹ ein Untertyp von ›double‹ und ein Obertyp von ›int‹.

Untertypbeziehungen (siehe JLS8, 4.10.1 Subtyping among Primitive Types )

int < long < double

Das Maximum zweier Typen ⃗

Man kann auch sagen, daß der Typ »double« größer  oder umfassenderer  als der Typ »int« sei, weil er alle Wert des Typs »int« und noch weitere Werte umfaßt.

Entsprechend sagt man auch, daß der Typ »double« das Maximum  der beiden Typen »int« und »double« sei. (Man kann auch sagen, daß der Typ »double« der speziellste gemeinsame Obertyp  der beiden Typen »int« und »double« sei.)

Maxima von zwei Typen

erster Typ   zweiter Typ   Maximum
int          int           int
int          double        double
double       int           double
double       double        double

Bei dem Operator »/« ist der Typ des Ergebnisses das Maximum  der Typen seiner Operanden.