Java - kurz & gut (eBook)
276 Seiten
O'Reilly Verlag
978-3-96010-211-3 (ISBN)
Robert Liguori ist ein erfahrener Software-Entwickler und entwickelt, betreut und testet Luftverkehrsverwaltungssysteme seit 1996. Zur Zeit leitet er die Entwicklung zahlreicher Java-Anwendungen in diesem Bereich. Er hat einen Bachelor in Informatik von der Richard Stockton College in New Jersey und ist Sun Certified Java Professional. Außerdem ist er Mitbegründer der Tech Center Java User Group. Patricia Liguori ist leitende Systementwicklerin und entwickelt seit 1994 Luftverkehrüberwachungssysteme und Simulationsumgebungen. Neben Java beherrscht sie Relationale Datenbanken, XML und XSL. In den letzten Jahren hat sie die Entwicklung von Systemen geleitet, die mehrere Organisationen für die Forschung und Analyse von Luftfahrtsystemen einsetzen. Sie hat einen B.S. in Business Administration von der Duquesne University, einen B.S. in Informatik vom Richard Stockton College in New Jersey und einen Master in Informatik vom New Jersey Institute of Technology.
Robert Liguori ist ein erfahrener Software-Entwickler und entwickelt, betreut und testet Luftverkehrsverwaltungssysteme seit 1996. Zur Zeit leitet er die Entwicklung zahlreicher Java-Anwendungen in diesem Bereich. Er hat einen Bachelor in Informatik von der Richard Stockton College in New Jersey und ist Sun Certified Java Professional. Außerdem ist er Mitbegründer der Tech Center Java User Group. Patricia Liguori ist leitende Systementwicklerin und entwickelt seit 1994 Luftverkehrüberwachungssysteme und Simulationsumgebungen. Neben Java beherrscht sie Relationale Datenbanken, XML und XSL. In den letzten Jahren hat sie die Entwicklung von Systemen geleitet, die mehrere Organisationen für die Forschung und Analyse von Luftfahrtsystemen einsetzen. Sie hat einen B.S. in Business Administration von der Duquesne University, einen B.S. in Informatik vom Richard Stockton College in New Jersey und einen Master in Informatik vom New Jersey Institute of Technology.
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... |
| Erscheint lt. Verlag | 15.3.2018 |
|---|---|
| Reihe/Serie | kurz & gut |
| O'Reilly`s kurz & gut | O'Reilly`s kurz & gut |
| Übersetzer | Thomas Demmig |
| Verlagsort | Heidelberg |
| Sprache | deutsch |
| Themenwelt | Informatik ► Programmiersprachen / -werkzeuge ► Java |
| Schlagworte | Anweisungen • Generic • Java 8 • java 9 • Java Collections-Framework • Java Referenz • Java Scripting-API • Java SE Plattform • JDK • Namenskonventionen • Nebenläufigkeit • Programmiersprache • REPL • Speicherverwaltung • Typen |
| ISBN-10 | 3-96010-211-9 / 3960102119 |
| ISBN-13 | 978-3-96010-211-3 / 9783960102113 |
| Haben Sie eine Frage zum Produkt? |
EPUB (Wasserzeichen)Größe: 1,8 MB
DRM: Digitales Wasserzeichen
Dieses eBook enthält ein digitales Wasserzeichen und ist damit für Sie personalisiert. Bei einer missbräuchlichen Weitergabe des eBooks an Dritte ist eine Rückverfolgung an die Quelle möglich.
Dateiformat: EPUB (Electronic Publication)
EPUB ist ein offener Standard für eBooks und eignet sich besonders zur Darstellung von Belletristik und Sachbüchern. Der Fließtext wird dynamisch an die Display- und Schriftgröße angepasst. Auch für mobile Lesegeräte ist EPUB daher gut geeignet.
Systemvoraussetzungen:
PC/Mac: Mit einem PC oder Mac können Sie dieses eBook lesen. Sie benötigen dafür die kostenlose Software Adobe Digital Editions.
eReader: Dieses eBook kann mit (fast) allen eBook-Readern gelesen werden. Mit dem amazon-Kindle ist es aber nicht kompatibel.
Smartphone/Tablet: Egal ob Apple oder Android, dieses eBook können Sie lesen. Sie benötigen dafür eine kostenlose App.
Geräteliste und zusätzliche Hinweise
Buying eBooks from abroad
For tax law reasons we can sell eBooks just within Germany and Switzerland. Regrettably we cannot fulfill eBook-orders from other countries.
aus dem Bereich
