Suche
Lesesoftware
Info / Kontakt
Java - kurz & gut
von: Robert Liguori, Patricia Liguori
O'Reilly Verlag, 2018
ISBN: 9783960102113 , 276 Seiten
3. Auflage
Format: ePUB
Kopierschutz: Wasserzeichen
Preis: 14,90 EUR
eBook anfordern 
KAPITEL 3
Grundlegende Typen
Zu den grundlegenden Typen zählen die elementaren Typen von Java und die korrespondierenden Wrapper-Klassen bzw. Referenztypen. Es gibt eine automatische Umwandlung zwischen diesen elementaren Typen und den entsprechenden Referenztypen. Dieser Vorgang wird als Autoboxing bzw. Unboxing bezeichnet. Falls erforderlich, werden elementare Typen numerisch hochgestuft.
Elementare Typen
Java hat acht elementare Typen, alles reservierte Schlüsselwörter. Sie beschreiben Variablen, die einzelne Werte mit dem entsprechenden Format und der entsprechenden Größe enthalten können (siehe Tabelle 3-1). Elementare Typen verwenden immer die angegebene Genauigkeit, unabhängig von der Genauigkeit der jeweiligen Hardware (d. h. 32 oder 64 Bit).
Tabelle 3-1: Elementare Typen
| Die elementaren Typen byte, short, int, long, float und double sind alle vorzeichenbehaftet. Der Typ char ist vorzeichenlos. |
Literale für elementare Typen
Alle elementaren Typen außer boolean können Zeichen-, Dezimal-, Hexadezimal-, Oktal- und Unicode-Literalformate akzeptieren. Falls erforderlich, wird ein Literalwert automatisch gecastet oder umgewandelt. Denken Sie daran, dass beim Abschneiden Bits verloren gehen. Unten sehen Sie eine Liste mit Zuweisungen, die elemenentare Typen nutzen.
Die einzigen zulässigen Literalwerte für den elementaren Typ boolean sind true und false:
boolean isEndogamous = true;
Der elementare Typ char repräsentiert ein einzelnes Unicode-Zeichen. Literale Werte des Typs char, die mehr als 2 Byte benötigen, müssen explizit gecastet werden:
// 'atDNA'
char [] cArray = {
'\'', // '
'\u0061', // a
't', // t
0x0044, // D
0116, // N
(char) (65 + 131072), // A
0b00100111}; // '
Der elementare Typ byte akzeptiert 4 Byte breite Integer als Literale. Wird kein expliziter Cast angegeben, wird der Integer implizit auf 1 Byte gecastet:
final byte CHROMOSOME_PAIRS = 12;
final byte CHROMOSOME_TOTAL = (byte) 48;
Der elementare Typ short akzeptiert 4 Byte breite Integer als Literale. Wird kein expliziter Cast angegeben, wird der Integer implizit auf 2 Byte gecastet:
short firstCousins = 6;
short secondCousins = (short) 18;
Der elementare Typ int akzeptiert 4 Byte breite Integer als Literale. Wenn elementare char-, byte- und short-Werte als Literale verwendet werden, werden sie automatisch in 4 Byte breite Integer umgewandelt. Gleitkommazahlen und long-Literale müssen explizit gecastet werden:
int thirdCousins = 104;
int forthCousins = (int) 648.0D;
int fifthCousins = (short) 3_888;
Der elementare Typ long akzepiert 8 Byte breite Integer als Literale. Er wird durch das Postfix L oder l angezeigt. Der Wert wird von einem 4 Byte breiten Wert in einen 8 Byte breiten Wert umgewandelt, wenn kein Postfix angegeben oder kein expliziter Cast eingesetzt wird:
long sixthCousins = 23_000;
long seventhCousins = (long) 138_000;
long eighthCousins = 828_000l;
long ninthCousins = 4_968_000L;
Der elementare Typ float akzeptiert 4 Byte breite, vorzeichenbehaftete Gleitkommazahlen als Literale. Er wird durch das Postfix F oder f oder einen expliziten Cast angezeigt. Obgleich für ein int-Literal kein expliziter Cast erforderlich ist, passt ein int nicht immer in einen float, wenn der Wert größer als 2^23 ist:
float totalSharedCentimorgansX = 0;
float totalSharedCentimorgansAutosomal = (float) 285.5;
float largestSharedCentimorgansX = 0.0f;
float largestSharedCentimorgansAutosomal = 71F;
Der elementare Typ double akzeptiert 8 Byte breite Gleitkommazahlen als Literale. Das Literal kann das Postfixh D oder d tragen oder mit einem expliziten Cast versehen werden. Wenn das Literal eine ganze Zahl darstellt, wird diese implizit gecastet:
double centimorgansSharedFloor = 0;
double centimorgansSharedCeiling = 6766.20;
double centimorgansShared = (double) 888;
double centimorgansUnShared = 5878.0d;
double centimorgansPercentShared = 13.12D;
Mehr Informationen zu Literalen finden Sie in Kapitel 2.
Gleitkommaeinheiten
Positive und negative Gleitkomma-Unendlichwerte, der negative Null-Wert und der Not-a-Number-Wert (NaN) sind besondere Einheiten, die gemäß dem Standard IEEE 754-1985 definiert werden (siehe Tabelle 3-2).
Infinity, –Infinity und –0.0 werden zurückgeliefert, wenn eine Gleitkommaoperation einen Gleitkommawert zurückliefert, der so groß oder klein ist, dass er auf übliche Weise nicht dargestellt werden kann.
Tabelle 3-2: Gleitkommaeinheiten
| Einheit | Beschreibung | Beispiele |
| Infinity | Repräsentiert das Konzept positiver Unendlichkeit. | 1.0 / 0.0, 1e300 / 1e–300, Math.abs (–1.0 / 0.0) |
| –Infinity | Repräsentiert das Konzept negativer Unendlichkeit. | –1.0 / 0.0, 1.0 / (–0.0), 1e300/–1e–300 |
| –0.0 | Repräsentiert eine negative Zahl, die fast null ist. | –1.0 / (1.0 / 0.0), –1e–300 / 1e300 |
| NaN | Repräsentiert ein undefiniertes Ergebnis. | 0.0 / 0.0, 1e300 * Float.NaN, Math.sqrt (–9.0) |
Positive und negative Unendlichkeit sowie NaN sind als double- und float-Konstanten verfügbar:
Double.POSITIVE_INFINITY; // Infinity
Float.POSITIVE_INFINITY; // Infinity
Double.NEGATIVE_INFINITY; // –Infinity
Float.NEGATIVE_INFINITY; // –Infinity
Double.NaN; // Not-a-Number
Float.NaN; // Not-a-Number
Die Wrapper-Klassen Double und Float bieten Methoden, mit denen man prüfen kann, ob eine Zahl endlich, unendlich oder NaN ist:
Double.isFinite(Double.POSITIVE_INFINITY); // false
Double.isFinite(Double.NEGATIVE_INFINITY); // false
Double.isFinite(Double.NaN); // false
Double.isFinite(1); // true
// true
Double.isInfinite(Double.POSITIVE_INFINITY);
// true
Double.isInfinite(Double.NEGATIVE_INFINITY);
Double.isInfinite(Double.NaN); // false
Double.isInfinite(1); // false
Double.isNaN(Double.NaN); // true
Double.isNaN(1); // false
Operationen mit besonderen Werten
Tabelle 3-3 zeigt die Ergebnisse von Operationen mit diesen speziellen Werten. Dabei steht INF für Double.POSITIVE_INFINITY, –INF für Double.NEGATIVE_INFINITY und NAN für Double.NaN.
Die Spaltenüberschrift der vierten Spalte ( –0.0) und der Eintrag in Zeile 12 ( \* NAN) ergeben also NaN. Das könnte folgendermaßen geschrieben werden:
// 'NaN' wird ausgegeben
System.out.print((-0.0) * Double.NaN);
Tabelle 3-3: Operationen mit besonderen numerischen Werten
| Jede Operation mit dem Wert NaN liefert NaN; –NaN gibt es... |