|
Zu diesem Buch – sowie zu vielen weiteren O’Reilly-Büchern – können Sie auch das entsprechende E-Book im PDF-Format herunterladen. Werden Sie dazu einfach Mitglied bei oreilly.plus+: www.oreilly.plus |
3. AUFLAGE
Robert Liguori, Patricia Liguori
Lektorat: Ariane Hesse
Korrektorat: Sibylle Feldmann, www.richtiger-text.de
Satz: III-Satz, www.drei-satz.de
Herstellung: Susanne Bröckelmann
Umschlaggestaltung: Michael Oréal, www.oreal.de
Druck und Bindung: Media-Print Informationstechnologie,
www.mediaprint-druckerei.de
Bibliografische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über
http://dnb.d-nb.de abrufbar.
ISBN:
Print978-3-96009-051-9
PDF978-3-96010-210-6
ePub978-3-96010-211-3
mobi978-3-96010-212-0
Dieses Buch erscheint in Kooperation mit O’Reilly Media, Inc. unter dem Imprint »O’REILLY«. O’REILLY ist ein Markenzeichen und eine eingetragene Marke von O’Reilly Media, Inc. und wird mit Einwilligung des Eigentümers verwendet.
3. Auflage
Copyright © 2018 dpunkt.verlag GmbH
Wieblinger Weg 17
69123 Heidelberg
Authorized German translation of the English edition of Java Pocket Guide, 4th Edition, ISBN 9781491938690 © 2017 Gliesian, LLC. This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls all rights to publish and sell the same.
Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.
Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.
Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen.
5 4 3 2 1 0
Dieses Buch ist unserer wunderbaren Tochter Ashleigh gewidmet.
Vorwort
Teil I: Sprache
1Namenskonventionen
Akronyme
Annotationsnamen
Klassennamen
Namen von Konstanten
Enumerationsnamen
Die Namen generischer Typparameter
Namen von Instanzvariablen und statischen Variablen
Interface-Namen
Methodennamen
Package-Namen
Modulnamen
Namen von Parametern und lokalen Variablen
2Lexikalische Elemente
Unicode und ASCII
Kompakte Strings
Kommentare
Schlüsselwörter
Bezeichner
Trennzeichen
Operatoren
Literale
Escape-Sequenzen
Unicode-Währungssymbole
3Grundlegende Typen
Elementare Typen
Literale für elementare Typen
Gleitkommaeinheiten
Numerische Hochstufung elementarer Typen
Wrapper-Klassen
Autoboxing und Unboxing
4Referenztypen
Elementare Typen und Referenztypen im Vergleich
Vorgabewerte
Umwandlung von Referenztypen
Umwandlungen zwischen elementaren Typen und Referenztypen
Referenztypen an Methoden übergeben
Referenztypen vergleichen
Referenztypen kopieren
Speicherallozierung und die Garbage Collection von Referenztypen
5Objektorientierte Programmierung
Klassen und Objekte
Argumentlisten variabler Länge
Abstrakte Klassen und Methoden
Statische Datenmember, statische Methoden, statische Konstanten und statische Initialisierer
Interfaces
Enumerationen
Annotationstypen
Funktionelle Interfaces
6Anweisungen und Blöcke
Ausdrucksanweisungen
Die leere Anweisung
Blöcke
Bedingungsanweisungen
Iterationsanweisungen
Kontrollflussübergabe
synchronized-Anweisungen
assert-Anweisungen
Exception-Handling-Anweisungen
7Exception-Handling
Die Exception-Hierarchie
Checked-/Unchecked-Exceptions und Errors
Verbreitete Checked-/Unchecked-Exceptions und Errors
Exception-Handling-Schlüsselwörter
Der Exception-Handling-Vorgang
Eigene Exception-Klassen definieren
Informationen zu Exceptions ausgeben
8Java-Modifizierer
Zugriffsmodifizierer
Andere Modifizierer (Nicht-Zugriffsmodifizierer)
Codieren von Modifizierern
Teil II: Plattform
9Java Platform, Standard Edition
Häufig verwendete Java SE-API-Bibliotheken
10Grundbausteine für die Java-Entwicklung
Java Runtime Environment
Java Development Kit
Struktur von Java-Programmen
Kommandozeilenwerkzeuge
Classpath
11Speicherverwaltung
Garbage Collector
Speicherverwaltungswerkzeuge
Kommandozeilenoptionen
Die Größe des JVM-Heaps ändern
Metaspace
Interaktion mit der GC
12Elementare Eingabe und Ausgabe
Die Standard-Streams in, out und err
Klassenhierarchie für die einfache Eingabe und Ausgabe
Dateien lesen und schreiben
Sockets lesen und schreiben
Serialisierung
Verpacken und Entpacken von Dateien
13Die New I/O-API (NIO.2)
Das Path-Interface
Die Klasse Files
Zusätzliche Funktionen
14Nebenläufigkeit
Threads erstellen
Thread-Zustände
Thread-Priorität
Häufig verwendete Methoden
Synchronisierung
Concurrent-Package
15Java Collections-Framework
Das Collection-Interface
Implementierungen
Methoden des Collections-Frameworks
Collections-Klassenalgorithmen
Algorithmuseffizienz
Das funktionelle Interface Comparator
Praktische Fabrikmethoden
16Generics-Framework
Generische Klassen und Interfaces
Konstruktoren mit Generics
Substitutionsprinzip
Typparameter, Jokerzeichen und Grenzen
Das Get- und Put-Prinzip
Generische Spezialisierung
Generische Methoden in rohen Typen
17Die Java Scripting-API
Skriptsprachen
Script-Engine-Implementierungen
Skriptsprachen und Scripting-Engines einrichten
18Date and Time-API
Interoperabilität mit älterem Code
Regionale Kalender
ISO-Kalender
19Lambda-Ausdrücke
Lambda-Grundlagen
Funktionelle Interfaces mit bestimmten Aufgaben
Funktionelle Interfaces allgemeiner Natur
Ressourcen für Lambda-Ausdrücke
20JShell: die Java-Shell
Der Einstieg
Snippets
JShell verwenden
Features von JShell
Zusammenfassung der Befehle in JShell
21Das Java Module System
Project Jigsaw
Java-Module
Module kompilieren
Modulares JDK
jdeps
Ein Modul definieren
Ein Paket exportieren
Abhängigkeiten deklarieren
Transitive Abhängigkeiten
Service Provider definieren
jlink
Teil III: Anhänge
A»Sprechende« APIs
BExterne Werkzeuge
CUML-Grundlagen
Index
Diese Taschenreferenz soll Ihnen ein ständiger Begleiter sein und Ihnen als Kurzreferenz für die Grundeinrichtung der Programmiersprache Java sowie der Java-Plattform dienen.
Java kurz & gut liefert Ihnen die Informationen, die Sie benötigen, wenn Sie Java-Programme entwickeln oder debuggen. Das schließt nützliche Programmbeispiele, Tabellen, Abbildungen und Listen ein.
Das Buch behandelt Java bis Java SE 9 einschließlich eines Teils der über 80 JDK Enhancement Proposals (JEPs). Zudem geht es auf die neue Java-Shell und das neue Java Module System ein.
Die Codebeispiele in diesem Buch entstammen größtenteils der Gliesians Web Application (https://gliesians.com/index-genealogy.faces). Aktuell liegt deren Hauptfokus auf dem Bereitstellen kostenloser Tools rund um die Genealogie und kleiner Drohnen.
Der Stoff in diesem Buch unterstützt Sie außerdem bei der Vorbereitung auf die Prüfung zum Oracle Certified Programmer.
Dieses Buch hat die drei Teile: Teil I, »Sprache«, beschreibt die Programmiersprache Java in der Form, in der sie von der Java Language Specification (JLS) und in den JEPs formuliert wird. Teil II, »Plattform«, geht auf Bestandteile der Java-Plattform und darauf bezogene Themen ein. Die Anhänge in Teil III erläutern zusätzliche Technologien.
In diesem Buch werden die folgenden typografischen Konventionen verwendet:
Kursiv
Kennzeichnet neue Begriffe, URLs, E-Mail-Adressen, Dateinamen und Dateinamenserweiterungen.
Nicht-Proportional-Schrift
Wird für Programmcode verwendet und außerdem in Textabsätzen, um Programmelemente wie Variablen oder Funktionsnamen, Datenbanken, Umgebungsvariablen, Anweisungen und Schlüsselwörter zu kennzeichnen.
Nicht-Proportional-Schrift fett
Kennzeichnet Befehle oder anderen Text, den der Benutzer wörtlich eingeben muss.
Nicht-Proportional-Schrift kursiv
Kennzeichnet Text, der durch vom Benutzer vorgegebene oder durch den Kontext bestimmte Werte ersetzt werden muss.
|
Dieses Element kennzeichnet einen Tipp, einen Vorschlag oder eine allgemeine Anmerkung. |
Unser besonderer Dank gilt all den Leuten bei O’Reilly. Sehr unterstützt haben uns auch Greg Grockenberger und Ryan Cuprak, die zu den Kapiteln über JShell und das Java Module System beigetragen haben. Ryan war zudem an der technischen Begutachtung des Buchs beteiligt.
Außerdem möchten wie allen danken, die am ursprünglichen Java Pocket Guide, dem Java 7 Pocket Guide und dem Java 8 Pocket Guide mitgewirkt haben.
Ein weiterer Dank geht an Personen, die nichts mit diesem Buchprojekt zu tun haben: Don Anderson, David Chong, Keith Cianfrani, Jay Clark, Steve Cullen, Ed DiCampli, Phil Greco, Scott Houck, Cliff Johnson, Juan Keller, Fran Kelly, Mike Krauss, Mike Lazlo, Phil Maloney, Lana Manovych, Matt Mariani, Chris Martino, Roe Morande, Sohrob Mottaghi, Brendan Nugent, Keith Smaniotto, Tom Tessitore, Lacey Thompson, Tyler Travis, Justin Trulear und Jack Wombough.
Namenskonventionen dienen dazu, Java-Programme lesbarer zu machen. Es ist wichtig, dass man aussagekräftige und eindeutige Namen wählt, die aus Java-Buchstabenzeichen bestehen. Die folgenden Beispiele stammen aus verschiedensten Java-Quellen.
Wenn Sie in einem Namen ein Akronym verwenden, sollte nur der erste Buchstabe ein Großbuchstabe sein – und auch nur dann, wenn dort ein Großbuchstabe angemessen ist:
// zum Beispiel wird DNA als Dna genutzt
public class GliesianDnaProvider {...}
// Most Recent Common Ancestor (MRCA) ist Mrca
public class MrcaCalculator {...}
Annotationsnamen werden in der Java SE-API bei den vordefinierten Annotationstypen auf unterschiedliche Weise formuliert, [Adjektiv|Verb][Nomen]:
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}
Klassennamen sollten Nomen sein, da Klassen »Dinge« oder »Objekte« repräsentieren. Sie sollten gemischte Groß-/Kleinschreibung (CamelCase) verwenden, wobei nur der erste Buchstabe jedes Worts großgeschrieben wird, z. B.:
public class AirDensityCalculator {...}
Namen von Konstanten sollten gänzlich aus Großbuchstaben bestehen, und mehrere Wörter sollten durch Unterstriche getrennt werden:
private static final double KELVIN = 273.16;
private static final double DRY_AIR_GAS_CONSTANT = 287.058;
private static final double HUMID_AIR_GAS_CONSTANT = 461.4964;
Enumerationsnamen verwenden die gleichen Namenskonventionen wie Klassennamen. Die Namen der Elemente der Enumeration (die Optionen) sollten gänzlich aus Großbuchstaben bestehen:
public enum MeasurementSystem {
METRIC, UNITED_STATES_CUSTOMARY, IMPERIAL
}
public enum Study {
ALL, NON_ENDOGAMOUS, SEMI_ENDOGAMOUS, ENDOGAMOUS
}
public enum RelationshipMatchCategory {
IMMEDIATE, CLOSE, DISTANT, SPECULATIVE
}
Die Namen generischer Typparameter sollten aus nur einem Großbuchstaben bestehen. Üblicherweise wird der Buchstabe T (für Typ) verwendet.
Das Collections-Framework macht umfassenden Gebrauch von Generics. E wird für Collection-Elemente genutzt, S für Service-Loader sowie K und V für Schlüssel (Key) und Werte (Value) in Maps:
public interface Map <K,V> {
V put(K key, V value);
}
Die Namen von Instanzvariablen und statischen Variablen sollten Nomen sein und den gleichen Namenskonventionen folgen wie Methodennamen:
private String prediction;
Interface-Namen sollten Adjektive sein, die auf »able« oder »ible« enden, wenn ein Interface eine Fähigkeit darstellt; andernfalls sollten Interface-Namen ebenfalls Nomen sein. Interface-Namen folgen den gleichen Konventionen für die Groß-/Kleinschreibung wie Klassennamen:
public interface Relatable {...}
public interface SystemPanel {...}
Methodennamen sollten ein Verb enthalten, da Methoden genutzt werden, um Objekte etwas unternehmen zu lassen. Die Groß-/Kleinschreibung sollte erneut gemischt sein, wobei der Name hier idealerweise mit einem Kleinbuchstaben beginnt und die ersten Buchstaben aller nachfolgenden Wörter großgeschrieben werden sollten. Methodennamen können Adjektive und Nomen enthalten:
public void clear() {...} // Verb
public String toString() {...} // Präposition und Nomen
public double getDryAirDensity() {...} // Verb, Adjektiv und Nomen
public double getHumidAirDensity() {...} // Verb, Adjektiv und Nomen
Package-Namen sollten einzigartig sein und vollständig aus Kleinbuchstaben bestehen. Bei Bedarf können Unterstriche gesetzt werden:
// Gliesian.com (Firma), JAirDensity (Software)
package com.gliesian.jairdensity;
// Gliesian.com (Firma), FOREX Calculator (Software), Utilities
package com.gliesian.forex_calculator.utils;
Der Name öffentlich zugänglicher Packages sollte der umgekehrte Domainname der Organisation sein, der mit der aus einem Wort bestehenden Top-Level-Domain (d. h. com, net, org oder edu) beginnt, auf die der Name der Organisation und der Name des Projekts oder der Abteilung folgen. (Interne Packages werden üblicherweise nach dem Projekt benannt.)
Package-Namen, die mit java oder javax beginnen, sind reserviert und dürfen nur für Implementierungen verwendet werden, die den Java-Klassenbibliotheken entsprechen.
Modulnamen sollten wie Paketnamen aus umgekehrten Domainnamen bestehen (mit den gleichen Richtlinien):
module com.gliesian.utils {
}
Die Namen von Parametern oder lokalen Variablen sollten aussagekräftige (kleingeschriebene) einzelne Wörter, Akronyme oder Abkürzungen sein. Wenn mehrere Wörter erforderlich sind, folgt die Groß-/Kleinschreibung der Namen den gleichen Konventionen wie die der Methodennamen:
public void printPredictions(ArrayList predictions) {
int counter = 1;
for (String prediction : predictions) {
System.out.println("Vorhersage Nr. " + counter++ + ": " + prediction);
}
}
Die Namen temporärer Variablen können auch aus nur einem einzigen Buchstaben bestehen, z. B. i, j, k, m und n für ganze Zahlen sowie c, d und e für Zeichen. Für temporäre und Schleifenvariablen werden einbuchstabige Namen wie in Tabelle 1-1 vorgeschlagen.
Tabelle 1-1: Temporäre und Schleifenvariablen
Einbuchstabiger Name |
Typ |
b |
Byte |
c |
Character |
d |
Double |
e |
Exception |
f |
Float |
i, j oder k |
Integer |
l |
Long |
o |
Object |
s |
String |
Java-Quellcode besteht aus Wörtern oder Symbolen, die als lexikalische Elemente oder Token bezeichnet werden. Zu den lexikalischen Elementen von Java zählen Zeilenendezeichen, Leerraumzeichen, Kommentare, Schlüsselwörter, Bezeichner, Trennzeichen, Operatoren und Literale. Die Wörter und Symbole bestehen in der Programmiersprache Java aus Zeichen aus dem Unicode-Zeichensatz.
Der von der Standardisierungsorganisation Unicode Consortium gepflegte Unicode ist ein allgemeiner Zeichensatz, dessen erste 128 Zeichen denen des Zeichensatzes ASCII (American Standard Code for Information Interchange) entsprechen. Unicode stellt eine eindeutige Nummer für jedes Zeichen bereit und kann auf allen Plattformen, in allen Programmen und mit allen Sprachen verwendet werden. Java SE 9 nutzt Unicode 8.0.0. Mehr Informationen dazu finden Sie im Onlinehandbuch (http://www.unicode.org/versions/Unicode8.0.0/). Java SE 8 nutzt Unicode 6.2.0.
|
Kommentare, Bezeichner und Stringliterale sind in Java nicht auf ASCII-Zeichen beschränkt. Alle anderen Java-Eingabeelemente werden aus ASCII-Zeichen gebildet. |
Die Unicode-Version, die von der jeweiligen Java-Plattform verwendet wird, wird in der Character-Klasse der Java-API dokumentiert. Auf eine Liste der Unicode-Zeichencodes für Schriftzeichen, Symbole und Interpunktionszeichen können Sie unter http://unicode.org/charts/ zugreifen.
ASCII reserviert Code 32 (Leerzeichen) und die Codes 33 bis 126 (Buchstaben, Ziffern, Interpunktionszeichen und ein paar weitere Zeichen) für druckbare Zeichen. Tabelle 2-1 zeigt die dezimalen Werte und die ASCII-Zeichen, die diesen Codes entsprechen.
Tabelle 2-1: Druckbare ASCII-Zeichen
ASCII reserviert die Codes 0 bis 31 sowie Code 127 für Steuerzeichen. Tabelle 2-2 zeigt die dezimalen Werte und die ASCII-Zeichen für den jeweiligen Code.
Tabelle 2-2: Nicht druckbare ASCII-Zeichen
|
ASCII 10 ist ein Zeilenvorschub, ASCII 13 ein Wagenrücklauf. |
Kompakte Strings sind eine Optimierung, die es erlaubt, Strings speichereffizienter abzulegen. In Java 9 ist sie standardmäßig aktiviert. Um sie abzuschalten, nutzen Sie -XX:-CompactStrings+, wenn Sie vor allem UTF16-Strings nutzen.
Ein einzeiliger Kommentar beginnt mit zwei Schrägstrichen und endet unmittelbar vor dem Zeilenendezeichen:
// Standard-Geburtsjahr eines Kindes
private Integer childsBIrthYear = 1950;
Ein mehrzeiliger Kommentar beginnt mit einem Schrägstrich, auf den unmittelbar ein Asterisk folgt, und endet mit einem Asterisk, auf den unmittelbar ein Schrägstrich folgt. Ein einzelner Asterisk zu Anfang der einzelnen Kommentarzeilen ist eine nützliche Formatierungskonvention; das ist üblich, aber nicht erforderlich:
/*
* Das Durchschnittsalter einer Frau bei der Geburt
* ihres ersten Kindes betrug in den USA im Jahr 2001
* 24.9 Jahre. Daher werden wir den Wert von 25 Jahren
* als Standardvorschlag nutzen.
*/
private Integer mothersAgeGivingBirth = 25;
Ein Javadoc-Kommentar wird vom Javadoc-Werkzeug verarbeitet, um eine API-Dokumentation im HTML-Format zu generieren. Ein Javadoc-Kommentar beginnt mit einem Schrägstrich, auf den unmittelbar zwei Asteriske folgen, und schließt mit einem Asterisk, auf den unmittelbar ein Schrägstrich folgt (Oracles Dokumentationsseite (http://bit.ly/16mhGeT) bietet weitere Informationen zum Javadoc-Werkzeug):
/**
* Genitor Birthdate Predictor
*
* @author Robert J. Liguori
* @author Gliesian, LLC.
* @version 0.1.1 09-02-16
* @since 0.1.0 09-01-16
*/
public class GenitorBirthdatePredictorBean {...}
Kommentare dürfen in Java nicht geschachtelt werden:
/* Das hier ist /* in Java */ nicht gestattet. */
Tabelle 2-3 enthält die Schlüsselwörter von Java 9. Zwei davon, const und goto, sind reserviert, werden von Java aber nicht verwendet.
|
Java-Schlüsselwörter dürfen in Java-Programmen nicht als Bezeichner verwendet werden. |
Tabelle 2-3: Java-Schlüsselwörter
abstract |
assert |
boolean |
break |
byte |
case |
catch |
char |
class |
const |
continue |
default |
do |
double |
else |
enum |
exports |
extends |
final |
finally |
float |
for |
goto |
if |
implements |
import |
instanceof |
int |
interface |
long |
module |
native |
new |
package |
private |
protected |
provides |
public |
requires |
return |
short |
static |
strictfp |
super |
switch |
synchronized |
this |
throw |
throws |
to |
transient |
try |
uses |
void |
volatile |
while |
with |
_ |
|
Gelegentlich werden true, false und null fälschlich als Schlüsselwörter betrachtet. Es sind jedoch keine Schlüsselwörter, sondern reservierte Literale. |
Ein Java-Bezeichner ist ein Name, den ein Programmierer einer Klasse, einer Methode, einer Variablen und so weiter gibt.
Bezeichner dürfen nicht aus der gleichen Unicode-Zeichenfolge bestehen wie Schlüsselwörter oder die vordefinierten Literale true, false und null.
Java-Bezeichner werden aus Java-Zeichen gebildet. Ein Java-Zeichen ist ein Zeichen, für das Character.isJavaIdentifierStart(int) true liefert. Aus dem ASCII-Zeichensatz sind nur das Dollarzeichen ($), Groß- und Kleinbuchstaben und der Unterstrich (_) Java-Zeichen. Seit Java 9 handelt es sich bei dem Unterstrich (_) um ein Schlüsselwort, das für sich allein nicht als Bezeichner genutzt werden darf.
Ziffern sind in Bezeichnern ebenfalls gestattet, aber erst nach dem ersten Zeichen:
// zulässige Java-Bezeichner
class GedcomBean {
private File uploadedFile; // Groß- und
// Kleinbuchstaben
private File _file; // führender Unterstrich
private File $file; // führendes $
private File file1; // Ziffer im Bezeichner
}
Namenskonventionen finden Sie in Kapitel 1.
Mehrere ASCII-Zeichen begrenzen Teile des Programms und werden als Trennzeichen eingesetzt. (), { }, [ ] und < > werden paarweise verwendet:
() { } [ ] < > :: : ; , . ->
Tabelle 2-4 beinhaltet eine Aufstellung der verschiedenen Arten von Klammern und ihrer Einsatzgebiete.
Tabelle 2-4: Klammer-Trennzeichen in Java
Klammer |
Bezeichnung |
Verwendung |
( ) |
Klammern, runde Klammern |
Definiert den Vorrang in arithmetischen Ausdrücken, schließt Typ-Casts ein und umgibt die Menge der Methodenargumente. |
{ } |
geschweifte Klammern |
Schließt Codeblöcke und Array-Literale ein. |
[ ] |
eckige Klammern |
Array-Deklaration und Zugriff. |
< > |
spitze Klammern |
Schließt generische Typargumente ein. |
Guillemets oder umgekehrte französische Anführungszeichen werden eingesetzt, um in UML Stereotypen anzugeben: « ».
Operatoren führen Operationen auf einem, zwei oder drei Operanden aus und liefern ein Ergebnis. Java-Operatoren fallen in unterschiedliche Kategorien: Zuweisung, Arithmetik, Vergleich, Bit-Operation und Klasse/Objekt. Tabelle 2-5 bietet eine Aufstellung der Java-Operatoren in der Reihenfolge des Vorrangs (wobei die mit der höchsten Priorität zu Beginn der Tabelle stehen). Sie enthält eine kurze Beschreibung des Operators und seine Assoziativität (d. h., ob er von rechts nach links oder von links nach rechts ausgewertet wird).
Tabelle 2-5: Java-Operatoren
Literale sind Quellcoderepräsentationen von Werten. Seit Java SE 7 sind in numerischen Literalen Unterstriche gestattet, um die Lesbarkeit von Code zu verbessern. Die Unterstriche können zwischen einzelnen Ziffern angegeben werden und werden zur Laufzeit ignoriert.
Mehr Informationen zu Literalen elementarer Typen finden Sie in Abschnitt »Literale für elementare Typen« auf Seite 40 in Kapitel 3.
Boolesche Literale werden entweder mit true oder mit false angegeben:
boolean isFullRelation = true;
boolean isHalfRelation = Boolean.valueOf(false); // Unboxing
boolean isEndogamyPresent = false;
Ein Zeichenliteral ist entweder ein einzelnes Zeichen oder eine Escape-Sequenz in einfachen Anführungszeichen. Zeilenendezeichen sind nicht gestattet:
char charValue1 = 'a';
// ein Apostroph
Character charValue2 = Character.valueOf('\'');
Ganzzahlige Typen oder Integer-Typen ( byte, short, int und long) können dezimal, hexadezimal, oktal oder binär angegeben werden. Standardmäßig haben ganzzahlige Literale den Typ int:
int intValue1 = 34567, intValue2 = 1_000_000;
Dezimale Ganzzahlen enthalten eine beliebige Anzahl der ASCII-Ziffern 0 bis 9 und repräsentieren positive Zahlen:
Integer integerValue1 = Integer.valueOf(100);
Wird einem dezimalen Wert der unäre Negationsoperator vorangestellt, wird ein negativer Dezimalwert gebildet:
public static final int INT_VALUE = -200;
Hexadezimale Literale beginnen mit 0x oder 0X. Darauf folgen die ASCII-Ziffern 0 bis 9 und die Buchstaben a bis f (oder A bis F). Bei hexadezimalen Literalen berücksichtigt Java Groß-/Kleinschreibung nicht.
Hexadezimale Zahlen können positive und negative ganze Zahlen sowie null repräsentieren:
int intValue3 = 0X64; // dezimal 100 in Hexform
Oktale Literale beginnen mit einer Null, auf die eine oder mehrere der ASCII-Ziffern 0 bis 7 folgen:
int intValue4 = 0144; // dezimal 100 in Oktalform
Binäre Literale werden mit dem Präfix 0b oder 0B angegeben, auf das Nullen und Einsen folgen:
char msgValue1 = 0b01001111; // O
char msgValue2 = 0B01001011; // K
char msgValue3 = 0B0010_0001; // !
Wollen Sie eine Ganzzahl mit dem Typ long definieren, hängen Sie dem Literal den ASCII-Buchstaben L (empfohlen und besser lesbar) oder l an:
long longValue = 100L;
Ein gültiges Gleitkommaliteral erfordert eine ganze Zahl und/oder einen Nachkommaanteil, einen Dezimaltrenner und ein Typsuffix. Ein Exponent, dem ein e oder E vorangestellt ist, ist optional. Nachkommaanteil und Dezimaltrenner sind nicht erforderlich, wenn ein Exponent oder ein Typsuffix angegeben wird.
Ein Gleitkommaliteral (double) ist ein Gleitkommawert doppelter Genauigkeit, bestehend aus acht Bytes. Ein float hat vier Bytes. Das Typsuffix für double-Werte ist d oder D, das für float-Werte f oder F:
[ganze_Zahl].[Nachkommaanteil][e|E exp][f|F|d|D]
float floatValue1 = 9.15f, floatValue2 = 1_168f;
Float floatValue3 = new Float(20F);
double doubleValue1 = 3.12;
Double doubleValue2 = Double.valueOf(1e058);
float expValue1 = 10.0e2f, expValue2=10.0E3f;
Stringliterale enthalten null oder mehr Zeichen, einschließlich Escape-Sequenzen, in einem Paar doppelter Anführungszeichen. Stringliterale dürfen die Unicode-Zeilenendezeichen \u000a und \u000d nicht enthalten. Nutzen Sie stattdessen die Escape-Sequenzen \r und \n. Strings sind unveränderlich:
String stringValue1 = new String("Gültiges Literal.");
String stringValue2 = "Gültig.\nAuf einer neuen Zeile.";
String stringValue3 = "Verkettete Str" + "ings";
String stringValue4 = "\"Escape-Sequenzen\"\r";
Mit der Klasse String ist ein Stringpool verknüpft. Dieser Pool ist zu Anfang leer. Stringliterale und konstante Stringausdrücke werden in diesem Pool gespeichert und werden ihm auch nur einmal hinzugefügt.
Das folgende Beispiel zeigt, wie die Literale dem Pool hinzugefügt und wie sie aus dem Pool verwendet werden:
// Fügt dem Pool "derString" hinzu.
String stringValue5 = "derString";
// Nutzt den String "derString" aus dem Pool.
String stringValue6 = "derString"
Ein String kann dem Pool explizit hinzugefügt werden (falls er noch nicht im Pool vorhanden ist), indem auf dem String die Methode intern() aufgerufen wird. intern()
