Java 7 - Mehr als eine Insel · 2.8.2 Paralleles Lösen von D&C-Algorithmen ... 4.9.1 Ausgaben mit printf() ... 1123 15.1.2 (J)

Christian Ullenboom

Java 7 – Mehr als eine InselDas Handbuch zu den Java SE-Bibliotheken

1507.book Seite 1 Mittwoch, 12. Oktober 2011 12:49 12

Auf einen Blick

1 Neues in Java 7 .................................................................................................. 41

2 Threads und nebenläufige Programmierung .............................................. 65

3 Datenstrukturen und Algorithmen ............................................................... 175

4 Raum und Zeit ................................................................................................... 305

5 Dateien, Verzeichnisse und Dateizugriffe ................................................... 357

6 Datenströme ...................................................................................................... 427

7 Die eXtensible Markup Language (XML) ...................................................... 531

8 Dateiformate ..................................................................................................... 617

9 Grafische Oberflächen mit Swing ................................................................. 645

10 Grafikprogrammierung ................................................................................... 865

11 Netzwerkprogrammierung ............................................................................. 955

12 Verteilte Programmierung mit RMI .............................................................. 1035

13 RESTful und SOAP Web-Services .................................................................... 1057

14 JavaServer Pages und Servlets ....................................................................... 1079

15 Applets ................................................................................................................ 1123

16 Datenbankmanagement mit JDBC ................................................................ 1139

17 Technologien für die Infrastruktur ................................................................ 1207

18 Reflection und Annotationen ......................................................................... 1227

19 Dynamische Übersetzung und Skriptsprachen .......................................... 1289

20 Logging und Monitoring .................................................................................. 1315

21 Java Native Interface (JNI) ............................................................................... 1337

22 Sicherheitskonzepte ......................................................................................... 1355

23 Dienstprogramme für die Java-Umgebung ................................................. 1381


5

Inhalt

Inhalt

Vorwort ...................................................................................................................................................... 35

1 Neues in Java 7

1.1 Sprachänderungen ........................................................................................................................ 41

1.1.1 Zahlen im Binärsystem schreiben .......................................................................... 41

1.1.2 Unterstriche bei Ganzzahlen .................................................................................... 41

1.1.3 switch (String) ................................................................................................................ 42

1.1.4 Zusammenfassen gleicher catch-Blöcke mit dem multi-catch ...................... 43

1.1.5 Präzisiertes rethrows .................................................................................................. 47

1.1.6 Automatisches Ressourcen-Management (try mit Ressourcen) ................... 51

1.1.7 try mit Ressourcen ....................................................................................................... 51

1.1.8 Ausnahmen vom close() bleiben bestehen .......................................................... 53

1.1.9 Die Schnittstelle AutoCloseable ............................................................................... 53

1.1.10 Mehrere Ressourcen nutzen ..................................................................................... 55

1.1.11 Unterdrückte Ausnahmen * ...................................................................................... 56

1.2 JVM-Änderungen ........................................................................................................................... 59

1.2.1 invokedynamic ............................................................................................................. 60

1.3 Neue Pakete und Klassen ............................................................................................................ 63

1.3.1 Weitere Änderungen ................................................................................................... 63

2 Threads und nebenläufige Programmierung

2.1 Threads erzeugen .......................................................................................................................... 65

2.1.1 Threads über die Schnittstelle Runnable implementieren ............................. 65

2.1.2 Thread mit Runnable starten ................................................................................... 66

2.1.3 Die Klasse Thread erweitern ..................................................................................... 68

2.2 Thread-Eigenschaften und -Zustände ..................................................................................... 71

2.2.1 Der Name eines Threads ............................................................................................ 71

2.2.2 Wer bin ich? .................................................................................................................... 72

2.2.3 Die Zustände eines Threads * .................................................................................... 72


Inhalt

6

2.2.4 Schläfer gesucht ........................................................................................................... 73

2.2.5 Mit yield() auf Rechenzeit verzichten ................................................................... 75

2.2.6 Der Thread als Dämon ................................................................................................ 76

2.2.7 Das Ende eines Threads ............................................................................................. 78

2.2.8 Einen Thread höflich mit Interrupt beenden ..................................................... 79

2.2.9 UncaughtExceptionHandler für unbehandelte Ausnahmen ........................ 81

2.2.10 Der stop() von außen und die Rettung mit ThreadDeath * ............................. 82

2.2.11 Ein Rendezvous mit join() * ...................................................................................... 84

2.2.12 Arbeit niederlegen und wieder aufnehmen * ..................................................... 87

2.2.13 Priorität * ........................................................................................................................ 87

2.3 Der Ausführer (Executor) kommt ............................................................................................. 88

2.3.1 Die Schnittstelle Executor ......................................................................................... 89

2.3.2 Die Thread-Pools .......................................................................................................... 91

2.3.3 Threads mit Rückgabe über Callable ..................................................................... 92

2.3.4 Mehrere Callable abarbeiten .................................................................................... 96

2.3.5 ScheduledExecutorService für wiederholende Ausgaben und

Zeitsteuerungen nutzen ............................................................................................ 97

2.4 Synchronisation über kritische Abschnitte ........................................................................... 98

2.4.1 Gemeinsam genutzte Daten .................................................................................... 98

2.4.2 Probleme beim gemeinsamen Zugriff und kritische Abschnitte ................. 98

2.4.3 Punkte parallel initialisieren ................................................................................... 100

2.4.4 i++ sieht atomar aus, ist es aber nicht * ................................................................ 102

2.4.5 Kritische Abschnitte schützen ................................................................................. 103

2.4.6 Kritische Abschnitte mit ReentrantLock schützen ........................................... 106

2.4.7 Synchronisieren mit synchronized ....................................................................... 113

2.4.8 Synchronized-Methoden der Klasse StringBuffer * .......................................... 114

2.4.9 Mit synchronized synchronisierte Blöcke ........................................................... 115

2.4.10 Dann machen wir doch gleich alles synchronisiert! ........................................ 117

2.4.11 Lock-Freigabe im Fall von Exceptions ................................................................... 118

2.4.12 Deadlocks ....................................................................................................................... 119

2.4.13 Mit synchronized nachträglich synchronisieren * ............................................ 121

2.4.14 Monitore sind reentrant – gut für die Geschwindigkeit * ............................... 122

2.4.15 Synchronisierte Methodenaufrufe zusammenfassen * .................................. 123

2.5 Synchronisation über Warten und Benachrichtigen .......................................................... 124

2.5.1 Die Schnittstelle Condition ...................................................................................... 125

2.5.2 It’s Disco-Time * ........................................................................................................... 129


Inhalt

7

2.5.3 Warten mit wait() und Aufwecken mit notify() * ................................................ 135

2.5.4 Falls der Lock fehlt: IllegalMonitorStateException * ......................................... 136

2.6 Datensynchronisation durch besondere Concurrency-Klassen * ..................................... 138

2.6.1 Semaphor ........................................................................................................................ 138

2.6.2 Barrier und Austausch ................................................................................................ 143

2.6.3 Stop and go mit Exchanger ....................................................................................... 145

2.7 Atomare Operationen und frische Werte mit volatile * ..................................................... 145

2.7.1 Der Modifizierer volatile bei Objekt-/Klassenvariablen .................................. 146

2.7.2 Das Paket java.util.concurrent.atomic ................................................................... 148

2.8 Teile und herrsche mit Fork und Join * .................................................................................... 149

2.8.1 Algorithmendesign per »teile und herrsche« ..................................................... 149

2.8.2 Paralleles Lösen von D&C-Algorithmen ............................................................... 151

2.8.3 Fork und Join ................................................................................................................. 152

2.9 Mit dem Thread verbundene Variablen * ............................................................................... 156

2.9.1 ThreadLocal .................................................................................................................... 156

2.9.2 InheritableThreadLocal .............................................................................................. 159

2.9.3 ThreadLocalRandom als Zufallszahlengenerator ............................................... 160

2.9.4 ThreadLocal bei der Performance-Optimierung ................................................ 161

2.10 Threads in einer Thread-Gruppe * ............................................................................................ 162

2.10.1 Aktive Threads in der Umgebung ........................................................................... 162

2.10.2 Etwas über die aktuelle Thread-Gruppe herausfinden ..................................... 163

2.10.3 Threads in einer Thread-Gruppe anlegen ............................................................. 166

2.10.4 Methoden von Thread und ThreadGroup im Vergleich .................................. 169

2.11 Zeitgesteuerte Abläufe ................................................................................................................ 170

2.11.1 Die Typen Timer und TimerTask ............................................................................. 171

2.11.2 Job-Scheduler Quartz .................................................................................................. 172

2.12 Einen Abbruch der virtuellen Maschine erkennen ............................................................... 173

2.13 Zum Weiterlesen ........................................................................................................................... 174

3 Datenstrukturen und Algorithmen

3.1 Datenstrukturen und die Collection-API ................................................................................ 175

3.1.1 Designprinzip mit Schnittstellen, abstrakten und konkreten Klassen ....... 176

3.1.2 Die Basis-Schnittstellen Collection und Map ...................................................... 176

3.1.3 Die Utility-Klassen Collections und Arrays .......................................................... 177


Inhalt

8

3.1.4 Das erste Programm mit Container-Klassen ...................................................... 177

3.1.5 Die Schnittstelle Collection und Kernkonzepte ................................................. 178

3.1.6 Schnittstellen, die Collection erweitern, und Map ............................................ 182

3.1.7 Konkrete Container-Klassen .................................................................................... 185

3.1.8 Generische Datentypen in der Collection-API .................................................... 187

3.1.9 Die Schnittstelle Iterable und das erweiterte for ............................................... 187

3.2 Listen ................................................................................................................................................ 188

3.2.1 Erstes Listen-Beispiel .................................................................................................. 189

3.2.2 Auswahlkriterium ArrayList oder LinkedList ..................................................... 190

3.2.3 Die Schnittstelle List ................................................................................................... 191

3.2.4 ArrayList ......................................................................................................................... 197

3.2.5 LinkedList ....................................................................................................................... 200

3.2.6 Der Feld-Adapter Arrays.asList() ............................................................................. 201

3.2.7 ListIterator * ................................................................................................................... 202

3.2.8 toArray() von Collection verstehen – die Gefahr einer Falle erkennen ...... 204

3.2.9 Primitive Elemente in Datenstrukturen verwalten .......................................... 207

3.3 Mengen (Sets) ................................................................................................................................ 208

3.3.1 Ein erstes Mengen-Beispiel ....................................................................................... 209

3.3.2 Methoden der Schnittstelle Set ............................................................................... 212

3.3.3 HashSet ........................................................................................................................... 213

3.3.4 TreeSet – die sortierte Menge .................................................................................. 214

3.3.5 Die Schnittstellen NavigableSet und SortedSet ................................................. 216

3.3.6 LinkedHashSet .............................................................................................................. 218

3.4 Stack (Kellerspeicher, Stapel) .................................................................................................... 218

3.4.1 Die Methoden von Stack ........................................................................................... 219

3.5 Queues (Schlangen) und Deques .............................................................................................. 220

3.5.1 Queue-Klassen .............................................................................................................. 221

3.5.2 Deque-Klassen .............................................................................................................. 222

3.5.3 Blockierende Queues und Prioritätswarteschlangen ....................................... 223

3.5.4 PriorityQueue ............................................................................................................... 223

3.6 Assoziative Speicher .................................................................................................................... 228

3.6.1 Die Klassen HashMap und TreeMap ...................................................................... 228

3.6.2 Einfügen und Abfragen der Datenstruktur ......................................................... 231

3.6.3 Über die Bedeutung von equals() und hashCode() ............................................ 234

3.6.4 Eigene Objekte hashen ............................................................................................... 235

3.6.5 IdentityHashMap ......................................................................................................... 237

3.6.6 Das Problem von veränderten Elementen .......................................................... 237


Inhalt

9

3.6.7 Aufzählungen und Ansichten des Assoziativspeichers ................................... 237

3.6.8 Die Arbeitsweise einer Hash-Tabelle * ................................................................... 241

3.7 Die Properties-Klasse ................................................................................................................... 243

3.7.1 Properties setzen und lesen ...................................................................................... 243

3.7.2 Properties verketten .................................................................................................... 244

3.7.3 Hierarchische Eigenschaften .................................................................................... 245

3.7.4 Eigenschaften auf der Konsole ausgeben * .......................................................... 245

3.7.5 Properties laden und speichern ............................................................................... 246

3.7.6 Klassenbeziehungen: Properties und Hashtable * ............................................. 248

3.8 Mit einem Iterator durch die Daten wandern ....................................................................... 249

3.8.1 Die Schnittstelle Iterator ............................................................................................ 249

3.8.2 Der Iterator kann (eventuell auch) löschen ......................................................... 251

3.8.3 Einen Zufallszahleniterator schreiben .................................................................. 252

3.8.4 Iteratoren von Sammlungen, das erweiterte for und Iterable ....................... 254

3.8.5 Fail-Fast-Iterator und die ConcurrentModificationException ....................... 258

3.8.6 Die Schnittstelle Enumerator * ................................................................................ 260

3.9 Algorithmen in Collections ......................................................................................................... 261

3.9.1 Die Bedeutung von Ordnung mit Comparator und Comparable ................. 263

3.9.2 Sortieren .......................................................................................................................... 264

3.9.3 Den größten und kleinsten Wert einer Collection finden ............................... 267

3.9.4 Nicht-änderbare Datenstrukturen, immutable oder nur-lesen? ................... 270

3.9.5 Null Object Pattern und leere Sammlungen/Iteratoren zurückgeben ........ 274

3.9.6 Mit der Halbierungssuche nach Elementen fahnden ....................................... 278

3.9.7 Ersetzen, Kopieren, Füllen, Umdrehen, Rotieren * ............................................ 279

3.9.8 Listen durchwürfeln * ................................................................................................. 281

3.9.9 Häufigkeit eines Elements * ...................................................................................... 282

3.9.10 Singletons * ..................................................................................................................... 282

3.9.11 nCopies() * ....................................................................................................................... 283

3.10 Spezielle thread-sichere Datenstrukturen ............................................................................. 284

3.10.1 Wait-free-Algorithmen ............................................................................................... 284

3.10.2 Nebenläufiger Assoziativspeicher und die Schnittstelle

ConcurrentMap ............................................................................................................. 284

3.10.3 ConcurrentLinkedQueue ........................................................................................... 285

3.10.4 CopyOnWriteArrayList und CopyOnWriteArraySet .......................................... 285

3.10.5 Wrapper zur Synchronisation .................................................................................. 286

3.10.6 Blockierende Warteschlangen .................................................................................. 287


Inhalt

10

3.10.7 ArrayBlockingQueue und LinkedBlockingQueue ............................................. 287

3.10.8 PriorityBlockingQueue .............................................................................................. 290

3.11 Google Guava (aka Google Collections Library) .................................................................. 294

3.11.1 Beispiel Multi-Set und Multi-Map .......................................................................... 294

3.11.2 Datenstrukturen aus Guava ..................................................................................... 295

3.11.3 Utility-Klassen von Guava ........................................................................................ 297

3.11.4 Prädikate ......................................................................................................................... 298

3.11.5 Transformationen ....................................................................................................... 299

3.12 Die Klasse BitSet für Bitmengen * ............................................................................................ 299

3.12.1 Ein BitSet anlegen, füllen und erfragen ................................................................ 300

3.12.2 Mengenorientierte Operationen ............................................................................ 301

3.12.3 Methodenübersicht .................................................................................................... 302

3.12.4 Primzahlen in einem BitSet verwalten ................................................................. 304

3.13 Zum Weiterlesen .......................................................................................................................... 304

4 Raum und Zeit

4.1 Weltzeit * ........................................................................................................................................ 305

4.2 Wichtige Datum-Klassen im Überblick .................................................................................. 306

4.2.1 Der 1.1.1970 ................................................................................................................... 307

4.2.2 System.currentTimeMillis() ..................................................................................... 307

4.2.3 Einfache Zeitumrechnungen durch TimeUnit ................................................... 307

4.3 Sprachen der Länder .................................................................................................................... 308

4.3.1 Sprachen und Regionen über Locale-Objekte ..................................................... 309

4.4 Internationalisierung und Lokalisierung ............................................................................... 312

4.4.1 ResourceBundle-Objekte und Ressource-Dateien ............................................. 313

4.4.2 Ressource-Dateien zur Lokalisierung .................................................................... 314

4.4.3 Die Klasse ResourceBundle ...................................................................................... 314

4.4.4 Ladestrategie für ResourceBundle-Objekte ......................................................... 316

4.5 Die Klasse Date .............................................................................................................................. 317

4.5.1 Objekte erzeugen und Methoden nutzen ............................................................ 317

4.5.2 Date-Objekte sind nicht immutable ...................................................................... 319

4.6 Calendar und GregorianCalendar ............................................................................................ 320

4.6.1 Die abstrakte Klasse Calendar .................................................................................. 320

4.6.2 Der gregorianische Kalender ................................................................................... 322


Inhalt

11

4.6.3 Calendar nach Date und Millisekunden fragen .................................................. 325

4.6.4 Ostertage * ...................................................................................................................... 326

4.6.5 Abfragen und Setzen von Datumselementen über Feldbezeichner ............ 328

4.6.6 Wie viele Tage hat der Monat, oder wie viele Monate hat ein Jahr? * .......... 333

4.6.7 Wann beginnt die Woche und wann die erste Woche im Jahr? * .................. 335

4.7 Zeitzonen in Java * ........................................................................................................................ 336

4.7.1 Zeitzonen durch die Klasse TimeZone repräsentieren ..................................... 337

4.7.2 SimpleTimeZone .......................................................................................................... 337

4.7.3 Methoden von TimeZone .......................................................................................... 339

4.8 Zeitdauern und der XML-Datentyp Duration * ..................................................................... 340

4.8.1 DatatypeFactory als Fabrik ........................................................................................ 341

4.8.2 Die Duration-Klasse und ihre Methoden .............................................................. 342

4.9 Formatieren und Parsen von Datumsangaben ..................................................................... 345

4.9.1 Ausgaben mit printf() .................................................................................................. 345

4.9.2 Mit DateFormat und SimpleDateFormat formatieren ..................................... 346

4.9.3 Parsen von Datumswerten ........................................................................................ 352

4.10 Zum Weiterlesen ........................................................................................................................... 355

5 Dateien, Verzeichnisse und Dateizugriffe

5.1 Datei und Verzeichnis .................................................................................................................. 357

5.1.1 Dateien und Verzeichnisse mit der Klasse File ................................................... 358

5.1.2 Verzeichnis oder Datei? Existiert es? ..................................................................... 361

5.1.3 Verzeichnis- und Dateieigenschaften/-attribute ............................................... 362

5.1.4 Umbenennen und Verzeichnisse anlegen ........................................................... 365

5.1.5 Verzeichnisse auflisten und Dateien filtern ........................................................ 365

5.1.6 Dateien berühren, neue Dateien anlegen, temporäre Dateien ...................... 369

5.1.7 Dateien und Verzeichnisse löschen ........................................................................ 370

5.1.8 Verzeichnisse nach Dateien iterativ durchsuchen * .......................................... 372

5.1.9 Wurzelverzeichnis, Laufwerksnamen, Plattenspeicher * ................................ 373

5.1.10 URL-, URI- und Path-Objekte aus einem File-Objekt ableiten * ...................... 376

5.1.11 Mit Locking Dateien sperren * .................................................................................. 376

5.1.12 Sicherheitsprüfung * ................................................................................................... 377

5.1.13 Zugriff auf SMB-Server mit jCIFS * .......................................................................... 378


Inhalt

12

5.2 Dateien mit wahlfreiem Zugriff ............................................................................................... 378

5.2.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen .............................. 379

5.2.2 Aus dem RandomAccessFile lesen ......................................................................... 380

5.2.3 Schreiben mit RandomAccessFile .......................................................................... 383

5.2.4 Die Länge des RandomAccessFile ........................................................................... 384

5.2.5 Hin und her in der Datei ............................................................................................ 384

5.3 Dateisysteme unter NIO.2 .......................................................................................................... 385

5.3.1 FileSystem und Path ................................................................................................... 386

5.3.2 Die Utility-Klasse Files ............................................................................................... 392

5.3.3 Dateien kopieren und verschieben ........................................................................ 395

5.3.4 Dateiattribute * ............................................................................................................. 397

5.3.5 Neue Dateien, Verzeichnisse, symbolische Verknüpfungen anlegen

und löschen ................................................................................................................... 406

5.3.6 MIME-Typen testen * .................................................................................................. 408

5.3.7 Verzeichnislistings (DirectoryStream) und Filter * ........................................... 410

5.3.8 Rekursive Abläufe des Verzeichnisbaums (FileVisitor) * ................................ 412

5.3.9 Dateisysteme und Dateisystemattribute * .......................................................... 416

5.3.10 Verzeichnisse im Dateisystem überwachen * ..................................................... 420

5.4 Wahlfreier Zugriff mit SeekableByteChannel und ByteBuffer * ..................................... 422

5.4.1 SeekableByteChannel ................................................................................................. 422

5.4.2 ByteBuffer ...................................................................................................................... 423

5.4.3 Beispiel mit Path + SeekableByteChannel + ByteBuffer .................................. 423

5.4.4 FileChannel .................................................................................................................... 424

5.5 Zum Weiterlesen .......................................................................................................................... 426

6 Datenströme

6.1 Stream-Klassen und Reader/Writer am Beispiel von Dateien ......................................... 427

6.1.1 Mit dem FileWriter Texte in Dateien schreiben ................................................. 428

6.1.2 Zeichen mit der Klasse FileReader lesen .............................................................. 430

6.1.3 Kopieren mit FileOutputStream und FileInputStream ................................... 431

6.1.4 Das FileDescriptor-Objekt * ...................................................................................... 435

6.1.5 Datenströme über Files mit NIO.2 beziehen ....................................................... 436

6.2 Basisklassen für die Ein-/Ausgabe ........................................................................................... 438

6.2.1 Die abstrakten Basisklassen ..................................................................................... 438

6.2.2 Übersicht über Ein-/Ausgabeklassen .................................................................... 439


Inhalt

13

6.2.3 Die abstrakte Basisklasse OutputStream .............................................................. 441

6.2.4 Die Schnittstellen Closeable, AutoCloseable und Flushable ........................... 443

6.2.5 Ein Datenschlucker * ................................................................................................... 444

6.2.6 Die abstrakte Basisklasse InputStream ................................................................. 445

6.2.7 Ressourcen aus dem Klassenpfad und aus Jar-Archiven laden ..................... 446

6.2.8 Ströme mit SequenceInputStream zusammensetzen * ................................... 447

6.2.9 Die abstrakte Basisklasse Writer .............................................................................. 449

6.2.10 Die Schnittstelle Appendable * ................................................................................. 451

6.2.11 Die abstrakte Basisklasse Reader ............................................................................. 451

6.3 Formatierte Textausgaben ......................................................................................................... 454

6.3.1 Die Klassen PrintWriter und PrintStream ............................................................ 455

6.3.2 System.out, System.err und System.in .................................................................. 460

6.4 Schreiben und Lesen aus Strings und Byte-Feldern ............................................................. 462

6.4.1 Mit dem StringWriter ein String-Objekt füllen ................................................... 463

6.4.2 CharArrayWriter ........................................................................................................... 464

6.4.3 StringReader und CharArrayReader ....................................................................... 465

6.4.4 Mit ByteArrayOutputStream in ein Byte-Feld schreiben ................................ 467

6.4.5 Mit ByteArrayInputStream aus einem Byte-Feld lesen .................................... 467

6.5 Datenströme filtern und verketten ......................................................................................... 468

6.5.1 Streams als Filter verketten (verschachteln) ....................................................... 469

6.5.2 Gepufferte Ausgaben mit BufferedWriter und BufferedOutputStream ..... 469

6.5.3 Gepufferte Eingaben mit BufferedReader/BufferedInputStream ................ 471

6.5.4 LineNumberReader zählt automatisch Zeilen mit * .......................................... 474

6.5.5 Daten mit der Klasse PushbackReader zurücklegen * ....................................... 474

6.5.6 DataOutputStream/DataInputStream * ................................................................ 478

6.5.7 Basisklassen für Filter * ............................................................................................... 478

6.5.8 Die Basisklasse FilterWriter * .................................................................................... 479

6.5.9 Ein LowerCaseWriter * ................................................................................................ 480

6.5.10 Eingaben mit der Klasse FilterReader filtern * .................................................... 482

6.5.11 Anwendungen für FilterReader und FilterWriter * ............................................ 483

6.6 Vermittler zwischen Byte-Streams und Unicode-Strömen ............................................... 491

6.6.1 Datenkonvertierung durch den OutputStreamWriter ..................................... 491

6.6.2 Automatische Konvertierungen mit dem InputStreamReader .................... 492

6.7 Kommunikation zwischen Threads mit Pipes * .................................................................... 493

6.7.1 PipedOutputStream und PipedInputStream ....................................................... 494

6.7.2 PipedWriter und PipedReader .................................................................................. 496


Inhalt

14

6.8 Prüfsummen ................................................................................................................................... 498

6.8.1 Die Schnittstelle Checksum ...................................................................................... 498

6.8.2 Die Klasse CRC32 .......................................................................................................... 499

6.8.3 Die Adler32-Klasse ....................................................................................................... 501

6.9 Persistente Objekte und Serialisierung .................................................................................. 502

6.9.1 Objekte mit der Standard-Serialisierung speichern und lesen ..................... 503

6.9.2 Zwei einfache Anwendungen der Serialisierung * ............................................ 506

6.9.3 Die Schnittstelle Serializable .................................................................................... 507

6.9.4 Nicht serialisierbare Attribute aussparen ............................................................ 509

6.9.5 Das Abspeichern selbst in die Hand nehmen ..................................................... 511

6.9.6 Tiefe Objektkopien * ................................................................................................... 515

6.9.7 Versionenverwaltung und die SUID ...................................................................... 517

6.9.8 Wie die ArrayList serialisiert * ................................................................................. 519

6.9.9 Probleme mit der Serialisierung ............................................................................. 520

6.10 Alternative Datenaustauschformate ...................................................................................... 522

6.10.1 Serialisieren in XML-Dateien ................................................................................... 522

6.10.2 XML-Serialisierung von JavaBeans mit JavaBeans Persistence * .................. 522

6.10.3 Die Open-Source-Bibliothek XStream * ................................................................ 525

6.10.4 Binäre Serialisierung mit Google Protocol Buffers * ........................................ 526

6.11 Tokenizer * ...................................................................................................................................... 526

6.11.1 StreamTokenizer .......................................................................................................... 526

6.12 Zum Weiterlesen .......................................................................................................................... 529

7 Die eXtensible Markup Language (XML)

7.1 Auszeichnungssprachen ............................................................................................................. 531

7.1.1 Die Standard Generalized Markup Language (SGML) ...................................... 532

7.1.2 Extensible Markup Language (XML) ...................................................................... 532

7.2 Eigenschaften von XML-Dokumenten .................................................................................... 533

7.2.1 Elemente und Attribute ............................................................................................. 533

7.2.2 Beschreibungssprache für den Aufbau von XML-Dokumenten ................... 535

7.2.3 Schema – eine Alternative zu DTD ......................................................................... 539

7.2.4 Namensraum (Namespace) ...................................................................................... 542

7.2.5 XML-Applikationen * .................................................................................................. 543


Inhalt

15

7.3 Die Java-APIs für XML .................................................................................................................. 544

7.3.1 Das Document Object Model (DOM) ...................................................................... 545

7.3.2 Simple API for XML Parsing (SAX) ........................................................................... 545

7.3.3 Pull-API StAX ................................................................................................................. 545

7.3.4 Java Document Object Model (JDOM) .................................................................... 545

7.3.5 JAXP als Java-Schnittstelle zu XML ......................................................................... 546

7.3.6 DOM-Bäume einlesen mit JAXP * ............................................................................ 547

7.4 Java Architecture for XML Binding (JAXB) .............................................................................. 548

7.4.1 Bean für JAXB aufbauen ............................................................................................. 548

7.4.2 JAXBContext und die Marshaller ............................................................................ 549

7.4.3 Ganze Objektgraphen schreiben und lesen ......................................................... 550

7.4.4 Validierung ..................................................................................................................... 553

7.4.5 Weitere JAXB-Annotationen * .................................................................................. 557

7.4.6 Beans aus XML-Schema-Datei generieren ............................................................ 565

7.5 Serielle Verarbeitung mit StAX ................................................................................................. 570

7.5.1 Unterschiede der Verarbeitungsmodelle ............................................................. 571

7.5.2 XML-Dateien mit dem Cursor-Verfahren lesen .................................................. 572

7.5.3 XML-Dateien mit dem Iterator-Verfahren verarbeiten * ................................. 576

7.5.4 Mit Filtern arbeiten * ................................................................................................... 578

7.5.5 XML-Dokumente schreiben ...................................................................................... 579

7.6 Serielle Verarbeitung von XML mit SAX * .............................................................................. 582

7.6.1 Schnittstellen von SAX ............................................................................................... 583

7.6.2 SAX-Parser erzeugen ................................................................................................... 584

7.6.3 Operationen der Schnittstelle ContentHandler ................................................. 584

7.6.4 ErrorHandler und EntityResolver ........................................................................... 587

7.7 XML-Dateien mit JDOM verarbeiten ....................................................................................... 588

7.7.1 JDOM beziehen .............................................................................................................. 588

7.7.2 Paketübersicht * ............................................................................................................ 588

7.7.3 Die Document-Klasse .................................................................................................. 590

7.7.4 Eingaben aus der Datei lesen .................................................................................... 591

7.7.5 Das Dokument im XML-Format ausgeben ........................................................... 592

7.7.6 Der Dokumenttyp * ...................................................................................................... 593

7.7.7 Elemente ......................................................................................................................... 594

7.7.8 Zugriff auf Elementinhalte ........................................................................................ 597

7.7.9 Liste mit Unterelementen erzeugen * .................................................................... 599

7.7.10 Neue Elemente einfügen und ändern .................................................................... 600


Inhalt

16

7.7.11 Attributinhalte lesen und ändern .......................................................................... 603

7.7.12 XPath ............................................................................................................................... 606

7.8 Transformationen mit XSLT * .................................................................................................... 610

7.8.1 Templates und XPath als Kernelemente von XSLT ........................................... 610

7.8.2 Umwandlung von XML-Dateien mit JDOM und JAXP ..................................... 613

7.9 XML-Schema-Validierung * ........................................................................................................ 614

7.9.1 SchemaFactory und Schema .................................................................................... 614

7.9.2 Validator ......................................................................................................................... 614

7.9.3 Validierung unterschiedlicher Datenquellen durchführen ........................... 615

7.10 Zum Weiterlesen .......................................................................................................................... 615

8 Dateiformate

8.1 Einfache Dateiformate für strukturierte Daten ................................................................... 618

8.1.1 Property-Dateien ......................................................................................................... 618

8.1.2 CSV-Dateien ................................................................................................................... 618

8.1.3 JSON-Serialisierung mit Jackson ............................................................................. 619

8.2 Dokumentenformate ................................................................................................................... 620

8.2.1 (X)HTML .......................................................................................................................... 620

8.2.2 PDF-Dokumente ........................................................................................................... 622

8.2.3 Microsoft Office-Dokumente ................................................................................... 622

8.2.4 OASIS Open Document Format ............................................................................... 624

8.3 Datenkompression * .................................................................................................................... 624

8.3.1 Java-Unterstützung beim Komprimieren ............................................................ 625

8.3.2 Daten packen und entpacken .................................................................................. 626

8.3.3 Datenströme komprimieren .................................................................................... 627

8.3.4 Zip-Archive .................................................................................................................... 632

8.3.5 Jar-Archive ..................................................................................................................... 640

8.4 Bild-Formate .................................................................................................................................. 640

8.5 Audio-Dateien ............................................................................................................................... 640

8.5.1 Die Arbeit mit AudioClip ........................................................................................... 640

8.5.2 MIDI-Dateien abspielen ............................................................................................. 641


Inhalt

17

9 Grafische Oberflächen mit Swing

9.1 Fenster zur Welt ............................................................................................................................ 645

9.1.1 Swing-Fenster mit javax.swing.JFrame darstellen ............................................. 645

9.1.2 Fenster schließbar machen – setDefaultCloseOperation() .............................. 647

9.1.3 Sichtbarkeit des Fensters ........................................................................................... 648

9.1.4 Größe und Position des Fensters verändern ....................................................... 648

9.1.5 Fenster- und Dialog-Dekoration, Transparenz * ................................................. 649

9.1.6 Die Klasse Toolkit * ...................................................................................................... 650

9.1.7 Dynamisches Layout während einer Größenänderung * ................................ 651

9.1.8 Zum Vergleich: AWT-Fenster darstellen * ............................................................. 651

9.2 Beschriftungen (JLabel) ............................................................................................................... 653

9.2.1 Mehrzeiliger Text, HTML in der Darstellung ....................................................... 656

9.3 Icon und ImageIcon für Bilder auf Swing-Komponenten .................................................. 657

9.3.1 Die Klasse ImageIcon .................................................................................................. 657

9.3.2 Die Schnittstelle Icon und eigene Icons zeichnen * ........................................... 659

9.4 Es tut sich was – Ereignisse beim AWT ................................................................................... 661

9.4.1 Die Ereignisquellen und Horcher (Listener) von Swing ................................... 662

9.4.2 Listener implementieren ........................................................................................... 663

9.4.3 Listener bei dem Ereignisauslöser anmelden/abmelden ................................ 666

9.4.4 Adapterklassen nutzen ............................................................................................... 668

9.4.5 Innere Mitgliedsklassen und innere anonyme Klassen ................................... 670

9.4.6 Aufrufen der Listener im AWT-Event-Thread ..................................................... 672

9.4.7 Ereignisse, etwas genauer betrachtet * .................................................................. 673

9.5 Schaltflächen .................................................................................................................................. 676

9.5.1 Normale Schaltflächen (JButton) ............................................................................. 676

9.5.2 Der aufmerksame ActionListener ........................................................................... 678

9.5.3 Schaltflächen-Ereignisse vom Typ ActionEvent ................................................. 679

9.5.4 Basisklasse AbstractButton ....................................................................................... 680

9.5.5 Wechselknopf (JToggleButton) ................................................................................ 682

9.6 Textkomponenten ........................................................................................................................ 683

9.6.1 Text in einer Eingabezeile ......................................................................................... 684

9.6.2 Die Oberklasse der Text-Komponenten (JTextComponent) .......................... 685

9.6.3 Geschützte Eingaben (JPasswordField) .................................................................. 686

9.6.4 Validierende Eingabefelder (JFormattedTextField) ........................................... 687

9.6.5 Einfache mehrzeilige Textfelder (JTextArea) ....................................................... 688

9.6.6 Editor-Klasse (JEditorPane) * ..................................................................................... 692


Inhalt

18

9.7 Swing Action * ............................................................................................................................... 694

9.8 JComponent und Component als Basis aller Komponenten ............................................ 697

9.8.1 Hinzufügen von Komponenten .............................................................................. 697

9.8.2 Tooltips (Kurzhinweise) ............................................................................................. 698

9.8.3 Rahmen (Border) * ....................................................................................................... 699

9.8.4 Fokus und Navigation * .............................................................................................. 701

9.8.5 Ereignisse jeder Komponente * ............................................................................... 702

9.8.6 Die Größe und Position einer Komponente * ..................................................... 706

9.8.7 Komponenten-Ereignisse * ....................................................................................... 707

9.8.8 UI-Delegate – der wahre Zeichner * ........................................................................ 708

9.8.9 Undurchsichtige (opake) Komponente * .............................................................. 711

9.8.10 Properties und Listener für Änderungen * .......................................................... 711

9.9 Container ........................................................................................................................................ 711

9.9.1 Standardcontainer (JPanel) ....................................................................................... 712

9.9.2 Bereich mit automatischen Rollbalken (JScrollPane) ....................................... 713

9.9.3 Reiter (JTabbedPane) ................................................................................................... 714

9.9.4 Teilungskomponente (JSplitPane) .......................................................................... 715

9.10 Alles Auslegungssache: die Layoutmanager ........................................................................ 716

9.10.1 Übersicht über Layoutmanager .............................................................................. 717

9.10.2 Zuweisen eines Layoutmanagers ........................................................................... 717

9.10.3 Im Fluss mit FlowLayout ........................................................................................... 718

9.10.4 BoxLayout ...................................................................................................................... 720

9.10.5 Mit BorderLayout in alle Himmelsrichtungen ................................................... 721

9.10.6 Rasteranordnung mit GridLayout .......................................................................... 724

9.10.7 Der GridBagLayoutmanager * .................................................................................. 725

9.10.8 Null-Layout * ................................................................................................................. 731

9.10.9 Weitere Layoutmanager ............................................................................................ 732

9.11 Rollbalken und Schieberegler ................................................................................................... 733

9.11.1 Schieberegler (JSlider) ................................................................................................ 733

9.11.2 Rollbalken (JScrollBar) * ............................................................................................. 734

9.12 Kontrollfelder, Optionsfelder, Kontrollfeldgruppen .......................................................... 739

9.12.1 Kontrollfelder (JCheckBox) ....................................................................................... 740

9.12.2 ItemSelectable, ItemListener und das ItemEvent ............................................. 741

9.12.3 Sich gegenseitig ausschließende Optionen (JRadioButton) ........................... 743

9.13 Fortschritte bei Operationen überwachen * ......................................................................... 745

9.13.1 Fortschrittsbalken (JProgressBar) ........................................................................... 745

9.13.2 Dialog mit Fortschrittsanzeige (ProgressMonitor) ........................................... 748


Inhalt

19

9.14 Menüs und Symbolleisten .......................................................................................................... 748

9.14.1 Die Menüleisten und die Einträge .......................................................................... 748

9.14.2 Menüeinträge definieren ........................................................................................... 750

9.14.3 Einträge durch Action-Objekte beschreiben ........................................................ 751

9.14.4 Mit der Tastatur: Mnemonics und Shortcut ........................................................ 752

9.14.5 Der Tastatur-Shortcut (Accelerator) ....................................................................... 753

9.14.6 Tastenkürzel (Mnemonics) ........................................................................................ 755

9.14.7 Symbolleisten alias Toolbars .................................................................................... 756

9.14.8 Popup-Menüs ................................................................................................................ 759

9.14.9 System-Tray nutzen * .................................................................................................. 764

9.15 Das Model-View-Controller-Konzept ...................................................................................... 765

9.16 Auswahlmenüs, Listen und Spinner ......................................................................................... 767

9.16.1 Listen (JList) .................................................................................................................... 767

9.16.2 Auswahlmenü (JComboBox) ..................................................................................... 775

9.16.3 Drehfeld (JSpinner) * .................................................................................................... 787

9.16.4 Datumsauswahl * .......................................................................................................... 789

9.17 Tabellen (JTable) ............................................................................................................................ 789

9.17.1 Ein eigenes Tabellen-Model ...................................................................................... 791

9.17.2 Basisklasse für eigene Modelle (AbstractTableModel) ..................................... 792

9.17.3 Ein vorgefertigtes Standard-Modell (DefaultTableModel) .............................. 796

9.17.4 Ein eigener Renderer für Tabellen .......................................................................... 798

9.17.5 Zell-Editoren .................................................................................................................. 801

9.17.6 Größe und Umrandung der Zellen * ....................................................................... 803

9.17.7 Spalteninformationen * ............................................................................................. 803

9.17.8 Tabellenkopf von Swing-Tabellen * ........................................................................ 804

9.17.9 Selektionen einer Tabelle * ........................................................................................ 805

9.17.10 Automatisches Sortieren und Filtern mit RowSorter * .................................... 806

9.18 Bäume (JTree) ................................................................................................................................. 809

9.18.1 JTree und sein TreeModel und TreeNode ............................................................. 809

9.18.2 Selektionen bemerken ................................................................................................ 811

9.18.3 Das TreeModel von JTree * ......................................................................................... 811

9.19 JRootPane und JDesktopPane * ................................................................................................. 815

9.19.1 Wurzelkomponente der Top-Level-Komponenten (JRootPane) ................... 815

9.19.2 JDesktopPane und die Kinder von JInternalFrame ........................................... 815

9.19.3 JLayeredPane ................................................................................................................. 817

9.20 Dialoge und Window-Objekte ................................................................................................... 818

9.20.1 JWindow und JDialog .................................................................................................. 818


Inhalt

20

9.20.2 Modal oder nicht-modal? .......................................................................................... 819

9.20.3 Standarddialoge mit JOptionPane ......................................................................... 820

9.20.4 Der Dateiauswahldialog ............................................................................................ 823

9.20.5 Der Farbauswahldialog JColorChooser * ............................................................... 827

9.21 Flexibles Java-Look-and-Feel .................................................................................................... 830

9.21.1 Look and Feel global setzen ...................................................................................... 830

9.21.2 UIManager ..................................................................................................................... 830

9.21.3 Die Windows-Optik mit JGoodies Looks verbessern * ..................................... 833

9.22 Swing-Komponenten neu erstellen oder verändern * ....................................................... 833

9.22.1 Überlagerungen mit dem Swing-Komponenten-Dekorator JLayer ............ 834

9.23 Die Zwischenablage (Clipboard) ............................................................................................... 836

9.23.1 Clipboard-Objekte ....................................................................................................... 836

9.23.2 Mit Transferable auf den Inhalt zugreifen ........................................................... 837

9.23.3 DataFlavor ist das Format der Daten in der Zwischenablage ........................ 838

9.23.4 Einfügungen in der Zwischenablage erkennen .................................................. 840

9.23.5 Drag & Drop ................................................................................................................... 841

9.24 Undo durchführen * ..................................................................................................................... 842

9.25 AWT, Swing und die Threads ..................................................................................................... 844

9.25.1 Ereignisschlange (EventQueue) und AWT-Event-Thread ................................ 844

9.25.2 Swing ist nicht thread-sicher ................................................................................... 845

9.25.3 invokeLater() und invokeAndWait() ...................................................................... 848

9.25.4 SwingWorker ................................................................................................................. 851

9.25.5 Eigene Ereignisse in die Queue setzen * ............................................................... 853

9.25.6 Auf alle Ereignisse hören * ........................................................................................ 854

9.26 Barrierefreiheit mit der Java Accessibility API ..................................................................... 854

9.27 Zeitliches Ausführen mit dem javax.swing.Timer .............................................................. 855

9.28 Die Zusatzkomponentenbibliothek SwingX ......................................................................... 856

9.28.1 Im Angebot: Erweiterte und neue Swing-Komponenten ............................... 857

9.28.2 Überblick über erweiterte Standard-Swing-Klassen ......................................... 857

9.28.3 Neue Swing-Klassen .................................................................................................... 858

9.28.4 Weitere SwingX-Klassen ............................................................................................ 859

9.28.5 SwingX-Installation .................................................................................................... 860

9.29 Alternativen zu programmierten Oberflächen, AWT und Swing * ................................. 860

9.29.1 Deklarative Beschreibungen der Oberfläche: Swing JavaBuilder, Swixml 860

9.29.2 SWT (Standard Widget Toolkit) ............................................................................... 862

9.30 Zum Weiterlesen .......................................................................................................................... 864


Inhalt

21

10 Grafikprogrammierung

10.1 Grundlegendes zum Zeichnen ................................................................................................. 865

10.1.1 Die paint()-Methode für das AWT-Frame ............................................................ 865

10.1.2 Zeichnen von Inhalten auf ein JFrame ................................................................ 867

10.1.3 Auffordern zum Neuzeichnen mit repaint() ...................................................... 869

10.1.4 Java 2D-API ................................................................................................................... 869

10.2 Einfache Zeichenmethoden ...................................................................................................... 870

10.2.1 Linien ............................................................................................................................. 870

10.2.2 Rechtecke ...................................................................................................................... 871

10.2.3 Ovale und Kreisbögen ............................................................................................... 872

10.2.4 Polygone und Polylines ............................................................................................ 874

10.3 Zeichenketten schreiben und Fonts ....................................................................................... 876

10.3.1 Zeichenfolgen schreiben .......................................................................................... 877

10.3.2 Die Font-Klasse ........................................................................................................... 878

10.3.3 Einen neuen Font aus einem gegebenen Font ableiten ................................. 880

10.3.4 Zeichensätze des Systems ermitteln * ................................................................. 880

10.3.5 Neue TrueType-Fonts in Java nutzen ................................................................... 881

10.3.6 Font-Metadaten durch FontMetrics * .................................................................. 882

10.4 Geometrische Objekte ............................................................................................................... 886

10.4.1 Die Schnittstelle Shape ............................................................................................. 888

10.4.2 Kreisförmiges .............................................................................................................. 889

10.4.3 Kurviges * ...................................................................................................................... 890

10.4.4 Area und die konstruktive Flächengeometrie * ................................................ 890

10.4.5 Pfade * ............................................................................................................................ 891

10.4.6 Punkt in einer Form, Schnitt von Linien, Abstand Punkt/Linie * ............... 895

10.5 Das Innere und Äußere einer Form ........................................................................................ 896

10.5.1 Farben und die Paint-Schnittstelle ....................................................................... 896

10.5.2 Farben mit der Klasse Color .................................................................................... 897

10.5.3 Die Farben des Systems über SystemColor * ..................................................... 903

10.5.4 Composite und Xor * ................................................................................................. 907

10.5.5 Dicke und Art der Linien von Formen bestimmen über Stroke * ............... 908

10.6 Bilder ............................................................................................................................................... 913

10.6.1 Eine Übersicht über die Bilder-Bibliotheken ..................................................... 914

10.6.2 Bilder mit ImageIO lesen ......................................................................................... 915

10.6.3 Ein Bild zeichnen ........................................................................................................ 917

10.6.4 Programm-Icon/Fenster-Icon setzen ................................................................... 921


Inhalt

22

10.6.5 Splash-Screen * ........................................................................................................... 922

10.6.6 Bilder im Speicher erzeugen * ................................................................................ 922

10.6.7 Pixel für Pixel auslesen und schreiben * ............................................................ 925

10.6.8 Bilder skalieren * ........................................................................................................ 927

10.6.9 Schreiben mit ImageIO ............................................................................................ 929

10.6.10 Asynchrones Laden mit getImage() und dem MediaTracker * .................... 934

10.7 Weitere Eigenschaften von Graphics * ................................................................................. 935

10.7.1 Eine Kopie von Graphics erstellen ....................................................................... 935

10.7.2 Koordinatensystem verschieben ......................................................................... 936

10.7.3 Beschnitt (Clipping) .................................................................................................. 937

10.7.4 Zeichenhinweise durch RenderingHints ........................................................... 941

10.7.5 Transformationen mit einem AffineTransform-Objekt ............................... 941

10.8 Drucken * ....................................................................................................................................... 944

10.8.1 Drucken der Inhalte .................................................................................................. 944

10.8.2 Bekannte Drucker ...................................................................................................... 946

10.9 Benutzerinteraktionen automatisieren, Robot und Screenshots * .............................. 947

10.9.1 Der Roboter ................................................................................................................. 947

10.9.2 Automatisch in die Tasten hauen ........................................................................ 948

10.9.3 Automatisierte Mausoperationen ....................................................................... 949

10.9.4 Methoden zur Zeitsteuerung ................................................................................. 949

10.9.5 Bildschirmabzüge (Screenshots) ........................................................................... 950

10.9.6 Funktionsweise und Beschränkungen ................................................................ 952

10.9.7 MouseInfo und PointerInfo ................................................................................... 952

10.10 Zum Weiterlesen ........................................................................................................................ 953

11 Netzwerkprogrammierung

11.1 Grundlegende Begriffe ............................................................................................................. 955

11.2 URI und URL .................................................................................................................................. 957

11.2.1 Die Klasse URI ............................................................................................................. 957

11.2.2 Die Klasse URL ............................................................................................................ 958

11.2.3 Informationen über eine URL * ............................................................................. 961

11.2.4 Der Zugriff auf die Daten über die Klasse URL ................................................. 963

11.3 Die Klasse URLConnection * ..................................................................................................... 965

11.3.1 Methoden und Anwendung von URLConnection ........................................... 965

11.3.2 Protokoll- und Content-Handler .......................................................................... 967


Inhalt

23

11.3.3 Im Detail: vom URL zur URLConnection ............................................................ 968

11.3.4 Der Protokoll-Handler für Jar-Dateien ................................................................ 969

11.3.5 Basic Authentication und Proxy-Authentifizierung ....................................... 971

11.4 Mit GET und POST Daten übergeben * .................................................................................. 973

11.4.1 Kodieren der Parameter für Serverprogramme ............................................... 974

11.4.2 Eine Suchmaschine mit GET-Request ansprechen .......................................... 975

11.4.3 POST-Request absenden ........................................................................................... 976

11.5 Host- und IP-Adressen ............................................................................................................... 977

11.5.1 Lebt der Rechner? ....................................................................................................... 980

11.5.2 IP-Adresse des lokalen Hosts .................................................................................. 980

11.5.3 Das Netz ist klasse ...................................................................................................... 981

11.5.4 NetworkInterface ....................................................................................................... 981

11.6 Mit dem Socket zum Server ...................................................................................................... 983

11.6.1 Das Netzwerk ist der Computer ............................................................................. 983

11.6.2 Sockets ........................................................................................................................... 983

11.6.3 Eine Verbindung zum Server aufbauen .............................................................. 984

11.6.4 Server unter Spannung: die Ströme ..................................................................... 985

11.6.5 Die Verbindung wieder abbauen ........................................................................... 986

11.6.6 Informationen über den Socket * .......................................................................... 986

11.6.7 Reine Verbindungsdaten über SocketAddress * ............................................... 988

11.7 Client-Server-Kommunikation ................................................................................................ 989

11.7.1 Warten auf Verbindungen ....................................................................................... 990

11.7.2 Ein Multiplikationsserver ........................................................................................ 991

11.7.3 Blockierendes Lesen .................................................................................................. 995

11.7.4 Von außen erreichbar sein * ................................................................................... 996

11.8 Apache HttpComponents und Commons Net * .................................................................. 997

11.8.1 HttpComponents ....................................................................................................... 997

11.8.2 Apache Commons Net .............................................................................................. 998

11.9 Arbeitsweise eines Webservers * ............................................................................................ 998

11.9.1 Das Hypertext Transfer Protocol (HTTP) ............................................................ 998

11.9.2 Anfragen an den Server ............................................................................................ 999

11.9.3 Die Antworten vom Server ...................................................................................... 1002

11.9.4 Webserver mit com.sun.net.httpserver.HttpServer ........................................ 1006

11.10 Verbindungen durch einen Proxy-Server * .......................................................................... 1007

11.10.1 System-Properties ...................................................................................................... 1008

11.10.2 Verbindungen durch die Proxy-API ..................................................................... 1008


Inhalt

24

11.11 Datagram-Sockets * ................................................................................................................... 1010

11.11.1 Die Klasse DatagramSocket .................................................................................... 1012

11.11.2 Datagramme und die Klasse DatagramPacket ................................................. 1013

11.11.3 Auf ein hereinkommendes Paket warten .......................................................... 1014

11.11.4 Ein Paket zum Senden vorbereiten ...................................................................... 1015

11.11.5 Methoden der Klasse DatagramPacket ............................................................... 1016

11.11.6 Das Paket senden ....................................................................................................... 1017

11.12 E-Mail * .......................................................................................................................................... 1019

11.12.1 Wie eine E-Mail um die Welt geht ........................................................................ 1019

11.12.2 Das Simple Mail Transfer Protocol und RFC 822 ............................................. 1019

11.12.3 POP (Post Office Protocol) ....................................................................................... 1020

11.12.4 Die JavaMail API ......................................................................................................... 1020

11.12.5 E-Mails mittels POP3 abrufen ................................................................................ 1023

11.12.6 Multipart-Nachrichten verarbeiten ..................................................................... 1025

11.12.7 E-Mails versenden ..................................................................................................... 1027

11.12.8 Ereignisse und Suchen ............................................................................................. 1030

11.13 Tiefer liegende Netzwerkeigenschaften * ........................................................................... 1031

11.13.1 Internet Control Message Protocol (ICMP) ........................................................ 1031

11.13.2 MAC-Adresse ............................................................................................................... 1032

11.14 Zum Weiterlesen ........................................................................................................................ 1033

12 Verteilte Programmierung mit RMI

12.1 Entfernte Objekte und Methoden ......................................................................................... 1035

12.1.1 Stellvertreter helfen bei entfernten Methodenaufrufen .............................. 1035

12.1.2 Standards für entfernte Objekte ........................................................................... 1037

12.2 Java Remote Method Invocation ........................................................................................... 1038

12.2.1 Zusammenspiel von Server, Registry und Client ............................................ 1038

12.2.2 Wie die Stellvertreter die Daten übertragen ..................................................... 1038

12.2.3 Probleme mit entfernten Methoden ................................................................... 1039

12.2.4 Nutzen von RMI bei Middleware-Lösungen ...................................................... 1040

12.2.5 Zentrale Klassen und Schnittstellen .................................................................... 1041

12.2.6 Entfernte und lokale Objekte im Vergleich ....................................................... 1042

12.3 Auf der Serverseite ..................................................................................................................... 1042

12.3.1 Entfernte Schnittstelle deklarieren ...................................................................... 1042

12.3.2 Remote-Objekt-Implementierung ....................................................................... 1043


Inhalt

25

12.3.3 Stellvertreterobjekte ................................................................................................. 1044

12.3.4 Der Namensdienst (Registry) .................................................................................. 1045

12.3.5 Remote-Objekt-Implementierung exportieren und beim

Namensdienst anmelden ........................................................................................ 1047

12.3.6 Einfaches Logging ...................................................................................................... 1049

12.3.7 Aufräumen mit dem DGC * ..................................................................................... 1050

12.4 Auf der Clientseite ...................................................................................................................... 1051

12.5 Entfernte Objekte übergeben und laden ............................................................................. 1052

12.5.1 Klassen vom RMI-Klassenlader nachladen ........................................................ 1052

12.6 Weitere Eigenschaften von RMI .............................................................................................. 1053

12.6.1 RMI und CORBA .......................................................................................................... 1053

12.6.2 RMI über HTTP getunnelt ........................................................................................ 1054

12.6.3 Automatische Remote-Objekt-Aktivierung ....................................................... 1054

12.7 Java Message Service (JMS) ...................................................................................................... 1055

12.8 Zum Weiterlesen ......................................................................................................................... 1055

13 RESTful und SOAP Web-Services

13.1 Web-Services ................................................................................................................................ 1057

13.2 RESTful Web-Services ................................................................................................................. 1059

13.2.1 Aus Prinzip REST ......................................................................................................... 1059

13.2.2 Jersey .............................................................................................................................. 1060

13.2.3 JAX-RS-Annotationen für den ersten REST-Service ......................................... 1061

13.2.4 Test-Server starten ..................................................................................................... 1062

13.2.5 REST-Services konsumieren .................................................................................... 1063

13.2.6 Content-Hander, Marshaller und verschiedene MIME-Typen ..................... 1064

13.2.7 REST-Parameter .......................................................................................................... 1067

13.2.8 REST-Services mit Parametern über die Jersey-Client-API aufrufen .......... 1069

13.2.9 PUT-Anforderungen und das Senden von Daten ............................................. 1070

13.2.10 PUT/POST/DELETE-Sendungen mit der Jersey-Client-API absetzen .......... 1071

13.3 Daily Soap und das SOAP-Protokoll ....................................................................................... 1071

13.3.1 Die technische Realisierung .................................................................................... 1072

13.3.2 Web-Service-APIs und Implementierungen ...................................................... 1072

13.3.3 @WebService in Java 6 ............................................................................................. 1073

13.3.4 Einen Web-Service definieren ................................................................................ 1074


Inhalt

26

13.3.5 Web-Services veröffentlichen ................................................................................ 1075

13.3.6 Einen JAX-WS-Client implementieren ................................................................ 1076

13.4 Zum Weiterlesen ........................................................................................................................ 1078

14 JavaServer Pages und Servlets

14.1 Dynamisch generierte Webseiten ......................................................................................... 1079

14.1.1 Was sind Servlets? ..................................................................................................... 1080

14.1.2 Was sind JavaServer Pages? .................................................................................... 1081

14.2 Servlets und JSPs mit Tomcat entwickeln ........................................................................... 1082

14.2.1 Servlet-Container ....................................................................................................... 1082

14.2.2 Entwicklung der Servlet/JSP-Spezifikationen ................................................... 1083

14.2.3 Webserver mit Servlet-Funktionalität ................................................................ 1083

14.2.4 Tomcat installieren ................................................................................................... 1084

14.2.5 Ablageort für eigene JSPs ........................................................................................ 1086

14.2.6 Webapplikationen ..................................................................................................... 1087

14.2.7 Zuordnung von Webapplikationen zu physikalischen Verzeichnissen ... 1088

14.2.8 Web-Projekt mit Eclipse IDE for Java EE Developers ...................................... 1088

14.3 Statisches und Dynamisches ................................................................................................... 1090

14.3.1 Statischer Template-Code ....................................................................................... 1090

14.3.2 Dynamische Inhalte .................................................................................................. 1090

14.3.3 Kommentare ............................................................................................................... 1091

14.4 Die Expression Language (EL) .................................................................................................. 1091

14.4.1 Operatoren der EL ...................................................................................................... 1092

14.4.2 Literale .......................................................................................................................... 1092

14.4.3 Implizite EL-Objekte ................................................................................................. 1093

14.5 Formulardaten ............................................................................................................................. 1094

14.5.1 Einen Parameter auslesen ...................................................................................... 1094

14.5.2 HTML-Formulare ....................................................................................................... 1095

14.6 Auf Beans zurückgreifen .......................................................................................................... 1096

14.6.1 Beans in JSPs anlegen ............................................................................................... 1097

14.6.2 Properties einer Bean im EL-Ausdruck erfragen .............................................. 1097

14.6.3 Properties mit <jsp:setProperty> setzen ............................................................ 1097

14.6.4 Bean-Klasse zum Testen von E-Mail-Adressen ................................................. 1098

14.6.5 Parameterwerte in Bean übertragen ................................................................... 1100


Inhalt

27

14.7 JSP-Tag-Libraries .......................................................................................................................... 1101

14.7.1 Standard Tag Library (JSTL) ..................................................................................... 1101

14.8 Skripting-Elemente in JSPs ....................................................................................................... 1105

14.8.1 Scriptlets ....................................................................................................................... 1106

14.8.2 JSP-Ausdrücke ............................................................................................................. 1106

14.8.3 JSP-Deklarationen ...................................................................................................... 1107

14.8.4 Quoting .......................................................................................................................... 1107

14.8.5 Entsprechende XML-Tags ........................................................................................ 1108

14.8.6 Implizite Objekte für Scriptlets und JSP-Ausdrücke ........................................ 1108

14.9 Sitzungsverfolgung (Session Tracking) ................................................................................. 1109

14.9.1 Lösungen für die Sitzungsverfolgung .................................................................. 1109

14.9.2 Sitzungen in JSPs ........................................................................................................ 1110

14.9.3 Auf Session-Dateien zurückgreifen ...................................................................... 1111

14.10 Servlets ........................................................................................................................................... 1111

14.10.1 Servlets compilieren ................................................................................................. 1115

14.10.2 Servlet-Mapping ......................................................................................................... 1116

14.10.3 Der Lebenszyklus eines Servlets ............................................................................ 1117

14.10.4 Mehrere Anfragen beim Servlet und die Thread-Sicherheit ......................... 1118

14.10.5 Servlets und Sessions ................................................................................................ 1118

14.10.6 Weiterleiten und Einbinden von Servlet-Inhalten .......................................... 1119

14.11 Zum Weiterlesen ......................................................................................................................... 1120

15 Applets

15.1 Applets in der Wiege von Java ................................................................................................ 1123

15.1.1 Applets heute ............................................................................................................... 1123

15.1.2 (J)Applet und Applikationen ................................................................................... 1124

15.1.3 Das erste Hallo-Applet .............................................................................................. 1125

15.2 Die Applet-API .............................................................................................................................. 1127

15.2.1 Die Zyklen eines Applets .......................................................................................... 1127

15.2.2 Parameter an das Applet übergeben .................................................................... 1127

15.2.3 Wie das Applet den Browser-Inhalt ändern kann * .......................................... 1129

15.2.4 Den Ursprung des Applets erfragen ..................................................................... 1130

15.2.5 Datenaustausch zwischen Applets * ..................................................................... 1131

15.2.6 Was ein Applet alles darf * ....................................................................................... 1134


Inhalt

28

15.2.7 Ist Java im Browser aktiviert? * .............................................................................. 1135

15.2.8 Applet unter Firefox (Netscape) oder Microsoft Internet Explorer? * ....... 1135

15.3 Webstart ....................................................................................................................................... 1137

15.4 Zum Weiterlesen ........................................................................................................................ 1137

16 Datenbankmanagement mit JDBC

16.1 Relationale Datenbanken ........................................................................................................ 1139

16.1.1 Das relationale Modell ............................................................................................. 1139

16.2 Datenbanken und Tools ............................................................................................................ 1140

16.2.1 HSQLDB ......................................................................................................................... 1141

16.2.2 Weitere Datenbanken * ............................................................................................ 1142

16.2.3 Eclipse-Plugins zum Durchschauen von Datenbanken ................................. 1145

16.3 JDBC und Datenbanktreiber .................................................................................................... 1148

16.3.1 Treibertypen * ............................................................................................................. 1149

16.3.2 JDBC-Versionen * ....................................................................................................... 1151

16.4 Eine Beispielabfrage .................................................................................................................. 1152

16.4.1 Schritte zur Datenbankabfrage ............................................................................. 1152

16.4.2 Ein Client für die HSQLDB-Datenbank ................................................................ 1153

16.4.3 Datenbankbrowser und eine Beispielabfrage unter NetBeans ................... 1155

16.5 Mit Java an eine Datenbank andocken ................................................................................ 1159

16.5.1 Der Treiber-Manager * .............................................................................................. 1160

16.5.2 Den Treiber laden ...................................................................................................... 1160

16.5.3 Eine Aufzählung aller Treiber * .............................................................................. 1162

16.5.4 Log-Informationen * ................................................................................................. 1162

16.5.5 Verbindung zur Datenbank auf- und abbauen ................................................ 1163

16.6 Datenbankabfragen ................................................................................................................... 1167

16.6.1 Abfragen über das Statement-Objekt .................................................................. 1168

16.6.2 Ergebnisse einer Abfrage in ResultSet ................................................................ 1169

16.6.3 Java und SQL-Datentypen ....................................................................................... 1170

16.6.4 Date, Time und Timestamp .................................................................................... 1173

16.6.5 Unicode in der Spalte korrekt auslesen .............................................................. 1175

16.6.6 Eine SQL-NULL und wasNull() bei ResultSet ...................................................... 1175

16.6.7 Wie viele Zeilen hat ein ResultSet? * .................................................................... 1176


Inhalt

29

16.7 Elemente einer Datenbank hinzufügen und aktualisieren ............................................. 1176

16.7.1 Batch-Updates ............................................................................................................. 1177

16.7.2 Die Ausnahmen bei JDBC, SQLException und Unterklassen ........................ 1179

16.8 ResultSet und RowSet * ............................................................................................................. 1182

16.8.1 Die Schnittstelle RowSet .......................................................................................... 1182

16.8.2 Implementierungen von RowSet .......................................................................... 1182

16.8.3 Der Typ CachedRowSet ............................................................................................. 1183

16.8.4 Der Typ WebRowSet .................................................................................................. 1184

16.9 Vorbereitete Anweisungen (Prepared Statements) .......................................................... 1187

16.9.1 PreparedStatement-Objekte vorbereiten ........................................................... 1187

16.9.2 Werte für die Platzhalter eines PreparedStatement ........................................ 1189

16.10 Transaktionen .............................................................................................................................. 1190

16.11 Metadaten * .................................................................................................................................. 1190

16.11.1 Metadaten über die Tabelle ..................................................................................... 1190

16.11.2 Informationen über die Datenbank ..................................................................... 1194

16.12 Vorbereitete Datenbankverbindungen ................................................................................ 1195

16.12.1 DataSource ................................................................................................................... 1195

16.12.2 Gepoolte Verbindungen ........................................................................................... 1198

16.13 JPA-Beispiel mit der NetBeans-IDE ......................................................................................... 1199

16.13.1 Entity-Beans generieren ........................................................................................... 1199

16.13.2 Die Quellen im Überblick ......................................................................................... 1201

16.13.3 Persistence Unit .......................................................................................................... 1203

16.13.4 Ein JPA-Beispielprogramm ...................................................................................... 1204

16.14 Zum Weiterlesen ......................................................................................................................... 1205

17 Technologien für die Infrastruktur

17.1 Property-Validierung durch Bean Validation ...................................................................... 1207

17.1.1 Technische Abhängigkeiten und POJOs .............................................................. 1218

17.2 Wie eine Implementierung an die richtige Stelle kommt ............................................... 1220

17.2.1 Arbeiten mit dem ServiceLoader ........................................................................... 1221

17.2.2 Die Utility-Klasse Lookup als ServiceLoader-Fassade ..................................... 1223

17.2.3 Contexts and Dependency Injection (CDI) aus dem JSR-299 ........................ 1224

17.3 Zum Weiterlesen ......................................................................................................................... 1226


Inhalt

30

18 Reflection und Annotationen

18.1 Metadaten .................................................................................................................................... 1227

18.1.1 Metadaten durch JavaDoc-Tags ............................................................................. 1227

18.2 Metadaten der Klassen mit dem Class-Objekt ................................................................... 1228

18.2.1 An ein Class-Objekt kommen ................................................................................ 1228

18.2.2 Was das Class-Objekt beschreibt * ........................................................................ 1231

18.2.3 Der Name der Klasse ................................................................................................. 1233

18.2.4 instanceof mit Class-Objekten * ............................................................................ 1235

18.2.5 Oberklassen finden * ................................................................................................. 1236

18.2.6 Implementierte Interfaces einer Klasse oder eines Interfaces * ................. 1237

18.2.7 Modifizierer und die Klasse Modifier * ............................................................... 1238

18.2.8 Die Arbeit auf dem Feld * ......................................................................................... 1240

18.3 Attribute, Methoden und Konstruktoren ............................................................................ 1241

18.3.1 Reflections – Gespür für die Attribute einer Klasse ........................................ 1243

18.3.2 Methoden einer Klasse erfragen ........................................................................... 1246

18.3.3 Properties einer Bean erfragen ............................................................................. 1250

18.3.4 Konstruktoren einer Klasse .................................................................................... 1250

18.3.5 Annotationen .............................................................................................................. 1253

18.4 Objekte erzeugen und manipulieren .................................................................................... 1253

18.4.1 Objekte erzeugen ....................................................................................................... 1253

18.4.2 Die Belegung der Variablen erfragen .................................................................. 1255

18.4.3 Eine generische eigene toString()-Methode * ................................................... 1257

18.4.4 Variablen setzen ......................................................................................................... 1260

18.4.5 Bean-Zustände kopieren * ....................................................................................... 1262

18.4.6 Private Attribute ändern ......................................................................................... 1262

18.4.7 Methoden aufrufen ................................................................................................... 1263

18.4.8 Statische Methoden aufrufen ................................................................................ 1265

18.4.9 Dynamische Methodenaufrufe bei festen Methoden beschleunigen * .... 1266

18.5 Eigene Annotationstypen * ...................................................................................................... 1268

18.5.1 Annotationen zum Laden von Ressourcen ....................................................... 1268

18.5.2 Neue Annotationen deklarieren ........................................................................... 1269

18.5.3 Annotationen mit genau einem Attribut .......................................................... 1270

18.5.4 Element-Werte-Paare (Attribute) hinzufügen .................................................. 1271

18.5.5 Annotationsattribute vom Typ einer Aufzählung .......................................... 1272


Inhalt

31

18.5.6 Felder von Annotationsattributen ....................................................................... 1273

18.5.7 Vorbelegte Attribute ................................................................................................. 1274

18.5.8 Annotieren von Annotationstypen ...................................................................... 1276

18.5.9 Deklarationen für unsere Ressourcen-Annotationen .................................... 1280

18.5.10 Annotierte Elemente auslesen ............................................................................... 1282

18.5.11 Auf die Annotationsattribute zugreifen ............................................................. 1283

18.5.12 Komplettbeispiel zum Initialisieren von Ressourcen .................................... 1284

18.5.13 Mögliche Nachteile von Annotationen ............................................................... 1287

18.6 Zum Weiterlesen ......................................................................................................................... 1288

19 Dynamische Übersetzung und Skriptsprachen

19.1 Codegenerierung ......................................................................................................................... 1290

19.1.1 Generierung von Java-Quellcode .......................................................................... 1291

19.1.2 Codetransformationen ............................................................................................. 1294

19.1.3 Erstellen von Java-Bytecode .................................................................................... 1294

19.2 Programme mit der Compiler API übersetzen .................................................................... 1295

19.2.1 Java Compiler API ....................................................................................................... 1295

19.2.2 Fehler-Diagnose .......................................................................................................... 1298

19.2.3 Eine im String angegebene Compiliationseinheit übersetzen .................... 1300

19.2.4 Wenn Quelle und Ziel der Speicher sind ............................................................. 1302

19.3 Ausführen von Skripten ............................................................................................................ 1306

19.3.1 JavaScript-Programme ausführen ........................................................................ 1306

19.3.2 Groovy ........................................................................................................................... 1308

19.4 Zum Weiterlesen ......................................................................................................................... 1314

20 Logging und Monitoring

20.1 Logging mit Java .......................................................................................................................... 1315

20.1.1 Logging-APIs ................................................................................................................ 1315

20.1.2 Logging mit java.util.logging .................................................................................. 1316

20.1.3 Logging mit log4j * ..................................................................................................... 1320

20.1.4 Die Simple Logging Facade ...................................................................................... 1323

20.2 Systemzustände überwachen .................................................................................................. 1324


Inhalt

32

20.3 MBean-Typen, MBean-Server und weitere Begriffe ......................................................... 1325

20.3.1 MXBeans des Systems .............................................................................................. 1325

20.4 Geschwätzige Programme und JConsole ............................................................................. 1328

20.4.1 JConsole ........................................................................................................................ 1328

20.5 Der MBeanServer ........................................................................................................................ 1330

20.6 Eine eigene Standard-MBean .................................................................................................. 1331

20.6.1 Management-Schnittstelle ..................................................................................... 1332

20.6.2 Implementierung der Managed-Ressource ....................................................... 1332

20.6.3 Anmeldung beim Server ......................................................................................... 1333

20.6.4 Eine eigene Bean in JConsole einbringen .......................................................... 1333

20.7 Zum Weiterlesen ........................................................................................................................ 1336

21 Java Native Interface (JNI)

21.1 Java Native Interface und Invocation-API ........................................................................... 1337

21.2 Eine C-Funktion in ein Java-Programm einbinden ............................................................ 1338

21.2.1 Den Java-Code schreiben ......................................................................................... 1338

21.3 Dynamische Bibliotheken erzeugen ..................................................................................... 1340

21.3.1 Die Header-Datei erzeugen ..................................................................................... 1340

21.3.2 Implementierung der Funktion in C ................................................................... 1342

21.3.3 Die C-Programme übersetzen und die dynamische Bibliothek

überzeugen .................................................................................................................. 1343

21.4 Nativ die Stringlänge ermitteln ............................................................................................. 1345

21.5 Erweiterte JNI-Eigenschaften .................................................................................................. 1347

21.5.1 Klassendefinitionen ................................................................................................. 1347

21.5.2 Zugriff auf Attribute ................................................................................................. 1348

21.5.3 Methoden aufrufen ................................................................................................... 1350

21.5.4 Threads und Synchronisation ............................................................................... 1352

21.6 Einfache Anbindung von existierenden Bibliotheken ..................................................... 1352

21.6.1 Generieren von JNI-Wrappern aus C++-Klassen und C-Headern ................ 1352

21.6.2 COM-Schnittstellen anzapfen ................................................................................ 1353

21.7 Invocation-API ............................................................................................................................. 1353

21.8 Zum Weiterlesen ........................................................................................................................ 1354


Inhalt

33

22 Sicherheitskonzepte

22.1 Zentrale Elemente der Java-Sicherheit ................................................................................. 1355

22.1.1 Security-API der Java SE ............................................................................................ 1355

22.1.2 Cryptographic Service Providers ........................................................................... 1356

22.2 Der Sandkasten (Sandbox) ....................................................................................................... 1357

22.3 Sicherheitsmanager (Security Manager) .............................................................................. 1358

22.3.1 Der Sicherheitsmanager bei Applets .................................................................... 1359

22.3.2 Sicherheitsmanager aktivieren .............................................................................. 1361

22.3.3 Rechte durch Policy-Dateien vergeben ............................................................... 1363

22.3.4 Erstellen von Rechtedateien mit dem grafischen Policy-Tool ..................... 1365

22.3.5 Kritik an den Policies ................................................................................................ 1366

22.4 Signierung ..................................................................................................................................... 1368

22.4.1 Warum signieren? ...................................................................................................... 1368

22.4.2 Digitale Ausweise und die Zertifizierungsstelle ............................................... 1368

22.4.3 Mit keytool Schlüssel erzeugen ............................................................................. 1369

22.4.4 Signieren mit jarsigner ............................................................................................. 1370

22.5 Digitale Unterschriften * ........................................................................................................... 1371

22.5.1 Die MDx-Reihe ............................................................................................................ 1371

22.5.2 Secure Hash Algorithm (SHA) ................................................................................ 1372

22.5.3 Mit der Security-API einen Fingerabdruck berechnen ................................... 1372

22.5.4 Die Klasse MessageDigest ........................................................................................ 1373

22.6 Verschlüsseln von Daten(-strömen) * .................................................................................... 1375

22.6.1 Den Schlüssel, bitte .................................................................................................... 1375

22.6.2 Verschlüsseln mit Cipher ......................................................................................... 1377

22.6.3 Verschlüsseln von Datenströmen ......................................................................... 1377

22.7 Zum Weiterlesen ......................................................................................................................... 1379

23 Dienstprogramme für die Java-Umgebung

23.1 Programme des JDK .................................................................................................................... 1381

23.2 Monitoringprogramme vom JDK ............................................................................................ 1381

23.2.1 jps .................................................................................................................................... 1381

23.2.2 jstat ................................................................................................................................. 1382

23.2.3 jmap ................................................................................................................................ 1382


Inhalt

34

23.2.4 jstack .............................................................................................................................. 1383

23.2.5 VisualVM ...................................................................................................................... 1385

23.3 Programmieren mit der Tools-API ......................................................................................... 1390

23.3.1 Eigene Doclets ............................................................................................................. 1390

23.4 Ant .................................................................................................................................................. 1393

23.4.1 Bezug und Installation von Ant ............................................................................ 1393

23.4.2 Das Build-Skript build.xml ..................................................................................... 1394

23.4.3 Build den Build ........................................................................................................... 1394

23.4.4 Properties ..................................................................................................................... 1395

23.4.5 Externe und vordefinierte Properties ................................................................. 1396

23.4.6 Weitere Ant-Tasks ...................................................................................................... 1397

23.5 Disassembler, Decompiler und Obfuscator ......................................................................... 1398

23.5.1 Der Diassembler javap ............................................................................................. 1399

23.5.2 Decompiler .................................................................................................................. 1404

23.5.3 Obfuscatoren ............................................................................................................... 1406

23.6 Weitere Dienstprogramme ...................................................................................................... 1408

23.6.1 Sourcecode Beautifier .............................................................................................. 1408

23.6.2 Java-Programme als Systemdienst ausführen ................................................. 1409

23.7 Zum Weiterlesen ........................................................................................................................ 1410

Index ............................................................................................................................................................ 1411


35

Vorwort

»Alles, was einen Anfang hat, hat auch ein Ende, und meistens hat das, was

ein Ende hat, auch eine Fortsetzung.«

– Sprichwort

Willkommen im zweiten Teil der Insel. Während der erste Band in die Grundlagen von

Java einführte und sich dabei insbesondere auf die objektorientierten Konzepte und die

Syntax der Sprache Java konzentrierte, kümmert sich der zweite Band um die Bibliotheken

aus der Java SE.

Organisation der Kapitel

Den Einsteig ins Buch bildet Kapitel 1, »Neues in Java 7«, mit einer kompakten Darstellung

der Neuerungen. Die Änderungen in den Bibliotheken fließen dabei in die jeweiligen Kapi-

tel ein; so konzentriert sich das kurze Kapitel eher auf die neuen Spracheigenschaften.

Kapitel 2 beschäftigt sich mit »Threads und nebenläufiger Programmierung«. Das Kapitel

umfasst auch die Koordination mehrerer kooperierender oder konkurrierender Threads.

Seit Java 5 ist ein neues java.util.concurrent-Paket hinzugekommen, das die Programmie-

rung nebenläufiger Programme gegenüber Java 1.0 sehr vereinfacht – dieses neue Paket

bildet die Grundlage des Kapitels.

Kapitel 3 beschäftigt sich mit den »Datenstrukturen und Algorithmen«, die die Standard-

bibliothek anbietet. Die wichtigsten Klassen wie Listen, Mengen, Stapel, Bitmengen und

Assoziativspeicher werden vorgestellt, und dann werden unterschiedliche Aufgaben mit

den jeweils passenden Datenstrukturen gelöst. Als Algorithmen kommen beispielsweise

vorgefertigte Sortierverfahren zum Einsatz. Das Kapitel diskutiert ebenfalls für Nebenläu-

figkeit optimierte Datenstrukturen.

Zeitzonen und unterschiedliche Ausgabeformate für Datumswerte sind Thema in Kapitel 4,

»Raum und Zeit«. Darunter fallen auch Datumsberechnungen auf der Grundlage des grego-

rianischen Kalenders. Interessant sind Java-Möglichkeiten zur Internationalisierung, was

sich durchweg durch alle APIs zieht, die in irgendeiner Weise Nachrichten zum Benutzer

geben.


Vorwort

36

Das Kapitel 5, »Dateien, Verzeichnisse und Dateizugriffe«, setzt den Fokus auf Dateiverarbei-

tung. Zuerst zeigen wir, wie sich Attribute von Dateien und Verzeichnissen auslesen lassen,

und dann, wie sich wahlfreier Zugriff auf eine Datei realisieren lässt. Das in Java 7 eingeführte

NIO.2-Paket nimmt dabei einen großen Raum ein, da es sehr leistungsfähig ist.

Nahtlos folgt in Kapitel 6, »Datenströme«, die Verarbeitung von Daten aus beliebigen Quellen

und Senken. Während sich Kapitel 5 nur auf Dateien beschränkt, geht es in diesem Kapitel um

allgemeinere Ein-/Ausgabe-Konzepte, die auch bei Datenströmen aus Netzwerken, Datenban-

ken oder Schnittstellen vorkommen. Die Datenströme können dabei durch Filter geschickt

werden. Von Letzteren stellen wir einige vor, die zum Beispiel die Zeilennummer zählen,

einen Datenstrom puffern oder ihn komprimieren. Eine elegante Möglichkeit ist das Seriali-

sieren von Objekten. Dabei wird der Zustand eines Objekts ausgelesen und so in einen Daten-

strom geschrieben, dass sich das Objekt später wiederherstellen lässt. Eine eigene Speicher-

routine kann somit entfallen.

Ein neues Thema spannt Kapitel 7 mit »Die eXtensible Markup Language (XML)« auf. Java als

plattformunabhängige Programmiersprache und XML als dokumentenunabhängige Be-

schreibungssprache sind ein ideales Paar, und die Kombination dieser beiden Technologien

ist der Renner der letzten Jahre. Das Kapitel beginnt auf der höchsten Abstraktionsebene, be-

schreibt, wie XML-Daten auf Objekte übertragen werden, und geht dann weiter zur elementa-

ren Verarbeitung der XML-Dokumente, wie sie zum Beispiel als Objekt-Baum aufgebaut und

modifiziert werden.

Heutzutage ist die Speicherung in XML populär, und auch Office-Dokumente werden in die-

sem Stil gespeichert. Doch keiner würde auf die Idee kommen, die Dokumente im XML-For-

mat auszulesen und dort die Absätze und Zeichen herauszuziehen. Das Gleiche gilt für Grafik-

dateien: Es ist zwar eine Byte-Datei, doch die wird nicht als Byte für Byte von uns eingelesen,

sondern es gibt immer eine API, die sich darum kümmert, Zeichen oder Bytes in ein für uns

komfortables Format zu bringen. Ein paar populäre Dateiformate stellt Kapitel Kapitel 8, »Da-

teiformate«, vor. Zu den beschriebenen Formaten zählen nicht nur Dokumentenformate, wie

für Microsoft Office, sondern auch Formate für die Kompression.

Kapitel 9, »Grafische Oberflächen mit Swing«, stellt die Swing-Komponenten zur Interaktion

vor, wie zum Beispiel Schaltflächen. Es geht auf die Behandlung von Ereignissen ein, die aus

Benutzeraktionen resultieren, und beschreibt Container, die andere Komponenten aufneh-

men und layouten.

Das anschließende Kapitel 10 deckt die zweite Aufgabe der grafischen Oberflächen ab, indem

es auf die »Grafikprogrammierung« eingeht. Das AWT (Abstract Window Toolkit) ist die Java-

Möglichkeit, grafische Oberflächen zu gestalten. Dabei gliedert es sich in zwei große Teile:

zum einen in die direkte Ausgabe von Grafik-Primitiven wie Linien, und zum anderen in


Vorwort

37

Komponenten für grafische Oberflächen. Das Kapitel behandelt die Themen Fenster, Zeichen-

ketten und Zeichensätze, Farben und Bilder.

Kapitel 11, »Netzwerkprogrammierung«, stellt vor, welche Informationen eine URL hat und

wie mit dieser URL Daten von Webservern bezogen werden können. Bei Webservern werden

wir CGI-Programme ansprechen, um an gewünschte Inhalte zu kommen. Mithilfe von Sockets

wollen wir eine eigene Client-Server-Kommunikation aufbauen. Außer auf die gesicherte Ver-

bindung TCP gehen wir auch auf ungesicherte UDP-Verbindungen ein.

»Verteilte Programmierung mit RMI« in Kapitel 12 zeigt auf, wie ein Java-Programm einfach

Objekte und Methoden nutzen kann, die auf einem anderen Rechner gespeichert beziehungs-

weise ausgeführt werden. Dabei wird der Aufruf einer Methode über das Netzwerk übertra-

gen, und für das aufrufende Programm sieht es so aus, als ob es sich um einen normalen Me-

thodenaufruf für ein lokales Objekt handelt.

Kapitel 13, »RESTful und SOAP Web-Services«, stellt mit REST einen neuen Trend in der Kom-

munikation zwischen Browser und Web-Server vor und mit SOAP einen Klassiker für den ent-

fernten Methodenaufruf zwischen Systemen. SOAP ist Teil der Java SE, und für REST wird Jer-

sey vorgestellt, die Referenzimplementierung der JAX-RS-API.

Mit Kapitel 14, »JavaServer Pages und Servlets«, geht es dann in die Welt der dynamischen

Webseiten. Java ist zurzeit auf der Serverseite sehr populär, und dort besonders beim soge-

nannten Enterprise-Computing. Mit JavaServer Pages ist es besonders einfach, dynamische

Webinhalte zu formulieren und auf die vom Client mitgeschickten Informationen sehr ein-

fach zuzugreifen. JSPs verfügen zudem über die gesamten Java-Möglichkeiten, insbesondere

die Fähigkeit zur Datenbankanbindung.

Grafische Oberflächen und Netzwerke verbinden das Kapitel 15 zum Thema »Applets«. App-

lets sind Java-Programme innerhalb eines Webbrowsers. Applets machten Java vor über 10

Jahren auf der Welt bekannt, und die ersten Java-Bücher erklärten alles im Zusammenhang

mit Applets. Heutzutage spielen Applets keine große Rolle mehr – auch durch die Verbreitung

von Flash – und sind schon fast zu einer Nischentechnologie geworden.

»Datenbankmanagement mit JDBC« ist das Thema von Kapitel 16. Als freie, quelloffene Bei-

spieldatenbank wird HSQLDB vorgestellt, da sie sehr leicht zu installieren und zu betreiben ist

und praktischerweise Beispieldaten mitbringt. Die Java-Beispiele bauen eine Verbindung zu

HSQLDB auf, setzen SQL-Anweisungen ab, holen die Ergebnisse herein und visualisieren sie.

Viele der vorgestellen Technologien sind sehr speziell, doch Kapitel 17, »Technologien für die

Infrastruktur«, geht auf den Aufbau großer Anwendungen ein und stellt Basistechnologien

vor, die ein gutes Fundament für eigene Anwendungen bilden und in jeder Architektur zu fin-

den sein dürften, ob es nun grafische Anwendungen sind oder reine Serveranwendungen.


Vorwort

38

Mit Kapitel 18 widmen wir uns einer Java-typischen Technik: »Reflection und Annotationen«.

Java-Klassen liegen selbst wieder als Meta-Objekte, als Exemplare der speziellen Klasse Class,

vor. Diese Class-Objekte geben Auskunft über die verfügbaren und definierten Variablen, Me-

thoden und Konstruktoren. So lassen sich beispielsweise dynamisch bestimmte Methoden

aufrufen oder die Werte von dynamisch ausgewählten Objektvariablen abfragen. Die Annota-

tionen sind eine bedeutende Neuerung in Java 5.

Am Anfang war die JVM fest mit der Programmiersprache Java verbunden, doch das änderte

sich im Laufe der Jahre. Heute gibt es unterschiedliche Programmiersprachen, die auf einer

JVM laufen – von ganz entwickelten Skriptsprachen bis zu portierten. Kapitel 19, »Dynami-

sche Übersetzung und Skriptsprachen«, stellt Skriptsprachen vor und auch die Möglichkeit,

wie eigene Klassen mit der Compiler-API übersetzt werden.

Wie Java-Programme zu Testzwecken überwacht werden können, zeigt Kapitel 20, »Logging

und Monitoring«. Mit der JMX-API lassen sich MBeans an einem MBean-Server anmelden, und

das Dienstprogramm jconsole ermöglicht den Zugriff und die Steuerung der Komponenten.

Java kann nicht alles plattformunabhängig lösen. An einer bestimmen Stelle muss plattform-

abhängiger Programmcode eingebaut werden. Um von Java auf Nicht-Java-Code wie C(++) zu-

zugreifen, definiert Oracle das in Kapitel 21 vorgestellte »Java Native Interface (JNI)«.

Kapitel 22 zeigt kurz »Sicherheitskonzepte«, etwa das Sandkastenprinzip, und Sicherheitsma-

nager auf, zeigt aber auch, wie von Daten eine Prüfsumme gebildet werden kann und wie

Daten mit DES oder RSA verschlüsselt werden.

In Kapitel 23, »Dienstprogramme für die Java-Umgebung«, geht es um die zum JDK gehörigen

Programme und um einige Extratools, die für Ihre Arbeit nützlich sind. Im Mittelpunkt stehen

Compiler, Interpreter und die Handhabung von Jar-Archiven. Dieses Archivformat ist vergleich-

bar mit den bekannten Zip-Archiven und fasst mehrere Dateien zusammen. Mit den eingebet-

teten Dokumentationskommentaren in Java kann aus einer Quellcodedatei ganz einfach eine

komplette HTML-Dokumentation der Klassen, Schnittstellen, Vererbungsbeziehungen und

Eigenschaften inklusive Verlinkung erstellt werden. Unter den Programmen, die zu keiner Stan-

dardinstallation gehören, sind etwa Tools, die Java-Programme in C-Programme übersetzen, sie

neu einrücken und formatieren und Bytecode wieder in lesbaren Java-Quellcode umwandeln.

Vorwort zur 1. Auflage

Es ist unverkennbar, dass dieses Buch seinen Ursprung in »Java ist auch eine Insel« hat. Es

enthält alle fortgeschrittenen Java-Konzepte der vorangegangenen Insel. Bei dieser Aufspal-

tung ist es natürlich nicht geblieben, denn sonst wäre das Buch ja auch nur 700 Seiten dick

und nicht 1400. Es gab also Änderungen und Neuerungen gegenüber diesen Kapiteln in der

alten Insel.


Vorwort

39

Zu den Neuerungen: Natürlich ist das Buch auf der Höhe der Zeit und beschreibt die aktuellen

Java 7-Features. Das erste Kapitel fasst die bescheidenen Sprachänderungen zusammen. Auf-

seiten der Bibliothek gibt es zwei größere Zuwächse: NIO.2 und das kleinere Fork-And-Join-

Framework. Swing bietet eine neue Klasse namens JLayer und bekommt kleine Updates, etwa

durch eine generische Typvariable etwa bei ListModel oder JComboBox.

Ein weiteres neues Kapitel behandelt dynamische Übersetzung mit dem Java-Compiler zur Lauf-

zeit und Skriptsprachen, wobei es einige Beispiele zur beliebten JVM-Sprache Groovy gibt. Und

da Web-Services nicht mehr nur durch SOAP realisiert werden, gibt es ein Unterkapitel zum

REST-Prinzip und JAW-RS. Im Swing-Kapitel ist eine bildgeführte Anleitung zu finden, wie sich

mit NetBeans einfach grafische Oberflächen entwickeln lassen. Am Ende des Swing-Kapitels

befindet sich ein Ausblick auf die freie Komponentenbibliothek SwingX, mit der Entwickler die

GUIs aufhübschen können. Das Datenbankkapitel hat einen Ausblick auf JPA bekommen, wobei

die Beispiele hier auch wieder mit NetBeans realisiert werden.

Zu den Aktualisierungen: Auch ohne die Anpassungen aus Java 7 gibt es Verbesserungen und

Aktualisierungen. Im Tooling-Bereich ist der Decompiler Jad durch JD ersetzt worden. Gleich-

zeitig gibt das gleiche Kapitel eine Einführung in Java-Bytecode und das Tool javap. Weiterhin

im Bereich Datenbanktools ist eine kleine Änderung nötig geworden, da der Datenbankbrow-

ser in die Eclipse Data Tools Platform (DTP) gewandert ist und sich auch die grafische Oberflä-

che veränderte. Im Bereich Java ME ist das Plugin zu Eclipse gewandert und trägt jetzt den

neuen Namen Eclipse Mobile Tools for Java (MTJ).

Christian Ullenboom

Sonsbeck, im Oktober 2011


41

1Kapitel 1

Neues in Java 7

»Jede Lösung eines Problems ist ein neues Problem.«

– Johann Wolfgang von Goethe (1749–1832)

1.1 Sprachänderungen

Die folgenden Abschnitte stellen Sprachänderungen aus Java 7 vor.

1.1.1 Zahlen im Binärsystem schreiben

Die Literale für Ganzzahlen lassen sich in vier unterschiedlichen Stellenwertsystemen ange-

ben. Das natürlichste ist das Dezimalsystem (auch Zehnersystem genannt), bei dem die Lite-

rale aus den Ziffern »0« bis »9« bestehen. Zusätzlich existieren Oktal- und Hexadezimal-

systeme, und seit Java 7 die Binärschreibweise. Bis auf Dezimalzahlen beginnen die Zahlen in

anderen Formaten mit einem besonderen Präfix.

1.1.2 Unterstriche bei Ganzzahlen

Um eine Anzahl von Millisekunden in Tage zu konvertieren, muss einfach eine Division vor-

genommen werden. Um Millisekunden in Sekunden umzurechnen, brauchen wir eine Divi-

sion durch 1000, von Sekunden auf Minuten eine Division durch 60, von Minuten auf Stun-

Präfix Stellenwertsystem Basis Darstellung von 1

0b oder 0B Binär 2 0b1 oder 0B1

0 Oktal 8 01

Kein Dezimal 10 1

0x oder 0X Hexadezimal 16 0x1 oder 0X1

Tabelle 1.1: Die Stellenwertsysteme und ihre Schreibweise


1 Neues in Java 7

42

den eine Division durch 60, und die Stunden auf Tage bringt die letzte Division durch 24.

Schreiben wir das auf:

long millis = 10 * 24*60*60*1000L;

long days = millis / 86400000L;

System.out.println( days ); // 10

Eine Sache fällt bei der Zahl 86400000 auf: Besonders gut lesbar ist sie nicht. Die eine Lösung

ist, es erst gar nicht zu so einer Zahl kommen zu lassen und sie wie in der ersten Zeile durch

eine Reihe von Multiplikationen aufzubauen – mehr Laufzeit kostet das nicht, da dieser kon-

stante Ausdruck zur Übersetzungszeit feststeht.

Die zweite Variante ist eine neue Schreibweise, die Java 7 einführt: Unterstriche in Zahlen. An-

statt ein numerisches Literal als 86400000 zu schreiben, ist in Java 7 auch Folgendes erlaubt:

long millis = 10 * 86_400_000L;

long days = millis / 86_400_000L;

System.out.println( days ); // 10

Die Unterstriche machen die 1000er-Blöcke gut sichtbar. Hilfreich ist die Schreibweise auch

bei Literalen in Binär- und Hexdarstellung, da die Unterstriche hier ebenfalls Blöcke absetzen

können.1

Der Unterstrich darf in jedem Literal stehen, zwei aufeinanderfolgende Unterstriche sind aber

nicht erlaubt.

1.1.3 switch (String)

Seit Java 7 sind switch-Anweisungen auf String-Objekten möglich.

String input = javax.swing.JOptionPane.showInputDialog( "Eingabe" );

switch ( input.toLowerCase() )

1 Bei Umrechnungen zwischen Stunden, Minuten und so weiter hilft auch die Klasse TimeUnit mit einigen

statischen toXXX()-Methoden.

Beispiel

Unterstriche verdeutlichen Blöcke bei Binär- und Hexadezimalzahlen.

int i = 0b01101001_01001101_11100101_01011110;

long l = 0x7fff_ffff_ffff_ffffL;



43

1{

case "kekse":

System.out.println( "Ich mag Keeeekse" );

break;

case "kuchen":

System.out.println( "Ich mag Kuchen" );

break;

case "scholokade":

case "lakritze":

System.out.println( "Hm. lecker" );

break;

default:

System.out.printf( "Kann man %s essen?", input );

}

Obwohl Zeichenkettenvergleiche nun möglich sind, fallen Überprüfungen auf reguläre Aus-

drücke leider heraus, die insbesondere Skriptsprachen anbieten.

Wie auch beim switch mit Ganzzahlen können die Zeichenketten beim String-case-Zweig aus

finalen (also nicht änderbaren) Variablen stammen. Ist etwa String KEKSE = "kekse"; vordefi-

niert, ist case KEKSE: erlaubt.

1.1.4 Zusammenfassen gleicher catch-Blöcke mit dem multi-catch

Greift ein Programm auf Teile zurück, die scheitern können, so ergeben sich in komplexeren

Abläufen schnell Situationen, in denen unterschiedliche Ausnahmen auftreten können. Ent-

wickler sollten versuchen, den Programmcode in einem try-Block durchzuschreiben, und

dann in catch-Blöcken auf alle möglichen Fehler zu reagieren, die den Block vom korrekten

Durchlaufen abgehalten haben.

Oftmals kommt es zu dem Phänomen, dass die aufgerufenen Programmteile unterschied-

liche Ausnahmetypen auslösen, aber die Behandlung der Fehler gleich aussieht. Um Quell-

codeduplizierung zu vermeiden, sollte der Programmcode zusammengefasst werden. Neh-

men wir an, die Behandlung der Ausnahmen SQLException und IOException soll gleich sein.

Wir haben schon gesehen, dass ein catch(Exception e) keine gute Lösung ist und nie im Pro-

grammcode vorkommen sollte, denn dann würden auch andere Ausnahmen mitgefangen.

Zum Glück gibt es in Java 7 eine elegante Lösung.


1 Neues in Java 7

44

Multi-catch

Java 7 führt eine neue Schreibweise für catch-Anweisungen ein, um mehrere Ausnahmen auf

einmal aufzufangen; sie heißt multi-catch. In der abgewandelten Variante von catch steht

dann nicht mehr nur eine Ausnahme, sondern eine Sammlung von Ausnahmen, die ein »|«

trennt. Der Schrägstrich ist schon als Oder-Operator bekannt und wurde daher auch hier ein-

gesetzt, denn die Ausnahmen sind ja auch als eine Oder-Verknüpfung zu verstehen. Die allge-

meine Syntax ist:

try

{

...

}

catch ( E1 | E2 | ... | En exception )

Die Variable exception ist implizit final.

Um das multi-catch zu demonstrieren, nehmen wir ein Programm an, das eine Farbtabelle

einliest. Die Datei besteht aus mehreren Zeilen, wobei in jeder Zeile die erste Zahl einen Index

repräsentiert und die zweite Zahl den hexadezimalen RGB-Farbwert.

Listing 1.1: basiscolors.txt

0 000000

1 ff0000

8 00ff00

9 ffff00

Eine eigene Methode readColorTable() soll die Datei einlesen und ein int-Feld der Größe 256

als Rückgabe liefern, wobei an den in der Datei angegebeen Positionen jeweils die Farbwerte

eingetragen sind. Nicht belegte Positionen bleiben 0. Gibt es einen Ladefehler, soll die Rück-

gabe null sein und die Methode eine Meldung auf dem Fehlerausgabekanal ausgeben.

Das Einlesen soll die Scanner-Klasse übernehmen. Bei der Verarbeitung der Daten und der Fül-

lung des Feldes sind diverse Fehler denkbar:

Þ IOException: Die Datei ist nicht vorhanden, oder während des Einlesens kommt es zu Pro-

blemen.

Þ InputMismatchException: Der Index oder die Hexadezimalzahl sind keine Zahlen (einmal zur

Basis 10, und dann zur Basis 16). Den Fehlertyp löst der Scanner aus.

Þ ArrayIndexOutOfBoundsException: Der Index liegt nicht im Bereich von 0 bis 255.

Während der erste Fehler beim Dateisystem zu suchen ist, sind die zwei unteren Fehler – un-

abhängig davon, dass sie ungeprüfte Ausnahmen sind – auf ein fehlerhaftes Format zurück-



45

1zuführen. Die Behandlung soll immer gleich aussehen und kann daher gut in einem multi-

catch zusammengefasst werden. Daraus folgt:

Listing 1.2: ReadColorTable.java

import java.io.*;

import java.util.Scanner;

public class ReadColorTable

{

private static int[] readColorTable( String filename )

{

Scanner input;

int[] colors = new int[ 256 ];

try

{

input = new Scanner( new File(filename) );

while ( input.hasNextLine() )

{

int index = input.nextInt();

int rgb = input.nextInt( 16 );

colors[ index ] = rgb;

}

return colors;

}

catch ( IOException e )

{

System.err.printf( "Dateioperationen fehlgeschlagen%n%s%n", e );

}

catch ( InputMismatchException | ArrayIndexOutOfBoundsException e )

{

System.err.printf( "Datenformat falsch%n%s%n", e );

}

finally

{

input.close();

}

return null;

}


1 Neues in Java 7

46

public static void main( String[] args )

{

readColorTable( "basiscolors.txt" );

}

}

Multi-catch-Blöcke sind also eine Abkürzung, und der Bytecode sieht genauso aus wie meh-

rere gesetzte catch-Blöcke, also wie:

catch ( InputMismatchException e )

{


}

catch ( ArrayIndexOutOfBoundsException e )

{


}

Multi-catch-Blöcke sind nur eine Abkürzung, daher teilen sie auch die Eigenschaften der nor-

malen catch-Blöcke. Der Compiler führt die gleichen Prüfungen wie bisher durch, also ob etwa

die genannten Ausnahmen im try-Block überhaupt ausgelöst werden können. Nur das, was in

der durch »|« getrennten Liste aufgezählt ist, wird behandelt; unser Programm fängt zum Bei-

spiel nicht generisch alle RuntimeExceptions ab. Und genauso dürfen die in catch oder multi-

catch genannten Ausnahmen nicht in einem anderen (multi)-catch auftauchen.

Neben den Standard-Tests kommen neue Überprüfungen hinzu, ob etwa die exakt gleiche Ex-

ception zweimal in der Liste ist oder ob es Widersprüche durch Mengenbeziehungen gibt.

Hinweis

Der folgende multi-catch ist falsch:

try

{

new RandomAccessFile("", "");

}

catch ( FileNotFoundException | IOException | Exception e ) { }

Der javac-Compiler meldet einen Fehler der Art »Alternatives in a multi-catch statement

cannot be related by subclassing« und bricht ab.



47

1

1.1.5 Präzisiertes rethrows

Die Notwendigkeit, Ausnahmen über einen Basistyp zu fangen, ist mit dem Einzug vom

multi-catch gesunken. Doch für gewisse Programmteile ist es immer noch praktisch, alle Feh-

ler eines gewissen Typs aufzufangen. Wir können auch so weit in der Ausnahmehierarchie

nach oben laufen, um alle Fehler aufzufangen – dann haben wir es mit einem try { ... }

catch(Throwable t){ ... } zu tun. Ein multi-catch ist für geprüfte Ausnahmen besonders gut,

aber bei ungeprüften Ausnahmen ist eben nicht immer klar, was als Fehler denn so ausgelöst

wird, und ein catch(Throwable t) hat den Vorteil, dass es alles wegfischt.

Problemstellung

Werden Ausnahmen über einen Basistyp gefangen und wird diese Ausnahme mit throw wei-

tergeleitet, dann ist es naheliegend, dass der aufgefangene Typ genau der Typ ist, der auch bei

throws in der Methodensignatur stehen muss.

Stellen wir uns vor, ein Programmblock nimmt einen Screenshot und speichert ihn in einer

Datei. Kommt es beim Abspeichern zu einem Fehler, soll das, was vielleicht schon in die Datei

geschrieben wurde, gelöscht werden; die Regel ist also: Entweder steht der Screenshot kom-

plett in der Datei oder es gibt gar keine Datei. Die Methode kann so aussehen, wobei die Aus-

nahmen an den Aufrufer weitergegeben werden sollen:

public static void saveScreenshot( String filename )

throws AWTException, IOException

{

try

{

Rectangle r = new Rectangle( Toolkit.getDefaultToolkit().getScreenSize() );

Mengenprüfungen führt der Compiler auch ohne multi-catch durch, und Folgendes ist eben-

falls falsch:

try { new RandomAccessFile("", ""); }

catch ( Exception e ) { }

catch ( IOException e ) { }

catch ( FileNotFoundException e ) { }

Während allerdings eine Umsortierung der Zeilen die Fehler korrigiert, spielt die Reihenfolge

bei multi-catch keine Rolle.

Hinweis (Forts.)


1 Neues in Java 7

48

BufferedImage screenshot = new Robot().createScreenCapture( r );

ImageIO.write( screenshot, "png", new File( filename ) );

}

catch ( AWTException e )

{

throw e;

}


{

new File( filename ).delete();

throw e;

}

}

Mit den beiden catch-Blöcken sind wir genau auf die Ausnahmen eingegangen, die create-

ScreenCapture() und write() auslösen. Das ist richtig, aber löschen wir wirklich immer die Da-

teireste, wenn es Probleme beim Schreiben gibt? Richtig ist, dass wir immer dann die Datei lö-

schen, wenn es zu einer IOException kommt. Aber was passiert, wenn die Implementierung

eine RuntimeException auslöst? Dann wird die Datei nicht gelöscht, aber das ist gefragt! Das

scheint einfach gefixt, denn statt


{


throw e;

}

schreiben wir:

catch ( Throwable e )

{


throw e;

}

Doch können wir das Problem so lösen? Der Typ Throwable passt doch gar nicht mehr mit dem

deklarierten Typ IOException in der Methodensignatur zusammen:

public static void saveScreenshot( String filename )

throws AWTException /*1*/, IOException /*2*/

{



49

1...

catch ( AWTException /*1*/ e )

{

throw e;

}

catch ( Throwable /*?*/ e )

{


throw e;

}

}

Die erste catch-Klausel fängt AWTException und leitet es weiter. Damit wird saveScreenshot()

zum möglichen Auslöser von AWTException und die Ausnahme muss mit throws an die Signa-

tur. Wenn nun ein catch-Block jedes Throwable auffängt und diesen Throwable-Fehler weiterlei-

tet, ist zu erwarten, dass an der Signatur auch Throwable stehen muss und IOException nicht

reicht. Das war auch bis Java 6 so, aber in Java 7 kam eine Anpassung.

Neu seit Java 7: eine präzisere Typprüfung

In Java 7 hat der Compiler eine kleine Veränderung erfahren, von einer unpräziseren zu einer

präziseren Typanalyse: Immer dann, wenn in einem catch-Block ein throw stattfindet, ermit-

telt der Compiler die im try-Block tatsächlich aufgetretenen geprüften Exception-Typen und

schenkt dem im catch genannten Typ für das rethrow im Prinzip keine Beachtung. Statt dem

gefangenen Typ wird der Compiler den durch die Codeanalyse gefundenen Typ beim rethrow

melden.

Der Compiler erlaubt nur dann das präzise rethrow, wenn die catch-Variable nicht verändert

wird. Zwar ist eine Veränderung einer nicht-finalen catch-Variablen wie auch unter Java 1.0

erlaubt, doch wenn die Variable belegt wird, schaltet der Compiler von der präzisen in die un-

präzise Erkennung zurück. Führen wir etwa die folgende Zuweisung ein, so funktioniert das

Ganze schon nicht mehr:

catch ( Throwable e )

{


e = new IllegalStateException();

throw e;

}


1 Neues in Java 7

50

Die Zuweisung führt zu dem Compilerhinweis, dass jetzt auch Throwable mit in die throws-

Klausel muss. 2

2 Die Zahl stammt aus der FOSDEM 2011-Präsentation »Project Coin: Language Evolution in the Open«.

Stilfrage

Die catch-Variable kann für die präzisere Typprüfung den Modifizierer final tragen, muss das

aber nicht tun. Immer dann, wenn es keine Veränderung an der Variablen gibt, wird der Com-

piler sie als final betrachten und eine präzisere Typprüfung durchführen – daher nennt sich

das auch effektiv final. Die Java Language Specification rät vom final-Modifizierer aus

Stilgründen ab. Ab Java 7 ist es das Standardverhalten, und daher ist es Quatsch, überall ein

final dazuzuschreiben, um die präzisere Typprüfung zu dokumentieren.

Migrationsdetail

Da der Compiler nun mehr Typwissen hat, stellt sich die Frage, ob alter Programmode mit dem

neuen präziseren Verhalten vielleicht ungültig werden könnte. Theoretisch ist das möglich,

aber die Sprachdesigner haben in über 9 Millionen Zeilen Code2 von unterschiedlichen Projek-

ten keine Probleme gefunden. Prinzipiell könnte der Compiler jetzt unerreichbaren Code fin-

den, der vorher versteckt blieb. Ein kleines Beispiel, was vor Java 7 compiliert, aber ab Java 7

nicht mehr:

try

{

throw new FileNotFoundException();

}


{

try

{

throw e; // e ist für den Compiler vom Typ FileNotFoundException

}

catch ( MalformedURLException f ) { }

}

Die Variable e in catch (IOException e) ist effektiv final, und der Compiler führt die präzisere

Typerkennung durch. Er findet heraus, dass der wahre rethrow-Typ nicht IOException, sondern

FileNotFoundException ist. Wenn dieser Typ dann mit throw e weitergeleitet wird, kann ihn

catch(MalformedURLException) nicht auffangen.



51

1

1.1.6 Automatisches Ressourcen-Management (try mit Ressourcen)

Java hat eine automatische Garbage-Collection (GC), sodass nicht mehr referenzierte Objekte

erkannt und ihr Speicher automatisch freigegeben wird. Nun bezieht sich die GC aber aus-

schließlich auf Speicher, doch es gibt viele weitere Ressourcen:

Þ Dateisystem-Ressourcen von Dateien

Þ Netzwerkressourcen wie Socket-Verbindungen

Þ Datenbankverbindungen

Þ nativ gebundene Ressourcen vom Grafiksubsystem

Þ Synchronisationsobjekte

Auch hier gilt es, nach getaner Arbeit aufzuräumen und Ressourcen freizugeben, etwa Dateien

und Datenbankverbindungen zu schließen.

Mit dem try-catch-finally-Konstrukt haben wir gesehen, wie Ressourcen freizugeben sind.

Doch es lässt sich auch ablesen, dass relativ viel Quellcode geschrieben werden muss und der

try-catch-finally drei Unfeinheiten hat:

1. Sollte eine Variable in finally zugänglich sein, muss sie außerhalb des try-Blocks deklariert

werden, was ihr eine höhere Sichtbarkeit als nötig gibt.

2. Das Schließen der Ressourcen bringt oft ein zusätzliches try-catch mit sich.

3. Eine im finally ausgelöste Ausnahme (etwa beim close()) überdeckt die im try-Block ausge-

löste Ausnahme.

1.1.7 try mit Ressourcen

Um das Schließen von Ressourcen zu vereinfachen, wurde in Java 7 eine besondere Form der

try-Anweisung eingeführt, die try mit Ressourcen genannt werden. Mit ihm lassen sich Res-

source-Typen, die die Schnittstelle java.lang.AutoCloseable implementieren, automatisch

schließen. Ein-/Ausgabeklassen wie Scanner, InputStream und Writer, implementieren diese

Schnittstelle und können direkt verwendet werden. Weil try mit Ressourcen dem Automatic

Resource Management dient, heißt der spezielle try-Block auch ARM-Block.

Unter Java 6 war das etwas anders, denn hier wusste der Compiler nur, dass e irgendeine

IOException ist, und es hätte ja durchaus die IOException-Unterklasse MalformedURLException

sein können. (Warum MalformedURLException aber eine Unterklasse von IOException ist, steht

auf einem ganz anderen Blatt.)

Migrationsdetail (Forts.)


1 Neues in Java 7

52

Gehen wir in die Praxis: Aus einer Datei soll mit einem Scanner die erste Zeile gelesen und

ausgegeben werden. Nach dem Lesen soll der Scanner geschlossen werden. Die linke Seite der

folgenden Tabelle nutzt die spezielle Syntax, die rechte Seite ist im Prinzip die Übersetzung,

allerdings noch etwas vereinfacht, wie wir später genauer sehen werden.

Üblicherweise folgt nach dem Schlüsselwort try ein Block, doch try-mit-Ressourcen nutzt

eine eigene spezielle Syntax.

1. Nach dem try folgt statt dem direkten {}-Block eine Anweisung in runden Klammern, und

dann erst der {}-Block, also try (...) {...} statt try {...}.

2. In den runden Klammern findet man eine lokale Variablendeklaration (die Variable ist auto-

matisch final) mit einer Zuweisung. Die Ressourcenvariable muss vom Typ AutoCloseable

sein. Rechts vom Gleichheitszeichen steht ein Ausdruck, etwa ein Konstruktor- oder Metho-

denaufruf. Der Typ des Ausdrucks muss natürlich auch intanceof AutoCloseable sein.

Die in dem try deklarierte lokale AutoCloseable-Variable ist nur in dem Block gültig und wird

automatisch freigegeben, gleichgültig ob der ARM-Block korrekt durchlaufen wurde oder ob

es bei der Abarbeitung zu einem Fehler kam. Der Compiler fügt alle nötigen Prüfungen ein.

try mit Ressourcen Vereinfachte ausgeschriebene Implementierung

InputStream in =

ClassLoader.getSystemResourceAsStream(

"EastOfJava.txt" );

try ( Scanner res =

new Scanner( in ) )

{

System.out.println(

res.nextLine() );

}

InputStream in =

ClassLoader.getSystemResourceAsStream(

"EastOfJava.txt" );

{

final Scanner res =

new Scanner( file );

try

{

System.out.println(

res.nextLine() );

}

finally

{

res.close();

}

}

Tabelle 1.2: Die main()-Methode von TryWithResources1 und ihre prinzipielle Umsetzung



53

11.1.8 Ausnahmen vom close() bleiben bestehen

Unser Scanner-Beispiel hat eine Besonderheit, denn keine der Methoden löst eine geprüfte

Ausnahme aus – weder getSystemResourceAsStream(), new Scanner(InputStream), nextLine()

noch das close(), was try-mit-Ressourcen automatisch aufruft. Anders ist es, wenn die Res-

source ein InputStream ist, denn dort deklariert die close()-Methode eine IOException. Die

muss daher auch behandelt werden, wie es das folgende Beispiel zeigt:

Listing 1.3: TryWithResourcesReadsLine, readFirstLine()

static String readFirstLine( File file )

{

try ( BufferedReader br = new BufferedReader(new FileReader(file) ) )

{

return br.readLine();

}

catch ( IOException e ) { e.printStackTrace(); return null; }

}

Wenn try-mit-Ressourcen verwendet wird, bleibt die Ausnahme bestehen; es zaubert die Aus-

nahmen beim catch also nicht weg.

1.1.9 Die Schnittstelle AutoCloseable

Die ARM-Anweisung schließt Ressourcen vom Typ AutoCloseable. Daher wird es Zeit, sich

diese Schnittstelle etwas genauer anzuschauen:

Hinweis

Löst close() eine geprüfte Ausnahme aus, und wird diese nicht behandelt, so kommt es zum

Compilerfehler. Die close()-Methode vom BufferedReader löst zum Beispiel eine IOException

aus, sodass sich die folgende Methode nicht übersetzen lässt:

void no()

{

try ( Reader r = new BufferedReader(null) ) { } // Compilerfehler

}

Der Ausdruck new BufferedReader(null) benötigt keine Behandlung, denn der Konstruktor löst

keine Ausnahme aus. Einzig der nicht behandelte Fehler von close() führt zu »exception

thrown from implicit call to close() on resource variable 'r'«.


1 Neues in Java 7

54

package java.lang;

public interface AutoCloseable

{

void close() throws Exception;

}

Anders als das übliche close() ist die Ausnahme deutlich allgemeiner mit Exception angege-

ben; die Ein-/Ausgabe-Klassen lösen beim Misslingen immer eine IOException aus, aber jede

Klasse hat eigene Ausnahmetypen:

Eine Unterklasse darf die Ausnahme ja auch weglassen, das machen Klassen wie der Scanner,

der keine Ausnahme weiterleitet, sondern sie intern schluckt – wenn es Ausnahmen gab, lie-

fert sie die Scanner-Methode ioException().

AutoCloseable und Closeable

Auf den ersten Blick einleuchtend wäre es, die schon existierende Schnittstelle Closeable als

Typ zu nutzen. Doch das hätte Nachteile: Die close()-Methode ist mit einem throws IOExcep-

tion deklariert, was bei einer allgemeinen automatischen Ressourcen-Freigabe unpassend ist,

wenn etwa ein Grafikobjekt bei der Freigabe eine IOException auslöst. Vielmehr ist der Weg

anders herum: Closeable erweitert AutoCloseable, denn das Schließen von Ein-/Ausgabe-Res-

sourcen ist eine besondere Art, allgemeine Ressourcen zu schließen.

package java.io;

import java.io.IOException;

public interface Closeable extends AutoCloseable

{

void close() throws IOException;

}

Typ Signatur

java.io.Scanner close() // ohne Ausnahme

javax.sound.sampled.Line close() // ohne Ausnahme

java.io.FileInputStream close() throws IOException

java.sql.Connection close() throws SQLException

Tabelle 1.3: Einige Typen, die AutoCloseable implementieren



55

1Wer ist AutoCloseable?

Da alle Klassen, die Closeable implementieren, auch automatisch vom Typ AutoCloseable sind,

kommen schon einige Typen zusammen. Im Wesentlichen sind es aber Klassen aus dem

java.io-Paket, wie Channel-, Reader-, Writer-Implementierungen, FileLock, XMLDecoder und noch

ein paar Exoten wie URLClassLoader, ImageOutputStream. Auch Typen aus dem java.sql-Paket

gehören zu den Nutznießern. Klassen aus dem Bereich Threading, wo etwa ein Lock wieder

freigeben werden könnte, oder Grafik-Anwendungen, bei denen der Grafik-Kontext wieder

freigegeben werden muss, gehören nicht dazu.

1.1.10 Mehrere Ressourcen nutzen

Unsere beiden Beispiele zeigten die Nutzung eines Ressource-Typs. Es sind aber auch mehrere

Typen möglich, die dann mit einem Semikolon getrennt werden:

try ( InputStream in = new FileInputStream(src);

OutputStream out = new FileOutputStream(dest) )

{ ... }

Wenn es beim Anlegen in der Kette zu einem Fehler kommt, wird nur das geschlossen, was

auch aufgemacht wurde. Wenn es also bei der ersten Initialisierung von in1 schon zu einer

Ausnahme kommt, wird die Belegung von in2 erst gar nicht begonnen und daher auch nicht

geschlossen. (Intern setzt der Compiler das als geschachtelte try-catch-finally-Blöcke um.)

Hinweis

Die Trennung erledigt ein Semikolon, und jedes Segment kann einen unterschiedlichen Typ

deklarieren, etwa InputStream/OutputStream. Die Ressourcen-Typen müssen also nicht gleich

sein, und auch wenn sie es sind, muss der Typ immer neu geschrieben werden, also etwa:

try ( InputStream in1 = ...; InputStream in2 = ... )

Es ist ungültig, Folgendes zu schreiben:

try ( InputStream in1 = ..., in2 = ... ) // Compilerfehler

Beispiel

Am Schluss der Ressourcensammlung kann – muss aber nicht – ein Semikolon stehen, so wie

auch bei Feldinitialisierungen zum Schluss ein Komma stehen kann:

int[] array = { 1, 2, };

// ^ Komma optional


1 Neues in Java 7

56

1.1.11 Unterdrückte Ausnahmen *

Aufmerksame Leser haben bestimmt schon ein Detail wahrgenommen: Im Text steht »ver-

einfachte ausgeschriebene Implementierung«, was vermuten lässt, dass es ganz so einfach

doch nicht ist. Das stimmt, denn es können zwei Ausnahmen auftauchen, die einiges an Son-

derbehandlung benötigen:

Þ Ausnahme im try-Block. An sich unproblematisch.

Þ Ausnahme beim close(). Auch an sich unproblematisch. Aber es gibt mehrere close()-Auf-

rufe, wenn nicht nur eine Ressource verwendet wurde. Ungünstig.

Þ Die Steigerung: Ausnahme im try-Block und dann auch noch Ausnahme(n) beim close().

Das ist ein echtes Problem!

Eine Ausnahme alleine ist kein Problem, aber zwei Ausnahmen auf einmal bilden ein großes

Problem, da ein Programmblock nur genau eine Ausnahme melden kann und nicht eine

Sequenz von Ausnahmen. Daher sind verschiedene Fragen zu klären, falls der try-Block und

close() beide eine Ausnahme auslösen:

Þ Welche Ausnahme ist wichtiger? Die Ausnahme im try-Block oder die vom close()?

Þ Wenn es zu zwei Ausnahmen kommt: Soll die von close() vielleicht immer verdeckt wer-

den und immer nur die vom try-Block zum Anwender kommen?

Þ Wenn beide Ausnahmen wichtig sind, wie sollen sie gemeldet werden?

Wie haben sich die Java-Ingenieure entschieden? Eine Ausnahme bei close() darf bei einem

gleichzeitigen Auftreten einer Exception im try-Block auf keinen Fall verschwinden.3 Wie also

beide Ausnahmen melden? Hier gibt es einen Trick: Da die Ausnahme im try-Block wichtiger

ist, ist sie die »Haupt-Ausnahme«, und die close()-Ausnahme kommt Huckepack als Extra-

Information mit oben drauf.

try ( InputStream in = new FileInputStream(src); ) { ... }

// ^ Semikolon optional

try ( InputStream in = new FileInputStream(src);

OutputStream out = new FileOutputStream(dest); ) { ... }

// ^ Semikolon optional

Ob das stilvoll ist, muss jeder selbst entscheiden; in der Insel steht kein unnützes Zeichen.

3 In einem frühen Prototyp war dies tatsächlich der Fall – die Ausnahme wurde komplett geschluckt.

Beispiel (Forts.)



57

1Dieses Verhalten soll das nächste Beispiel zeigen. Um die Ausnahmen besser steuern zu kön-

nen, soll eine eigene AutoCloseable-Implementierung eine Ausnahme in close() auslösen.

Listing 1.4: SuppressedClosed.java

public class SuppressedClosed

{


{

class NotCloseable implements AutoCloseable

{

@Override public void close()

{

throw new UnsupportedOperationException( "close() mag ich nicht" );

}

}

try ( NotCloseable res = new NotCloseable() ) {

throw new NullPointerException();

}

}

}

Das Programm löst also im close() und im try-Block eine Ausnahme aus. Das Resultat ist:

Exception in thread "main" java.lang.NullPointerException

at SuppressedClosed.main(SuppressedClosed.java:14)

Suppressed: java.lang.UnsupportedOperationException: close() mag ich nicht

at SuppressedClosed$1NotCloseable.close(SuppressedClosed.java:9)


Die interessante Zeile beginnt mit »Suppressed:«, denn dort ist die close()-Ausnahme refe-

renziert. An den Aufrufer kommt die spannende Ausnahme vom misslungenen try-Block

aber nicht direkt von close(), sondern verpackt in der Hauptausnahme und muss extra er-

fragt werden.

Zum Vergleich: Kommentieren wir throw new NullPointerException() aus, gibt es nur noch die

close()-Ausnahme und es folgt auf der Konsole:


1 Neues in Java 7

58

Exception in thread "main" java.lang.UnsupportedOperationException: close() mag ich nicht



Die Ausnahme ist also nicht irgendwo anders untergebracht, sondern die »Hauptausnahme«.

Eine Steigerung ist, dass es mehr als eine Ausnahme beim Schließen geben kann. Simulieren

wir auch dies wieder an einem Beispiel, indem wir unser Beispiel um eine Zeile ergänzen:

try ( NotCloseable res1 = new NotCloseable();

NotCloseable res2 = new NotCloseable() )

{

throw new NullPointerException();

}

Aufgerufen führt dies zu:

Exception in thread "main" java.lang.NullPointerException








Jede unterdrückte close()-Ausnahme taucht auf.

Spezielle Methoden in Throwable *

Damit eine normale Exception die unterdrückten close()-Ausnahmen Huckepack nehmen

kann, sind in der Basisklasse Throwable seit Java 7 zwei Methoden hinzugekommen:

Umsetzung

Im Kapitel über finally wurde das Verhalten vorgestellt, dass eine Ausnahme im finally eine

Ausnahme im try-Block unterdrückt. Der Compiler setzt bei der Umsetzung vom try-mit-Res-

sourcen das close() in einen finally-Block. Ausnahmen im finally-Block sollen eine mögli-

che Hauptausnahme aber nicht schlucken. Daher fängt die Umsetzung vom Compiler jede

mögliche Ausnahme im try-Block ab sowie die close()-Ausnahme und hängt diese Schließ-

Ausnahme, falls vorhanden, an die Hauptausnahme.


1.2 JVM-Änderungen

59

1

Þ final Throwable[] getSuppressed()

Liefert alle unterdrückten Ausnahmen. Die printStackTrace()-Methode zeigt alle unter-

drückten Ausnahmen und greift auf getSuppressed() zurück. Für Anwender wird es selten

Anwendungsfälle für diese Methode geben.

Þ final void addSuppressed(Throwable exception)

Fügt eine neue unterdrückte Ausnahme hinzu. In der Regel ruft der finally-Block vom try-

mit-Ressourcen die Methode auf, doch wir können auch selbst die Methode nutzen, wenn

wir mehr als eine Ausnahme melden wollen. Die Java-Bibliothek selbst nutzt das bisher nur

an sehr wenigen Stellen.

Neben den beiden Methoden gibt es einen protected-Konstruktor, der bestimmt, ob es über-

haupt unterdrückte Ausnahmen geben soll oder ob sie nicht vielleicht komplett geschluckt

werden. Wenn, dann zeigt sie auch printStackTrace() nicht mehr an.

1.2 JVM-Änderungen

Wenn es um Java geht, müssen wir immer unterscheiden, ob es um die Sprache selbst geht,

um die Bibliotheken, um die JVM oder um die Implementierung von Oracle, die das JDK dar-

stellt. Eine wichtige Änderung am Bytecode, und damit an der JVM selbst, ist ein neuer Byte-

code zum Beschleunigen von Methoden, deren Signatur nicht bekannt ist.

final class java.lang.Throwable

Blick über den Tellerrand

In C++ gibt es Dekonstruktoren, die beliebige Anweisungen ausführen, wenn ein Objekt frei-

gegeben wird. Hier lässt sich auch das Schließen von Ressourcen realisieren. C# nutzt statt try

das spezielle Schlüsselwort using, mit Typen, die die Schnittstelle IDisposable implementie-

ren, mit einer Methode Dispose() statt close(). (In Java sollte die Schnittstelle ursprünglich

auch Disposable statt nun AutoCloseable heißen.) In Python 2.5 wurde ein context manage-

ment protocol mit dem Schlüsselwort with realisiert, sodass Python automatisch bei Betreten

eines Blockes __enter__() aufruft und beim Verlassen die Methode __exit__(). Das ist inso-

fern interessant, als dass hier zwei Methoden zur Verfügung stehen. Bei Java ist es nur close()

beim Verlassen des Blockes, aber es gibt keine Methode zum Betreten eines Blockes; so etwas

muss beim Anlegen der Ressource erledigt werden.


1 Neues in Java 7

60

In der Implementierung von Oracle gibt es zwei große Änderungen an der JVM selbst:

Þ einen neuen Garbage-Collector G1 (für Garbage Frist)

Þ komprimierte 64-Bit-Objekt-Pointer, sodass sie in 32 Bit Platz finden.

Bei Java-Programmen mit DTrace (wie Solaris) lassen sich die Zustände erfragen und die Ab-

arbeitung überwachen.

1.2.1 invokedynamic

Seit Java vor über 10 Jahren auf dem Markt erschien, hat sich vieles geändert (und auch vieles

ist gleich geblieben). Auffällig ist eine starke Zunahme von Skriptsprachen – spielten sie vor

10 Jahren kaum eine Rolle, sind sie heute unübersehbar. Möglicherweise ist ein Grund dafür,

dass vor 10–20 Jahren compilierte Sprache einfach nicht die nötige Performance brachten,

aber heute auch durch leistungsfähige Maschinen und intelligente Ausführung die Leistung

einfach da ist.

Skriptsprachen auf der JVM

Eine unübersehbare Tatsache ist, dass viele Skriptsprachen heute in einer virtuellen Maschine

laufen. Besondere Rolle nehmen die Java-Plattform (mit der JVM) und die .NET-Plattform mit

CLR (einer virtuellen Maschine für .NET) ein. Zwei Trends zeigen sich: Zum einen werden exis-

tierende Skriptsprachen auf die JVM/CLR übertragen und zum anderen Sprachen explizit für

die virtuellen Maschinen entworfen.

Skriptsprache Für JVM Für CLR

Python Jython IronPython

Ruby JRuby IronRuby

Lua Jill, Kahlua LuaCLR

JavaScript Rhino IronJS

PHP Quercus

Tcl Jacl

Groovy

JavaFX

Boo

Tabelle 1.4: Skriptsprachen auf der JVM (Java) und CLR (.NET)


1.2 JVM-Änderungen

61

1Umsetzung der Skriptsprachen auf der JVM

Eine Skriptsprache, die explizit für eine VM entworfen wurde, berücksichtigt natürlich Ein-

schränkungen. Existierende Programmiersprachen sind eine ganz andere Herausforderung,

da sie Sprach- und Laufzeitkonstrukte bieten können, die auf der JVM vielleicht nicht unter-

stützt werden. Das ist ein Problem, und drei Strategien zur Lösung bieten sich an:

Þ Ignorieren der Eigenschaften: Python ermöglicht Mehrfachvererbung, Java nicht. Daher

kann das Verhalten von Python unter Java nicht perfekt nachgebildet werden, obwohl

Jython sein Bestes gibt. Weiterhin kann Python Interrupts auffangen, aber so etwas gibt es

unter Java nicht, also auch nicht in Jython. (Das ist aber eher eine Bibliotheks- und weniger

eine Spracheigenschaft.)

Þ Nachbilden der Eigenschaften: In Sprachen wie JavaScript, Python oder Ruby gibt es das so-

genannte Duck Typing. Zur Laufzeit wird erst das Vorhandensein von Methoden geprüft,

und die Typen müssen nicht im Quellcode stehen. In JavaScript ist zum Beispiel function

add(x, y){return x + y;} oder function isEmpty(s){return s == null || s.length() == 0;} er-

laubt, und erst später beim Aufruf stellt sich heraus, was x und y überhaupt ist und ob ein

Plus-Operator/length()-Methode definiert ist. Deklarationen und Aufrufe dieser Art sind

nur mit vielen Tricks auf der JVM umzusetzen.

Þ Ändern der JVM zur Unterstützung der Eigenschaften: Die Spracheigenschaften zu ignorie-

ren ist natürlich keine schöne Sache. Glücklicherweise kommt das selten vor, denn die JVM

macht vieles mit. Ruby erlaubt etwa Methodennamen wie ==, <, >, +, und 1.+2 ist gültig. Die

Bezeichner sind in Java zwar nicht möglich, aber die JVM hat grundsätzlich mit den Be-

zeichnen keine Probleme. Es ist interessant zu sehen, wie unterschiedlich Java als Sprache

und die JVM sind, denn vieles in Java gibt es in der JVM gar nicht. Enums zum Beispiel sind

nur einfache Klassen. Oder dass eine Klasse ohne einen vom Entwickler explizit geschrie-

benen Konstruktor automatisch einen Standardkonstruktor bekommt, ist nur etwas, was

der Compiler generiert. Oder ein super() als ersten Aufruf im Konstruktor – alles das sind

Compilereigenschaften, und von Generics ganz zu schweigen.

Wenn die Besonderheiten einer Skriptsprache über Tricks und intelligentes Übersetzen in

Bytecode realisiert werden können, stellt sich die Frage, ob an der JVM überhaupt Änderun-

gen nötig sind. Wie bei vielen Diskussionen kommt dann ein Argument auf, das Änderungen

oft rechtfertigt: Performance. Wenn eine Änderung in der JVM die Abarbeitung bestimmter

Konstrukte massiv beschleunigt, ist das ein Grund für die Änderung. Und somit sind wir beim

neuen Bytecode invokedynamic angelangt.

Umsetzung von Duck Typing

Reine Java-Programme werden den Bytecode invokedynamic nie benötigen, er ist einzig und

allein in die JVM eingeführt worden, um Methodenaufrufe der Skriptsprachen auf der JVM zu


1 Neues in Java 7

62

beschleunigen. Die bisherigen Bytecodes von Methodenaufrufen trugen alle nötigen Typ-

informationen, so wie es bei Java üblich ist. Nehmen wir:

System.out.prinln( 1 );

Der Compiler macht aus dem Programm ein invokevirtual, wobei genau bei dem Aufruf steht,

dass ein println() gemeint ist, was ein int annimmt. Die Typinformationen im Bytecode sind:

Þ Der Empfänger ist PrintStream, und seine Methode ist println.

Þ Der Parametertyp ist ein int.

Þ Die »Rückgabe« ist void.

Exakt diese Typen müssen vom Compiler in Bytecode gegossen werden, sonst kann die JVM

den Aufruf nicht durchführen.

Skriptsprachen hingegen sind da lascher. Nehmen wir noch einmal unser Beispiel aus Java-

Script:

function isEmpty(s) { return s == null || s.length() == 0; }

Die Typen wären zwar zur Laufzeit bekannt, aber eben nicht zur Compilezeit, in der der Byte-

code erstellt würde. Ein Aufruf der Methode wird schwierig, denn es fehlen ganz offensicht-

lich der Rückgabe- und der Parametertyp. Natürlich könnten sie über einen Trick zu Object er-

gänzt werden. Spielen wir kurz die Konsequenzen durch:

Object isEmpty( Object s )

Das sieht gut aus. Aber jetzt wird es haarig bei length(), das keine Methode von Object ist. Das

Problem kann ein Compiler auf zwei Arten lösen. Zunächst kann der Aufruf an das unbe-

kannte Objekt, das ja zur Laufzeit üblicherweise etwas anderes als String ist, über Reflection

gelöst werden. Da Reflection-Aufrufe aber nicht so performant sind wie richtige Methoden-

aufrufe, ist diese Lösung nicht so effizient. Eine zweite Lösung besteht in der Einführung

einer Schnittstelle, die genau die fehlenden Operationen deklariert:

interface I { int length(); }

I isEmpty( I s ) { return s == null || s.length() == 0; }

Ja, das geht – irgendwie. Das ist performanter als Reflection, aber auf diese Weise kommen

eine riesige Anzahl neuer Schnittstellen bzw. Klassen in die JVM, deren Behandlung recht

speicherintensiv ist. Außerdem können die Deklarationen von Methoden in Skriptsprachen

auch außerhalb von Klassen vorkommen, sodass für Java ein Fake-Methoden-Empfänger er-

zeugt werden müsste.


1.3 Neue Pakete und Klassen

63

1invokedynamic und Hilfsklassen

Um die sonderbare Methodendeklaration in Java performant umzusetzen, hat der JSR-292,

»Supporting Dynamically Typed Languages on the Java Platform«, den neuen Bytecode

invokedynamic zusammen mit einigen Hilfsklassen im Paket java.lang.invoke definiert. Der

neue Bytecode muss von einer Java 7-JVM unterstützt werden und wird von dynamischen

Skriptsprachen generiert, um die Aufrufe schnell von der JVM ausführen zu lassen. Normale

Entwickler werden den neuen Bytecode kaum brauchen, und im Quellcode ist er eh nicht

sichtbar.

Weitere Details und ein Programmbeispiel finden Leser unter http://java.sun.com/developer/

technicalArticles/DynTypeLang/. Sehr tiefe Detailinformationen liefert http://blogs.oracle.

com/jrose/resource/pres/200910-VMIL.pdf.

1.3 Neue Pakete und Klassen

Auf einige Neuerungen geht das Buch noch gezielter ein, etwa auf NIO.2 in Kapitel 5, »Dateien,

Verzeichnisse und Dateizugriffe«, oder auf die API für nebenläufige Programmierung, das

Fork-und-Join-Framework in Kapitel 2, »Threads und nebenläufige Programmierung«. Da die

APIs alle bibliotheksbezogen sind und dieses Buch die Java-Bibliothek in den Mittelpunkt

rückt, sind die Änderungen zu Java 7 dort vermerkt – mal ist es hier eine Methode, mal da;

große Überraschungen gibt es nicht.

An Typen im Paket java.lang gibt es ebenfalls kleine Änderungen. Java 7 unterstützt Unicode

6, was bedeutet, dass Java 7 Konstanten für die neuen Zeichenbereiche einführt und Metho-

den wie isLetter() aktualisiert hat, um auch dieses neue Zeichen korrekt zu berücksichtigen.

Die Klasse Character hat für die Unicode-Blöcke Konstanten bekommen. Über den Unicode 6-

Standard gibt http://unicode.org/versions/Unicode6.0.0/ Auskunft. Für »normale« Entwickler

ist das wenig relevant. Für die üblichen Unicode-Kodierungen gibt es in StandardCharsets Kon-

stanten.

1.3.1 Weitere Änderungen

Im GIU-Bereich, das heißt bei AWT und Swing, haben sich Kleinigkeiten geändert. Fenster

können auch nicht eckig und transparent sein – das ging zwar auch schon seit einer späteren

Java 6-Version, aber nur inoffiziell – das heißt, mit keiner Klasse im »erlaubten« Paket. Zwar

war ein Datumsauswahldialog für Java 7 in Planung, aber er verschiebt sich wohl noch bis

Java 8.


1 Neues in Java 7

64

Neuerungen in Kürze:

Þ Alle Wrapper-Klassen bieten eine statische compare()-Methode, die zwei primitive Werte

vergleicht. Die Methode ist eine Alternative zur compareTo()-Methode, die alle Wrapper-

Klassen bieten, die Comparable implementieren.

Þ Der ProcessBuilder ist eine Klasse in Java, um externe Prozesse aufzubauen. Neu sind

Methoden, um die Datenströme umzuleiten.

Þ Klassenlader lassen sich mit close() wieder schließen.

Þ kleine Änderungen an den Kalender-Klassen

Þ Unterstützung für SCTP (Stream Control Transmission Protocol) und SDP (Sockets Direct

Protocol). Das Tutorial gibt unter http://download.oracle.com/javase/tutorial/sdp/sockets/

eine Einführung in die sehr spezielle Technologie.

Þ neue Klassen für asynchrone Datei- und Socket-Operationen

Þ Neu in Java 7 ist JDBC 4.1, was nicht nur auf AutoCloseable eingeht, sondern auch Standard-

Implementierungen für sogenannte Row-Sets mitbringt. Weiterhin können die JDBC-Klas-

sen Pseudo-Spalten nutzen, und bei einer Connection lässt sich das Datenbank-Schema

erfragen und setzen.


1227

18

Kapitel 18

Reflection und Annotationen

»Aber wofür soll das gut sein?«

– Advanced Computing Systems Division von IBM zum Microchip, 1968

Das Reflection-Modell erlaubt es uns, Klassen und Objekte, die zur Laufzeit von der JVM im

Speicher gehalten werden, zu untersuchen und in begrenztem Umfang zu modifizieren. Das

Konzept der Reflection (oder auch Introspektion) ist besonders bei JavaBeans oder Hilfspro-

grammen zum Debuggen oder bei GUI-Buildern interessant. Diese Programme heißen auch

Metaprogramme, da sie auf den Klassen und Objekten anderer Programme operieren. Reflec-

tion fällt daher auch in die Schlagwortkategorie »Meta-Programming«.

18.1 Metadaten

Ein Metadatum ist eine Information über eine Information. In Java beschreibt ein Class-

Objekt, was Typen wie Klassen so »können«, also welche Konstruktoren und Methoden sie

haben, welche Attribute sie besitzen und wie die Erweiterungsbeziehungen sind.

18.1.1 Metadaten durch JavaDoc-Tags

Seit den ersten Java-Versionen gibt es die JavaDoc-Tags, die besondere Metadaten darstellen.

So ist im folgenden Beispiel die Methode veraltet, weil das JavaDoc-Tag @deprecated gesetzt ist:

/**

* Sets the day of the month of this <tt>Date</tt>object to the specified value. ....

* @deprecated As of JDK version 1.1, replaced by ....

*/

@Deprecated

public void setDate( int date ) {

getCalendarDate().setDayOfMonth( date );

}



1228

In diesem Fall gilt das JavaDoc-Tag für genau eine Methode, die dann als annotiert gilt. Die Be-

schreibungen können aber noch weiter gehen und müssen nicht nur auf Methodenebene

bleiben. So annotiert das Tag @author den Autor und damit gleich eine ganze Klasse oder

Schnittstelle.

Um die in Kommentaren eingesetzten JavaDoc-Tags muss sich der Java-Compiler nicht küm-

mern, obwohl er @deprecated eine Ausnahme zugesteht. Es ist Aufgabe des externen Pro-

gramms javadoc – eines sogenannten Doclets –, aus diesen Kommentaren etwas zu machen,

etwa eine Sammlung von verknüpften HTML-Dokumenten.

18.2 Metadaten der Klassen mit dem Class-Objekt

Angenommen, wir wollen einen Klassen-Browser schreiben. Dieser soll alle zum laufenden

Programm gehörenden Klassen und darüber hinaus weitere Informationen anzeigen, wie

etwa Variablenbelegung, deklarierte Methoden, Konstruktoren und Informationen über die

Vererbungshierarchie. Dafür benötigen wir die Bibliotheksklasse Class. Exemplare der Klasse

Class sind Objekte, die entweder eine Java-Klasse oder Java-Schnittstelle repräsentieren (dass

auch Schnittstellen durch Class-Objekte repräsentiert werden, wird im Folgenden nicht mehr

ausführlich unterschieden).

In diesem Punkt unterscheidet sich Java von vielen herkömmlichen Programmiersprachen,

da sich Eigenschaften von Klassen vom gerade laufenden Programm mittels der Class-Ob-

jekte abfragen lassen. Bei den Exemplaren von Class handelt es sich um eine eingeschränkte

Form von Meta-Objekten1 – die Beschreibung einer Java-Klasse, die aber nur ausgewählte

Informationen preisgibt. Neben normalen Klassen werden auch Schnittstellen durch je ein

Class-Objekt repräsentiert.

18.2.1 An ein Class-Objekt kommen

Zunächst müssen wir für eine bestimmte Klasse das zugehörige Class-Objekt in Erfahrung

bringen. Class-Objekte selbst kann nur die JVM erzeugen. Wir können das nicht (die Objekte

sind immutable, und der Konstruktor ist privat).2 Um einen Verweis auf ein Class-Objekt zu

bekommen, bieten sich folgende Lösungen an:

1 Echte Metaklassen wären Klassen, deren jeweils einziges Exemplar die normale Java-Klasse ist. Dann wären

etwa die normalen Klassenvariablen in Wahrheit Objektvariablen in der Metaklasse.

2 Und der JavaDoc lautet: »Constructor. Only the Java Virtual Machine creates Class objects.«



1229

18

Þ Ist ein Exemplar der Klasse verfügbar, rufen wir die getClass()-Methode des Objekts auf

und erhalten das Class-Exemplar der zugehörigen Klasse.

Þ Jede Klasse enthält eine Klassenvariable mit dem Namen .class vom Typ Class, die auf das

zugehörige Class-Exemplar verweist.

Þ Auch auf primitiven Datentypen ist das Ende .class erlaubt. Das gleiche Class-Objekt lie-

fert die statische Variable TYPE der Wrapper-Klassen. Damit ist int.class == Integer.TYPE.

Þ Die Klassenmethode Class.forName(String) kann eine Klasse erfragen, und wir erhalten das

zugehörige Class-Exemplar als Ergebnis. Ist die Klasse noch nicht geladen, sucht und bin-

det forName() die Klasse ein. Weil das Suchen schiefgehen kann, ist eine ClassNotFoundExcep-

tion möglich.

Þ Haben wir bereits ein Class-Objekt, sind aber nicht an ihm, sondern an seinen Vorfahren

interessiert, so können wir einfach mit getSuperclass() ein Class-Objekt für die Oberklasse

erhalten.

Das folgende Beispiel zeigt drei Möglichkeiten auf, um an ein Class-Objekt für java.util.Date

heranzukommen:

Listing 18.1: com/tutego/insel/meta/GetClassObject.java, main()

Class<Date> c1 = java.util.Date.class;

System.out.println( c1 ); // class java.util.Date

Class<?> c2 = new java.util.Date().getClass();

// oder Class<? extends Date> c2 = ...


try {

Class<?> c3 = Class.forName( "java.util.Date" );


}

catch ( ClassNotFoundException e ) { e.printStackTrace(); }

Die Variante mit forName() ist sinnvoll, wenn der Klassenname bei der Übersetzung des Pro-

gramms noch nicht feststand. Sonst ist die vorhergehende Technik eingängiger, und der

Compiler kann prüfen, ob es den Typ gibt.

Beispiel

Klassenobjekte für primitive Elemente liefert forName() nicht! Die beiden Anweisungen

Class.forName("boolean") und Class.forName(boolean.class.getName()) führen zu einer

ClassNotFoundException.



1230

Þ final Class<? extends Object> getClass()

Liefert zur Laufzeit das Class-Exemplar, das die Klasse des Objekts repräsentiert.

Þ static Class<?> forName(String className) throws ClassNotFoundException

Liefert das Class-Exemplar für die Klasse oder Schnittstelle mit dem angegebenen voll qua-

lifizierten Namen. Falls sie bisher noch nicht vom Programm benötigt wurde, sucht und

lädt der Klassenlader die Klasse. Die Methode liefert niemals null zurück. Falls die Klasse

nicht geladen und eingebunden werden konnte, gibt es eine ClassNotFoundException. Eine al-

ternative Methode forName() ermöglicht auch das Laden mit einem gewünschten Klassenla-

der. Der Klassenname muss immer voll qualifiziert sein.

ClassNotFoundException und NoClassDefFoundError *

Eine ClassNotFoundException lösen die Methoden forName() aus Class und loadClass() bzw.

findSystemClass() aus ClassLoader immer dann aus, wenn der Klassenlader die Klasse nach

ihrem Klassennamen nicht finden kann.

Neben der Exception-Klasse gibt es ein NoClassDefFoundError – ein harter LinkageError, den das

System immer dann auslöst, wenn die JVM eine im Bytecode referenzierte Klasse nicht laden

kann. Nehmen wir zum Beispiel eine Anweisung wie new MeineKlasse(). Führt die JVM diese

Anweisung aus, versucht sie den Bytecode von MeineKlasse zu laden. Ist der Bytecode für

MeineKlasse nach dem Compilieren entfernt worden, löst die JVM durch den nicht geglückten

Ladeversuch den NoClassDefFoundError aus. Auch tritt der Fehler auf, wenn beim Laden des

Bytecodes die Klasse MeineKlasse zwar gefunden wurde, aber MeineKlasse einen statischen Ini-

tialisierungsblock besitzt, der wiederum eine Klasse referenziert, für die keine Klassendatei

vorhanden ist.

Während ClassNotFoundException häufiger vorkommt als NoClassDefFoundError, ist es im Allge-

meinen ein Indiz dafür, dass ein Java-Archiv im Klassenpfad fehlt.

Umbenennungen der Klassennamen durch den Obfuscator

Dass der Compiler automatisch Bytecode gemäß dieses veränderten Quellcodes erzeugt, führt

nur dann zu unerwarteten Problemen, wenn wir einen Obfuscator über den Programmtext

laufen lassen, der nachträglich den Bytecode modifiziert und damit die Bedeutung des Pro-

gramms beziehungsweise des Bytecodes verschleiert und dabei Klassen umbenennt. Offen-

sichtlich darf ein Obfuscator Klassen, deren Class-Exemplare abgefragt werden, nicht umbe-

class java.lang.Object

final class java.lang.Class<T>

implements Serializable, GenericDeclaration, Type, AnnotatedElement



1231

18

nennen; oder der Obfuscator müsste die entsprechenden Zeichenketten ebenfalls korrekt

ersetzen (aber natürlich nicht alle Zeichenketten, die zufällig mit Namen von Klassen über-

einstimmen).

18.2.2 Was das Class-Objekt beschreibt *

Ein Class-Exemplar kann eine Schnittstelle, eine Klasse, einen primitiven Datentyp oder auch

einen Array-Typ beschreiben. Dies lässt sich durch die drei Methoden isInterface(), isPrimi-

tive() und isArray() herausfinden. Wenn keine der drei Methoden für ein Class-Exemplar

true liefert, repräsentiert das Objekt eine gewöhnliche Klasse.

Dass es auch Class-Exemplare gibt, die die primitiven Datentypen von Java beschreiben, er-

staunt zunächst. Damit ist es jedoch möglich, die Parameter- und Ergebnistypen beliebiger

Java-Methoden einheitlich durch Class-Exemplare zu beschreiben. Dazu kodieren jede der

acht Wrapper-Klassen, die zu den Datentypen boolean, byte, char, short, int, long, float und

double gehören, und die spezielle Klasse für den Typ void eine Konstante TYPE. Benötigen wir

ein Class-Objekt für den primitiven Typ int, so greifen wir mit Integer.TYPE (oder alternativ

mit int.class) darauf zu. Alle Class-Exemplare für primitive Datentypen werden automatisch

von der JVM erzeugt. Die Methode isPrimitive() gibt genau für diese neun besonderen Class-

Exemplare true zurück, sodass sie von Repräsentanten für echte Klassen unterschieden wer-

den können.

Das folgende Programmstück testet die Attribute von Class-Objekten systematisch durch. Wir

benutzen die Methode getName(), um den Namen des Class-Objekts auszugeben. Im nächsten

Unterkapitel mehr dazu. Das Class-Objekt für Felder setzt sich aus dem Basistyp und Paaren

von eckigen Klammern zusammen, etwa double[][].class.

Listing 18.2: com/tutego/insel/meta/CheckClassType.java, CheckClassType

class CheckClassType

{


{

checkClassType( Observer.class );

checkClassType( Observable.class );

checkClassType( (new int[2][3][4]).getClass() );

Hinweis

Obwohl void kein Typ ist, meldet isPrimitive() dies:

System.out.println( void.class.isPrimitive() ); // true



1232

checkClassType( Integer.TYPE );

}

static void checkClassType( Class<?> c )

{

if ( c.isArray() )

System.out.println( c.getName() + " ist ein Feld." );

else if ( c.isPrimitive() )

System.out.println( c + " ist ein primitiver Typ.");

else if ( c.isInterface() )

System.out.println( c.getName() + " ist ein Interface." );

else

System.out.println( c.getName() + " ist eine Klasse." );

}

}

Die Ausgabe des Programms ist nun:

java.util.Observer ist ein Interface.

java.util.Observable ist eine Klasse.

[[[I ist ein Feld.

int ist ein primitiver Typ.

Þ boolean isInterface()

Liefert true, wenn das Class-Objekt eine Schnittstelle beschreibt.

Þ boolean isArray()

Liefert true, wenn das Class-Objekt einen Array-Typ beschreibt.

Þ boolean isPrimitive()

Testet, ob das Class-Objekt einen primitiven Datentyp beschreibt.

Komponententyp bei Feldern

Die Methode getComponentType() liefert bei Feldern den Typ der Elemente als Class-Objekt.

Steht das Class-Objekt für kein Feld, ist die Methodenrückgabe null.





1233

18

System.out.println( double[].class.getComponentType() ); // double

System.out.println( double[][].class.getComponentType() ); // class [D

System.out.println( double.class.getComponentType() ); // null

18.2.3 Der Name der Klasse

Liegt zu einer Klasse das Class-Objekt vor, so können wir zur Laufzeit ihren voll qualifizierten

Namen über die Methode getName() ausgeben. Da jeder Typ über einen Namen verfügt, führt

diese Methode also jedes Mal zum Ziel:

Listing 18.3: SampleName.java

String n1 = new java.util.Date().getClass().getName();

System.out.println( n1 ); // java.util.Date

String n2 = java.util.RandomAccess.class.getName();

System.out.println( n2 ); // java.util.RandomAccess

String n3 = Deprecated.class.getName();

System.out.println( n3 ); // java.lang.Deprecated

String n4 = Thread.State.class.getName();

System.out.println( n4 ); // java.lang.Thread$State

Kodierung von Feldern *

Schwieriger ist die Kodierung bei Array-Typen, die ja eine besondere Form von Klassen sind.

getName() kodiert sie mit einer führenden »[«. Jede Klammer steht dabei für eine Dimension

des Array-Typs. Nach den Klammern folgt in einer kodierten Form der Typ der Array-Ele-

mente. So liefert

System.out.println( int[][][].class.getName() ); // [[[I

System.out.println( (new int[2][3][4]).getClass().getName() ); // [[[I

den String »[[[I«, also einen dreidimensionalen Array-Typ mit Array-Elementen vom primiti-

ven Typ int. Der Elementtyp ist wie folgt kodiert:

Kürzel Datentyp

B Byte

C Char

D Double

Tabelle 18.1: Kodierung der Elementtypen



1234

Nimmt das Array Objektreferenzen auf, wird deren Typ in der Form »LKlassenname;« kodiert.

So liefert (new Object[3]).getClass().getName() den String [Ljava.lang.Object;. Der Klassen-

beziehungsweise Schnittstellenname ist wie üblich voll qualifiziert.

Der String ist auch für Class.forName() von Bedeutung. Im Fall von Arrays liefert die Methode

ein Class-Objekt für den Elementtyp. Die ersten Versuche, ein Class-Objekt für Felder zu be-

ziehen, scheitern an einer ClassNotFoundException:

Class.forName( "String[]" );

Class.forName( "java.lang.String[]" );

In der ersten Anweisung ist der Klassenname nicht voll qualifiziert, und auch in der zweiten

Anweisung ist der String falsch aufgebaut.

out.println( Class.forName("[Ljava.lang.String;") ); // class [Ljava.lang.String;

Steht die Frage an, ob ein Class-Objekt für ein Feld von Objekten steht oder für ein primitives

Feld, lässt sich das Ergebnis von getName() auswerten:

public static boolean isObjectArray( Class clazz )

{

if ( clazz != null && clazz.isArray() )

return clazz.getName().startsWith( "[L" );

return false;

}

So liefert:

System.out.println( isObjectArray( Object[].class ) ); // true

System.out.println( isObjectArray( int[].class ) ); // false

System.out.println( isObjectArray( Object.class ) ); // false

F Float

I Int

J Long

LElementtyp; Klasse oder Schnittstelle

S Short

Z Boolean

Kürzel Datentyp

Tabelle 18.1: Kodierung der Elementtypen (Forts.)



1235

18

toString()

Auch eine zweite Methode ist uns bekannt, um Class-Exemplare für Menschen lesbar auszu-

geben: die Methode toString(). Sie basiert im Kern auf getName(), fügt aber zusätzlich die Art

der repräsentierten Klasse (normale Klasse, Schnittstelle oder primitiver Datentyp) ein:

public String toString() {

return (isInterface() ? "interface " :

(isPrimitive() ? "" : "class ")) + getName();

}

Þ String getName()

Liefert für ein Class-Exemplar als String den voll qualifizierten Namen der repräsentierten

Klasse oder Schnittstelle beziehungsweise des repräsentierten Array-Typs oder des primiti-

ven Datentyps.

Þ String toString()

Liefert eine für Menschen lesbare String-Repräsentation des Class-Objekts.

18.2.4 instanceof mit Class-Objekten *

Der binäre Operator instanceof testet, ob ein Objekt Exemplar einer Klasse oder der Ober-

klasse ist. Wenn das Ergebnis wahr ist, lässt sich das Objekt unter dem gegebenen Typ anspre-

chen, ist also zuweisungskompatibel. Der rechte Operator bei instanceof, der Typname, muss

jedoch immer zur Übersetzungszeit bekannt sein und kann nicht dynamisch, etwa durch

einen String, festgelegt werden.

Ist der Typname zur Compilierzeit vielleicht unbekannt, kann das Class-Objekt helfen. Die

Methode isInstance(Object) ist sozusagen ein dynamisches instanceof. Gilt mit dem Operator

object instanceof ReferenceType

so heißt das mit der Methode:

ReferenceType-Class-Objekt.isInstance( object )

Gewöhnungsbedürftig ist sicherlich die Tatsache, dass bei der Methode isInstance() die bei-

den Operanden umgedreht sind. Dazu ein paar Beispiele:





1236

Listing 18.4: IsAssignableFrom.java, main()

Component b = new JLabel();

out.println( b instanceof JLabel ); // true

out.println( JLabel.class.isInstance( b ) ); // true

out.println( Object.class.isInstance( b ) ); // true

out.println( Class.forName("java.awt.Component").isInstance( b ) ); // true

out.println( String.class.isInstance( b ) ); // false

Die Methode isInstance(object) ist natürlich ein wenig dadurch eingeschränkt, dass es

immer ein Test-Objekt geben muss. Die Frage etwa, ob das Class-Objekt der Schnittstelle Pub-

licKey eine »Ist-eine-Art-von-Serializable« ist, kann isInstance(object) nicht beantworten,

denn dann müsste es vorher ein Objekt geben. Für diesen Fall bietet das Class-Objekt noch

eine zweite Methode, isAssignableFrom(Class):

Class<?> clazz = Serializable.class;

out.println( clazz.isAssignableFrom( String.class ) ); // true

out.println( clazz.isAssignableFrom( Thread.class ) ); // false

out.println( clazz.isAssignableFrom( PublicKey.class ) ); // true

Solange der Typname zur Übersetzungszeit bekannt ist, ist instanceof immer noch die beste

Lösung. Doch wenn die Klasse nur durch ein Class-Objekt gegeben ist, bleibt immer noch

isAssignableFrom(). Die Methode clazz.isInstance(obj) ist sozusagen eine Kurzform von

clazz.isAssignableFrom(obj.getClass()).

18.2.5 Oberklassen finden *

Das Class-Exemplar für eine Klasse gibt Zugriff auf die Oberklasse, die Sichtbarkeitsstufe und

weitere Informationen. Die Oberklasse ermittelt getSuperclass(). Die Methode gibt null zu-

rück, falls das Class-Objekt eine Schnittstelle repräsentiert oder wir schon am oberen Ende

der Hierarchie sind, also bei dem Class-Objekt für die Wurzelklasse Object. Das folgende Pro-

gramm findet alle Oberklassen einer Klasse durch den wiederholten Aufruf der Methode get-

Superclass():

Listing 18.5: com/tutego/insel/meta/ShowSuperclasses.java

Class<?> subclass = javax.swing.JButton.class;

Class<?> superclass = subclass.getSuperclass();

while ( superclass != null )

{

String className = superclass.getName();



1237

18

System.out.println( className );

subclass = superclass;

superclass = subclass.getSuperclass();

}

Wahrscheinlich wäre eine rekursive Variante noch eleganter, aber darauf kommt es jetzt

nicht an.

javax.swing.AbstractButton

javax.swing.JComponent

java.awt.Container

java.awt.Component

java.lang.Object

Þ Class<? super T> getSuperclass()

Liefert ein Class-Exemplar für die Oberklasse der Klasse, die durch das aufrufende Class-Ob-

jekt repräsentiert wird. Falls wir schon oben auf der Vererbungshierarchie bei Object sind

oder nach der Oberklasse einer Schnittstelle fragen, liefert die Methode null.

18.2.6 Implementierte Interfaces einer Klasse oder eines Interfaces *

Klassen stehen zum einen in einer Vererbungsbeziehung zu einer Oberklasse und können

zum anderen mehrere Schnittstellen implementieren. Schnittstellen können ihrerseits wie-

derum andere Schnittstellen erweitern. Bei einer Klassendeklaration folgt direkt hinter dem

Schlüsselwort implements eine Auflistung der implementierten Schnittstellen. So implemen-

tiert die Klasse RandomAccessFile die Schnittstellen DataOutput, DataInput und Closeable:

public class RandomAccessFile implements DataOutput, DataInput, Closeable

Um zu einem vorhandenen Class-Objekt die Schnittstellen aufzulisten, rufen wir getInter-

faces() auf, die uns ein Array von Class-Objekten liefert. Von hier aus kennen wir den Weg

zum Namen: Der Aufruf von getName() liefert den String für den Namen der Schnittstelle.



Beispiel

Gib die implementierten Schnittstellen von RandomAccessFile aus:

Listing 18.6: com/tutego/insel/meta/ShowInterfaces.java, main()

for ( Class<?> theInterface: java.io.RandomAccessFile.class.getInterfaces() )

System.out.println( theInterface.getName() );



1238

18.2.7 Modifizierer und die Klasse Modifier *

Eine Klassendeklaration kann Modifizierer enthalten, also Schlüsselwörter, die zum Beispiel

die Sichtbarkeit bestimmen. Unter anderem sind dies public, protected, private und final. Sie

stehen etwa in der Klassendeklaration vor dem Schlüsselwort class oder auch vor Methoden.

Die Modifizierer können auch kombiniert werden: So ist die Klasse Class selbst public final.

Die Methode getModifiers() liefert im Rückgabewert die Modifizierer, verschlüsselt als Ganz-

zahl:

System.out.println( Modifier.class.getModifiers() ); // 1

System.out.println( Modifier.toString(Modifier.class.getModifiers()) ); // public

Þ int getModifiers()

Liefert die Modifizierer für eine Klasse oder eine Schnittstelle.

Dekodieren der Zahlrepräsentationen durch die Klasse Modifier

Damit wir uns bei der Entschlüsselung nicht mit magischen Zahlenwerten der JVM herum-

schlagen müssen, gibt es in der Klasse java.lang.reflect.Modifier einige statische Methoden,

die diese Ganzzahl testen und aufbauen. Zudem werden Konstanten deklariert (wie Modi-

fier.PUBLIC), mit denen dieser Integerwert verglichen werden kann. Da die Ganzzahl potenzi-

ell eine Kombination mehrerer Modifizierer kodiert, ist die gezielte Abfrage allerdings mit

den statischen isXXX()-Methoden einfacher. Obwohl eine Klasse nicht transient, synchronized,

nativ sein kann, listen wir hier alle statischen Methoden auf, da wir diese Modifizierer später

auch für die Untersuchung von Methoden und Objekt- beziehungsweise Klassenvariablen per

Reflection einsetzen. Jede dieser Testmethoden liefert true, wenn der gefragte Modifizierer in

dem kodierten Ganzzahlwert enthalten ist. Alle Methoden sind static und liefern ein boolean-

Ergebnis, außer toString().

Die Ausgabe ist:

java.io.DataOutput

java.io.DataInput

java.io.Closeable



Beispiel (Forts.)



1239

18

Þ static boolean isAbstract(int mod)

Þ static boolean isFinal(int mod)

Þ static boolean isInterface(int mod)

Þ static boolean isNative(int mod)

Þ static boolean isPrivate(int mod)

Þ static boolean isProtected(int mod)

Þ static boolean isPublic(int mod)

Þ static boolean isStatic(int mod)

Þ static boolean isSynchronized(int mod)

Þ static boolean isTransient(int mod)

Þ static boolean isVolatile(int mod)

Betrachten wir die toString()-Methode der Klasse Modifier. Dort finden wir eine Liste aller

möglichen Modifizierer mit den Konstanten:

public static String toString( int mod )

{

StringBuffer sb = new StringBuffer();

int len;

if ((mod & PUBLIC) != 0) sb.append("public ");

if ((mod & PRIVATE) != 0) sb.append("private ");

if ((mod & PROTECTED) != 0) sb.append("protected ");

/* Canonical order */

if ((mod & ABSTRACT) != 0) sb.append("abstract ");

if ((mod & STATIC) != 0) sb.append("static ");

if ((mod & FINAL) != 0) sb.append("final ");

if ((mod & TRANSIENT) != 0) sb.append("transient ");

if ((mod & VOLATILE) != 0) sb.append("volatile ");

if ((mod & NATIVE) != 0) sb.append("native ");

if ((mod & SYNCHRONIZED) != 0) sb.append("synchronized ");

if ((mod & INTERFACE) != 0) sb.append("interface ");

if ((len = sb.length()) > 0)/* trim trailing space */

return sb.toString().substring(0, len-1);

return "";

}

class java.lang.reflect.Modifier



1240

Des Weiteren gibt es seit Java 7 xxxModifier()-Methoden, die über ein int aussagen, welche

Modifizierer an einem bestimmten Element erlaubt sind:

Þ static int classModifiers()

Þ static int constructorModifiers()

Þ static int fieldModifiers()

Þ static int interfaceModifiers()

Þ static int methodModifiers()

Liefert ein int, das alle Modifizierer kodiert, die an Klassen/Konstruktoren/Feldern/Schnitt-

stellen/Methoden erlaubt sind. So liefert constructorModifiers() zum Beispiel Modifier.PUB-

LIC | Modifier.PROTECTED | Modifier.PRIVATE.

18.2.8 Die Arbeit auf dem Feld *

Die Utility-Klasse java.lang.reflect.Array stellt statische Methoden bereit, um auf Array-Ob-

jekten generisch zu arbeiten. Elemente lassen sich erfragen und setzen und auch Arrays mit

einem gewünschten Typ anlegen:

Object array = Array.newInstance( int.class, 20 );

System.out.println( Array.getLength(array) ); // 20

Array.setInt( array, 0, –1 );

System.out.println( Array.getInt(array, 0) ); // –1

Bei newInstance() ist der Typ int.class und nicht int[].class!

Eine allgemeine statische Array-Methode set() und get() arbeitet für Objekte, wobei auch

Wrapper für primitive Felder verwendet werden können:

Array.set( array, 0, Integer.valueOf(-1) );

System.out.println( Array.get(array, 0) ); // –1

class java.lang.reflect.Modifier

Hinweis

Schnittstellen, wie java.io.Serializable, tragen den Modifier abstract.

int modifier = Serializable.class.getModifiers();

out.println( modifier ); // 1537

out.println( Modifier.toString(modifier) ); // public abstract interface


18.3 Attribute, Methoden und Konstruktoren

1241

18

Für mehrdimensionale Felder lässt sich bei newInstance() ein Feld von Größen angeben:

Object array = Array.newInstance( int.class, new int[]{ 2, 2 } );

((int[][])array)[0][0] = 1;

((int[][])array)[1][1] = 1;

System.out.println( Arrays.deepToString( (int[][])array ) ); // [[1, 0], [0, 1]]


Ein Class-Objekt bietet nicht nur Zugriff auf Oberklassen, Sichtbarkeiten, Modifizierer und

Schnittstellen, sondern natürlich auch auf die Variablen, Methoden und Konstruktoren einer

Klasse oder Schnittstelle. Daher kooperiert Class mit fünf weiteren Typen:

Þ Constructor: Steht für die Konstruktoren einer Klasse. So gibt zum Beispiel getConstruc-

tors() ein Feld von Konstruktoren zurück.

Þ Field: Ermöglicht den Zugriff auf die Objekt- und Klassenvariablen, um später Belegungen

lesen und Werte verändern zu können.

Þ Method: Steht für die Methoden einer Klasse beziehungsweise Operationen der Schnittstel-

len. So liefert getDeclaredMethods() die Methoden, die dann später mit invoke() aufgerufen

werden können.

Þ Annotation: Repräsentiert die Annotationen, die an der Klasse/Schnittstelle festgemacht

sind. So liefert zum Beispiel die Class-Methode getAnnotations() die festgemachten Anno-

tationen.

Þ Package: getPackage() liefert ein Package-Objekt für die Klasse, die eine Versionsnummer be-

inhaltet, wenn diese im Manifest gesetzt wurde.

Weiterhin gibt es folgende allgemeine Implementierungsbeziehungen:

Þ Die Klassen Class, Method, Field und Constructor implementieren eine Schnittstelle Member,

um etwa den Namen, die Modifizierer oder die deklarierende Klasse zu erfragen.

Þ Die Klassen Class, Constructor und Method implementieren die Schnittstelle GenericDeclara-

tion, da sie generische Typvariablen deklarieren können.

Þ Die Klassen Constructor, Field und Method implementieren AccessibleObject, um die Sicht-

barkeit auszuschalten.

Þ Class, Constructor, Field, Method und Package implementieren AnnotatedElement, weil sie An-

notationen tragen können.



1242

Reflections-Exceptions und ReflectiveOperationException

Ist etwas so dynamisch wie Reflection, kann eine Menge schiefgehen. Nahezu alle Methoden

zum Zugriff auf Laufzeitinformationen lösen daher die eine oder andere Ausnahme aus. An

dieser Stelle sollen die zentralen Ausnahmen kurz vorgestellt werden. Alle stammen aus dem

Paket java.lang:

Þ NoSuchFieldException und NoSuchMethodException: Das Attribut oder die Methode wird er-

fragt, aber existiert nicht.

Þ ClassNotFoundException: Der Klassenlader versucht, die Klasse zu laden, konnte sie aber

nicht bekommen. Wird ausgelöst etwa von Class.forName(String).

Þ InstantiationException: Der Versuch, ein Exemplar aufzubauen, scheitert, etwa wenn ver-

sucht wird, eine abstrakte Klasse zu instanziieren oder den Standardkonstruktor aufzuru-

fen, die Klasse aber nur parametrisierte Konstruktoren deklariert.

Þ IllegalAccessException: Die Sichtbarkeit ist zum Beispiel private, sodass von außen ein At-

tribut nicht erfragt, eine Methode nicht aufgerufen oder ein Exemplar nicht aufgebaut

werden kann.

Þ InvocationTargetException: Eine Methode oder ein Konstruktor können eine Exception aus-

lösen. Die InvocationTargetException packt diese Exception ein.

Abbildung 18.1: UML-Diagramm für ReflectiveOperationException

Einige Methoden lösen weniger Ausnahmen im Fehlerfall aus, einige mehr. newInstance()

führt gleich vier Ausnahmen am throws auf. Oftmals führt das zu großen catch-Blöcken mit

dupliziertem Code. Ab Java 7 gibt es daher für die sechs Ausnahmen eine Oberklasse Reflec-

tiveOperationException, sodass bei identischer Behandlung alles vom Typ ReflectiveOpera-

tionException gecatcht werden kann:

java.lang.Exception

+ ReflectiveOperationException()+ ReflectiveOperationException(message: String)+ ReflectiveOperationException(message: String, cause: Throwable)+ ReflectiveOperationException(cause: Throwable)

java.lang.ReflectiveOperationException

java.lang.reflect.InvocationTargetException

java.lang.InstantiationException

java.lang.NoSuchFieldException

java.lang.IllegalAccessException

java.lang.ClassNotFoundException

java.lang.NoSuchMethodException



1243

18

Þ ClassNotFoundException extends ReflectiveOperationException

Þ IllegalAccessException extends ReflectiveOperationException

Þ InstantiationException extends ReflectiveOperationException

Þ InvocationTargetException extends ReflectiveOperationException

Þ NoSuchFieldException extends ReflectiveOperationException

Þ NoSuchMethodException extends ReflectiveOperationException

ReflectiveOperationException selbst ist eine Unterklasse von Exception und nicht von Runtime-

Exception. Sie muss daher explizit behandelt werden, genauso wie die anderen Ausnahmen

vorher.

18.3.1 Reflections – Gespür für die Attribute einer Klasse

Besonders bei Klassen-Browsern oder GUI-Buildern ist es interessant, auf die Variablen eines

Objekts zuzugreifen, das heißt, ihre Werte auszulesen und zu verändern. Damit wir an be-

schreibende Objekte für die in einer Klasse deklarierten beziehungsweise aus Oberklassen ge-

erbten Variablen gelangen, rufen wir die Methode getFields() für das Class-Objekt der Klasse

auf, die uns interessiert. Als Ergebnis erhalten wir ein Array von Field-Objekten. Jeder Array-

Eintrag beschreibt eine Objekt- oder Klassenvariable, auf die wir zugreifen dürfen. Nur auf

öffentliche, also public-Elemente, haben wir per (gewöhnlicher) Reflection Zugriff (auf eine

privilegierte Reflection gehen wir hier nicht ein). Schnittstellen deklarieren ja bekanntlich

nur Konstanten. Somit ist der schreibende Zugriff, den wir später näher betrachten wollen,

nur auf in Klassen deklarierte Variablen beschränkt. Lesen ist natürlich bei Konstanten und

Variablen gleichermaßen erlaubt. Beim Zugriff auf die Attribute mittels getFields() müssen

wir aufpassen, dass wir uns keine SecurityException einfangen. Das kann uns aber bei vielen

Methoden passieren, und weil SecurityException eine RuntimeException ist, muss sie auch

nicht extra aufgefangen werden. In der Dokumentation ist sie daher nicht angegeben.

Um für SimpleDateFormat alle Objekt- und Klassenvariablen mit ihren Datentypen herauszu-

finden, lassen wir eine Schleife über das Field-Array laufen. Die Namen der Variablen finden

sich leicht mit getName(). Wir haben aber den zugehörigen Datentyp noch nicht. Dazu müssen

wir erst mit getType() ein Class-Objekt für den Typ ermitteln, und dann liefert uns getName()

eine String-Repräsentation des Typs:

Listing 18.7: com/tutego/insel/meta/ShowFields.java, main()

Class<?> c = java.text.SimpleDateFormat.class;

System.out.println( "class " + c.getName() + " {" );

for ( Field publicField : c.getFields() ) {

String fieldName = publicField.getName();



1244

String fieldType = publicField.getType().getName();

System.out.printf( " %s %s;%n", fieldType, fieldName );

}

System.out.println( "}" );

Dies ergibt die (gekürzte) Ausgabe:

class java.text.SimpleDateFormat {

int ERA_FIELD;

int YEAR_FIELD;

...

int SHORT;

int DEFAULT;

}

Þ Field[] getFields()

Liefert ein Array mit Field-Objekten. Die Einträge sind unsortiert. Das Array hat die Länge

0, wenn die Klasse beziehungsweise Schnittstelle keine öffentlichen Variablen deklariert

oder erbt. getFields() liefert automatisch auch Einträge für die aus Oberklassen bezie-

hungsweise Schnittstellen geerbten öffentlichen Variablen.

Þ Field getField(String name) throws NoSuchFieldException

Erfragt ein bestimmtes Feld.

Die Klasse Field implementiert im Übrigen das Interface Member und ist eine Erweiterung von

AccessibleObject. AccessibleObject ist die Basisklasse für Field-, Method- und Constructor-Ob-

jekte. Auch Method und Constructor implementieren das Interface Member, das zur Identifika-

tion über getName() oder getModifiers() dient. Zusätzlich liefert getDeclaringClass() das Class-

Objekt, das tatsächlich eine Variable oder Methode deklariert. Da geerbte Elemente in der Auf-

zählung mit auftauchen, ist dies der einzige Weg, um die Position der Deklaration in der Ver-

erbungshierarchie exakt zu bestimmen.

Mit dem Field-Objekt können wir vieles erfragen: den Namen des Attributs, den Datentyp

und auch wieder die deklarierten Modifizierer. Werfen wir einen Blick auf die toString()-

Methode der Klasse Field:

public String toString() {

int mod = getModifiers();

return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))

+ getTypeName(getType()) + " "





1245

18

+ getTypeName(getDeclaringClass()) + "."

+ getName());

}

Þ Class<?> getDeclaringClass()

Liefert das Class-Exemplar für die Klasse oder die Schnittstelle, in der die Variable deklariert

wurde. Diese Methode ist Teil der Schnittstelle Member.


Liefert die deklarierten Modifizierer für die Variable.

Þ String getName()

Liefert den Namen der Variable. Diese Methode ist Teil der Schnittstelle Member.

Þ Class<?> getType()

Liefert ein Class-Objekt, das dem Datentyp der Variable entspricht.


Liefert eine String-Repräsentation. Am Anfang stehen die Sichtbarkeitsmodifizierer (public,

protected oder private), und es folgen die weiteren Modifizierer (static, final, transient,

volatile). Dann kommt der Datentyp, gefolgt vom voll qualifizierten Namen der deklarie-

renden Klasse, und schließlich der Name der Variable.

Beispiel

Für die Schleife über die Field-Objekte von SimpleDateFormat und einen Aufruf von toString()

liefern die Zeilen

for ( Field publicField : c.getFields() )

System.out.println( " " + publicFields );

dann:

class java.text.SimpleDateFormat {

public static final int java.text.DateFormat.ERA_FIELD

public static final int java.text.DateFormat.YEAR_FIELD

...

public static final int java.text.DateFormat.SHORT

public static final int java.text.DateFormat.DEFAULT

}

final class java.lang.reflect.Field

extends AccessibleObject

implements Member



1246

Abbildung 18.2: UML-Diagramm mit den Unterklassen von Member

18.3.2 Methoden einer Klasse erfragen

Um herauszufinden, über welche Methoden eine Klasse verfügt, wenden wir eine ähnliche

Vorgehensweise an wie bei den Variablen: getMethods(). Diese Methode liefert ein Array mit

Method-Objekten. Über ein Method-Objekt lassen sich Methodenname, Ergebnistyp, Parameter-

typen, Modifizierer und eventuell resultierende Exceptions erfragen. Wir werden später se-

hen, dass sich die durch ein Method-Exemplar repräsentierte Methode über invoke() aufrufen

lässt.



1247

18

Þ Method[] getMethods()

Gibt ein Array von Method-Objekten zurück, die alle öffentlichen Methoden der Klasse/

Schnittstelle beschreiben. Geerbte Methoden werden mit in die Liste übernommen. Die Ele-

mente sind nicht sortiert, noch gibt es keine Reihenfolge. Die Länge des Arrays ist null,

wenn es keine öffentlichen Methoden gibt.

Þ Method getMethod(String name, Class... parameterTypes)

throws NoSuchMethodException

Liefert zu einem Methodennamen und einer Parameterliste das passende Method-Objekt

oder löst eine NoSuchMethodException aus. Besitzt die Methode keine Parameter – wie eine

übliche getXXX()-Methode –, ist das Argument null und wird wegen der Varargs auf Class[]

angepasst.

Nachdem wir nun mittels getMethods() ein Array von Method-Objekten erhalten haben, lassen

die Method-Objekte verschiedene Abfragen zu. So liefert getName() den Namen der Methode,

getReturnType() den Ergebnistyp, und getParameterTypes() erzeugt ein Array von Class-Objek-

ten, das die Typen der Methodenparameter widerspiegelt. Wir kennen dies schon von den

Attributen.

Wir wollen nun ein Programm betrachten, das alle Methoden und ihre Parametertypen sowie

Ausnahmen ausgibt:

Listing 18.8: com/tutego/insel/meta/ShowMethods.java

package com.tutego.insel.meta;

import java.lang.reflect.*;

class ShowMethods

{


{

showMethods( java.awt.Color.BLACK );

}

Hinweis

Auch wenn zwei Klassen die gleiche Methode besitzen, muss doch ein Method-Objekt immer

für jede Klasse erfragt werden. Method-Objekte sind immer mit dem Class-Objekt verbunden.





1248

static void showMethods( Object o )

{

for ( Method method : o.getClass().getMethods() )

{

String returnString = method.getReturnType().getName();

System.out.print( returnString + " " + method.getName() + "(" );

Class<?>[] parameterTypes = method.getParameterTypes();

for ( int k = 0; k < parameterTypes.length; k++ ) {

String parameterString = parameterTypes[k].getName();

System.out.print( " " + parameterString );

if ( k < parameterTypes.length – 1 )

System.out.print( ", " );

}

System.out.print( " )" );

Class<?>[] exceptions = method.getExceptionTypes();

if ( exceptions.length > 0 ) {

System.out.print( " throws " );

for ( int k = 0; k < exceptions.length; k++ ) {

System.out.print( exceptions[k].getName() );

if ( k < exceptions.length – 1 )

System.out.print( ", " );

}

}

System.out.println();

}

}

}

Die Ausgabe sieht gekürzt so aus:

int hashCode( )

boolean equals( java.lang.Object )

java.lang.String toString( )



1249

18

...

[F getRGBColorComponents( [F )

...

void wait( long ) throws java.lang.InterruptedException

void notify( )

void notifyAll( )

Wir bemerken an einigen Stellen eine kryptische Notation, wie etwa »[F«. Dies ist aber ledig-

lich wieder die schon erwähnte Kodierung für Array-Typen. So gibt getRGB-Components() ein

float-Array zurück und erwartet ein float-Array als Argument.

Þ Class<?> getDeclaringClass()

Liefert das Class-Exemplar für die Klasse oder die Schnittstelle, in der die Methode dekla-

riert wurde. Diese Methode ist Teil der Schnittstelle Member.

Þ String getName()

Liefert den Namen der Methode. Diese Methode ist Teil der Schnittstelle Member.


Liefert die Modifizierer. Diese Methode ist Teil der Schnittstelle Member.

Þ Class<?> getReturnType()

Gibt ein Class-Objekt zurück, das den Ergebnistyp beschreibt.

Þ Class<?>[] getParameterTypes()

Liefert ein Array von Class-Objekten, die die Typen der Parameter beschreiben. Die Reihen-

folge entspricht der deklarierten Parameterliste. Das Array hat die Länge null, wenn die Me-

thode keine Parameter erwartet.

Þ Class<?>[] getExceptionTypes()

Liefert ein Array von Class-Objekten, die mögliche Exceptions beschreiben. Das Array hat

die Länge null, wenn die Methode keine solchen Exceptions mittels throws deklariert. Das

Feld spiegelt nur die throws-Klausel wider. Sie kann prinzipiell auch zu viele Exceptions ent-

halten, bei einer Methode foo() throws RuntimeException, NullPointerException etwa genau

die beiden Ausnahmen.


Liefert eine String-Repräsentation der Methode, ähnlich dem Methodenkopf in einer Dekla-

ration.

final class java.lang.reflect.Method


implements GenericDeclaration, Member



1250

18.3.3 Properties einer Bean erfragen

Eine Bean besitzt Properties (Eigenschaften), die in Java (bisher) durch Setter und Getter aus-

gedrückt werden, also Methoden, die einer festen Namenskonvention folgen. Gibt es Inter-

esse an den Properties, lässt sich natürlich getMethods() auf dem Class-Objekt aufrufen und

nach den Methoden filtern, die der Namenskonvention entsprechen. Die Java-Bibliothek bie-

tet aber im Paket java.beans eine einfachere Lösung für Beans: einen PropertyDescriptor.

Interessanter sind vom PropertyDescriptor die Methoden getReadMethod() und getWrite-

Method(), die beide ein Method-Objekt liefern – sofern es verfügbar ist –, um so die Methode

gleich aufrufen zu können.

BeanInfo liefert mit getPropertyDescriptors() zwar die Properties, kann jedoch über getMethod-

Descriptors() auch alle anderen Methoden liefern.

18.3.4 Konstruktoren einer Klasse

Konstruktoren und Methoden haben einige Gemeinsamkeiten, unterscheiden sich aber inso-

fern, als Konstruktoren keinen Rückgabewert haben. Die Ähnlichkeit zeigt sich auch in der

Methode getConstructors(), die ein Array von Constructor-Objekten zurückgibt. Über dieses

Array lassen sich dann wieder Name, Modifizierer, Parameter und Exceptions der Konstrukto-

Beispiel

Gib alle Properties von Color aus (es gibt nur lesbare):

Listing 18.9: com/tutego/insel/meta/PropertyDescriptors.java, main()

BeanInfo beanInfo = Introspector.getBeanInfo( Color.class );

for ( PropertyDescriptor pd : beanInfo.getPropertyDescriptors() )

System.out.println( pd.getDisplayName() + " : " +

pd.getPropertyType().getName() );

Die Ausgabe:

RGB : int

alpha : int

blue : int

class : java.lang.Class

colorSpace : java.awt.color.ColorSpace

green : int

red : int

transparency : int



1251

18

ren einer Klasse erfragen. Wie wir in Abschnitt 18.4.1, »Objekte erzeugen«, sehen werden, las-

sen sich auch über die Methode newInstance() neue Objekte erzeugen. Wegen der weitgehen-

den Ähnlichkeit der Klassen Constructor und Method sind die folgenden Methoden hier nicht

näher beschrieben.

Þ Constructor[] getConstructors()

Liefert ein Feld mit Constructor-Objekten.

Þ Constructor<T> getConstructor(Class... parameterTypes)


Liefert ein ausgewähltes Constructor-Objekt.

Þ Class<T> getDeclaringClass()

Eine ziemlich langweilige Methode, da Konstruktoren nicht vererbt werden. Sie gibt immer

nur jene Klasse aus, von der das Class-Objekt kommt. Das ist ein wichtiger Unterschied zwi-

schen Methoden und Konstruktoren, der bei dieser Methode deutlich auffällt.

Beispiel

Zeige alle Konstruktoren der Color-Klasse:

Listing 18.10: com/tutego/insel/meta/ShowConstructors.java, main()

for ( Constructor<?> c : java.awt.Color.class.getConstructors() )

System.out.println( c );

Die Klasse Constructor implementiert eine auskunftsfreudige toString()-Methode. Die

String-Repräsentation zeigt die Signatur mit Sichtbarkeit. Nach dem Aufruf erhalten wir:

public java.awt.Color(float,float,float,float)

public java.awt.Color(int)

public java.awt.Color(int,int,int)

public java.awt.Color(int,int,int,int)

public java.awt.Color(java.awt.color.ColorSpace,float[],float)

public java.awt.Color(int,boolean)

public java.awt.Color(float,float,float)



final class java.lang.reflect.Constructor<T>





1252

Þ Class[] getExceptionTypes()


Þ String getName()

Þ Class[] getParameterTypes()

Abbildung 18.3: UML-Diagramm mit den Unterklassen von Member


18.4 Objekte erzeugen und manipulieren

1253

18

18.3.5 Annotationen

Annotationen erfragen Methoden der Schnittstelle AnnotatedElement, die unter anderem

Class, Constructor, Field, Method und Package implementieren. Ein Blick in AnnotatedElement

verrät, wie an die Annotationen heranzukommen ist:

Þ Annotation[] getAnnotations()

Liefert alle mit diesem Element assoziierten Annotationen.

Þ Annotation[] getDeclaredAnnotations()

Liefert alle an diesem Element deklarierten Annotationen. Vererbte Annotationen werden

ignoriert.

Þ boolean isAnnotationPresent(Class<? extends Annotation> annotationType)

Erfragt, ob das Element eine bestimmte Annotation besitzt.

Þ <T extends Annotation> T getAnnotation(Class<T> annotationType)

Liefert die Annotationen eines gewünschten Typs.

In Abschnitt 18.5, »Eigene Annotationstypen«, kommen wir auf Annotationen zurück.


Nachdem wir nun genügend über das Ausfragen von Klassen-, Variablen-, Methoden- und

Konstruktor-Objekten wissen, wollen wir aktiv eigene Objekte erzeugen, Werte von Variablen

abfragen und verändern sowie Methoden dynamisch per Reflection aufrufen.

18.4.1 Objekte erzeugen

Der new-Operator erzeugt in Java zur Laufzeit ein Exemplar einer Klasse. Der Compiler muss

dazu den Namen der Klasse kennen, sodass er einen passenden Konstruktor-Aufruf erzeugen

kann. Kennen wir aber erst später zur Laufzeit den Namen der gewünschten Klasse für unser

Objekt, so fällt die new-Operation flach, weil der new-Operator nicht für diesen Spezialfall ge-

dacht ist.

Um Exemplare bestimmter Klassen dynamisch zu erzeugen, brauchen wir wieder ein passen-

des Class-Objekt. Nun holen wir uns mit getConstructor() ein Konstruktor-Objekt, das den ge-

wünschten Konstruktor beschreibt. Jedes Konstruktor-Objekt kennt eine newInstance(Ob-

ject[])-Methode, die ein neues Exemplar erschafft, indem sie den zugrundeliegenden

Konstruktor aufruft. Der Parameter von newInstance() ist ein Feld von Werten, die an den ech-

interface java.lang.reflect.AnnotatedElement



1254

ten Konstruktor gehen. Glücklicherweise kennt Java anonyme Arrays, sodass wenig zu schrei-

ben bleibt. Bei einem parameterlosen Konstruktor können wir einfach newInstance(null) auf-

rufen.

Þ Constructor<T> getConstructor(Class... parameterTypes)


Liefert den sichtbaren Konstruktor mit dem gewünschten Typ.

Þ T newInstance(Object... initargs)

throws InstantiationException, IllegalAccessException,

IllegalArgumentException, InvocationTargetException

Erzeugt ein neues Exemplar, indem es den durch das Constructor-Objekt repräsentierten

Konstruktor mit den im Array angegebenen Parametern aufruft. Auf einige Exceptions ist

zu achten.

Þ IllegalAccessException: Auf den Konstruktor kann nicht zugegriffen werden (zum Beispiel,

weil er privat ist).

Þ IllegalArgumentException: Die Anzahl der Parameter ist falsch beziehungsweise eine Kon-

vertierung der Parameterwerte in die benötigten Typen ist nicht möglich.

Þ InstantiationException: Das Constructor-Objekt bezieht sich auf einen Konstruktor einer

abstrakten Klasse.

Beispiel

Ein Reflection-Konstruktor erzeugt ein Point-Objekt mit den Koordinaten 10, 20:

Listing 18.11: com/tutego/insel/meta/CreateObject.java, main()

Class<Point> pointClass = Point.class;

Constructor<Point> constructor =

pointClass.getConstructor( int.class, int.class );

Point p = constructor.newInstance( 10, 20 );

System.out.println( p );



final class java.lang.reflect.Constructor<T>





1255

18

InvocationTargetException

Die Ausnahme InvocationTargetException ist keine RuntimeException und kommt bei zwei Me-

thoden aus der Reflection-API vor:

Þ newInstance() zum Erzeugen von Objekten bei Constructor

Þ invoke() zum Aufruf von Methoden bei Method

Die InvocationTargetException ist ein Mantel um genau die Ausnahme, die der aufgerufene

Konstruktor beziehungsweise die Methode ausgelöst hat. Löst der Konstruktor oder die Me-

thode eine Ausnahme aus, so generiert die JVM eine InvocationTargetException und lässt uns

mit getCause() beziehungsweise mit getTargetException() den Grund als Throwable erfragen.

18.4.2 Die Belegung der Variablen erfragen

Schreiben wir einen GUI-Builder oder einen Debugger, so reicht es nicht aus, nur die Namen

und Datentypen der Variablen zu kennen. Wir wollen auch auf ihre Inhalte lesend und schrei-

bend zugreifen. Das ist mithilfe der verschiedenen getXXX()-Methoden für ein Field-Objekt

leicht machbar. Der erste Schritt besteht also wieder darin, ein Class-Objekt zu erfragen. Dann

besorgen wir uns mittels getFields() ein Array von Attributbeschreibungen – oder mit get-

Fields(String) ein spezielles Attribut – und nehmen das Field-Objekt für unsere gewünschte

Variable. Den Wert, den das Field dann speichert, erfragt die Methode get(). Sie ist auf allen

Variablentypen möglich und konvertiert automatisch in Wrapper-Objekte, wenn der Typ pri-

mitiv war. Die Field-Klasse bietet einige spezielle getXXX()-Methoden, um besonders einfach

an die Werte von Variablen primitiven Typs zu gelangen. So liefert getDouble() einen double-

Wert und getInt() ein int. Wir müssen daran denken, dass IllegalArgumentException und

IllegalAccessException bei falschem Zugriff auftreten können.

Alle getXXX()-Methoden zum Erfragen – und auch setXXX()-Methoden zum Setzen – erwarten

ein Argument mit dem Verweis auf das Objekt, das die Variable besitzt. Das Argument wird

ignoriert (und sollte null sein), wenn es sich um eine statische Variable handelt.

Rechtecke erzeugen und erfragen

Ein Programm soll ein Rectangle-Objekt mit einer Belegung für x, y, Höhe und Breite er-

zeugen. Anschließend erfragt getField(String) das Field-Objekt für eine Beschreibung der

Variablen mit dem gegebenen Namen. Das Field-Objekt gibt mit getXXX() den Inhalt der

Variablen preis. Um das Prinzip zu demonstrieren, erfragt die get()-Methode die Höhe height,

die ein Integer-Objekt zurückgibt. Alle anderen Ganzzahlwerte liefert die spezialisierte Helfer-

methode getInt():



1256

Listing 18.12: com/tutego/insel/meta/GetFieldElements.java



class GetFieldElements

{


{

Object o = new java.awt.Rectangle( 11, 22, 33, 44 );

Class<?> c = o.getClass();

try

{

Field heightField = c.getField( "height" ),

widthField = c.getField( "width" ),

xField = c.getField( "x" ),

yField = c.getField( "y" );

Integer height = (Integer) heightField.get( o );

int width = widthField.getInt( o ),

x = xField.getInt( o ),

y = yField.getInt( o );

String s = c.getName() + "[x=" + x + ",y=" + y +

",width=" + width + ",height=" + height + "]";

System.out.println( s ); // java.awt.Rectangle[x=11,y=22,width=33,height=44]

System.out.println( o ); // java.awt.Rectangle[x=11,y=22,width=33,height=44]

}

catch ( NoSuchFieldException e ) {

e.printStackTrace();

}

catch ( SecurityException e ) {


}



1257

18

catch ( IllegalAccessException e ) {


}

}

}

Es erzeugt nun nach dem Aufruf die Ausgabe:

java.awt.Rectangle[x=11,y=22,width=33,height=44]

java.awt.Rectangle[x=11,y=22,width=33,height=44]

Þ String getName()

Liefert den Namen der Variablen. Diese Methode ist Teil der Schnittstelle Member.


Liefert die Modifizierer. Diese Methode ist Teil der Schnittstelle Member.

Þ Object get(Object obj)

Þ boolean getBoolean(Object obj)

Þ byte getByte(Object obj)

Þ char getChar(Object obj)

Þ double getDouble(Object obj)

Þ float getFloat(Object obj)

Þ int getInt(Object obj)

Þ long getLong(Object obj)

Þ short getShort(Object obj)

Erfragt den Wert eines Attributs. Die Referenz von obj zeigt auf das Objekt, das das Attribut

enthält. Es sollte null übergeben werden, wenn es sich um eine statische Variable handelt.

18.4.3 Eine generische eigene toString()-Methode *

Die toString()-Methode ist für viele Klassen nicht überlebenswichtig, aber außerordentlich

praktisch. Es ist viel zu schade, hier Zeit für die Entwicklung zu investieren. Toll wäre es, wenn

toString() ganz automatisch die Attribute und Belegungen analysierte und ausgäbe. Aber wer

Allgemeines sucht, findet die Antwort in Reflection. Wir schreiben einfach eine statische Me-

thode toString(Object) in eine Hilfsklasse und erfragen dann alle Attribute und die Werte des



implements Member



1258

zu untersuchenden Objekts. Etwas Programmieraufwand müssen wir noch in die Behandlung

der Oberklasse investieren, denn Reflection auf einem Objekt zeigt nur die in der Klasse de-

klarierten Attribute, nicht aber die geerbten Attribute an. Die Lösung ergibt sich fast von

selbst:

Listing 18.13: com/tutego/insel/meta/ToStringHelper.java



import java.util.*;

public class ToStringHelper

{

public static String toString( Object o )

{

Collection<String> result = new ArrayList<String>();

toString( o, o.getClass(), result );

return o.getClass().getName().concat( result.toString() );

}

private static void toString( Object o, Class<?> clazz, Collection<String> list )

{

Field[] fields = clazz.getDeclaredFields();

AccessibleObject.setAccessible( fields, true );

for ( Field f : fields )

{

try

{

list.add( f.getName() + "=" + f.get( o ) );

}

catch ( IllegalAccessException e )

{


}

}



1259

18

if ( clazz.getSuperclass().getSuperclass() != null )

toString( o, clazz.getSuperclass(), list );

}

}

Die private Methode toString(Object, Class, ArrayList) dient eigentlich nur dem rekursiven

Aufruf durch die Oberklassen. Falls es eine Oberklasse gibt, also clazz.getSuperclass().get-

Superclass() ein Objekt liefert, müssen wir für die Oberklasse ebenfalls die Attribute ablaufen.

Das machen wir rekursiv.

Testen wir anschließend ToStringHelper in einer Klasse ToStringHelperDemo, die von Ober abge-

leitet ist. Damit bekommen wir zwei Attribute in der Oberklasse. Eines davon ist interessant

(die Variable i), denn die Unterklasse überdeckt sie. Dennoch findet toString() beide Belegun-

gen. Wäre das nicht erwünscht, müssten wir einfach die Liste durchschauen und suchen, ob

schon ein Attribut mit dem gleichen Namen vorhanden ist. Da der Algorithmus rekursiv erst

die Unterklasse und dann die Oberklasse(n) durchsucht, bekommen wir auch die Attribute in

dem sichtbaren Bereich, wie sie auch der Benutzer sieht:

Listing 18.14: com/tutego/insel/meta/ToStringHelperDemo.java


class Ober

{

int i = 123;

/* private */double d = 3.1415;

}

public class ToStringHelperDemo extends Ober

{

String hello = "world";

int i = 42;


{

ToStringHelperDemo t = new ToStringHelperDemo();

System.out.println( ToStringHelper.toString( t ) );

// ToStringHelperTest[hello=world, i=42, i=123, d=3.1415]

}

}



1260

18.4.4 Variablen setzen

Bei Debuggern oder grafischen Editoren ist es nur eine Seite der Medaille, die Werte von Vari-

ablen anzuzeigen. Hinzu kommt noch das Setzen der Werte von Variablen. Dies ist aber ge-

nauso einfach wie das Abfragen. Anstelle der getXXX()-Methoden kommen nun verschiedene

setXXX()-Methoden zum Einsatz. So trägt setBoolean() einen Wahrheitswert oder setDouble()

eine Fließkommazahl in eine Variable ein. Eine allgemeine set()-Methode dient Objektrefe-

renzen wie im Fall von get(). Die Methode set() nimmt ebenso Wrapper-Objekte für Variab-

len von primitiven Datentypen. Die folgenden set<Typ>()-Methoden setzen daher alle »ih-

ren« Datentyp. Wir müssen aber dafür sorgen, dass die Variable existiert und wir Zugriff

darauf haben. In allen Fällen muss auf IllegalArgumentException und IllegalAccessException

geachtet werden.

Das folgende Programm erzeugt klassisch ein Point-Objekt mit dem Konstruktor, der x und y

setzt. Anschließend verändert die eigene Methode modify() ein gewünschtes Attribut:

Listing 18.15: com/tutego/insel/meta/SetFieldElements.java



import java.awt.*;

class SetFieldElements

{


{

Point p = new Point( 11, 22 );


modify( p, "x", 1111 ); // java.awt.Point[x=11,y=22]

modify( p, "y", 2222 ); // java.awt.Point[x=1111,y=2222]


modify( p, "z", 0 ); // java.lang.NoSuchFieldException: z

}

static void modify( Object o, String name, Integer param )

{



1261

18

try

{

Field field = o.getClass().getField( name );

field.set( o, param );

}

catch ( NoSuchFieldException e ) {


}

catch ( IllegalAccessException e ) {


}

}

}

Die Veränderung der Variablen erfolgt mit der set()-Methode. Da wir primitive Datentypen

übergeben, wickeln wir sie für die modify()-Methode in ein Integer-Objekt ein. Das Integer-

Objekt haben wir nicht explizit programmiert, denn es wird über Boxing vom Compiler selbst

zur Verfügung gestellt. Für bekannte Typen könnten wir neben der allgemeinen Methode

set() auch etwa setInt() verwenden.

Þ void set(Object obj, Object value)

Setzt das Attribut des Objekts obj, das dieses Field-Objekt repräsentiert, auf den neuen Wert

value.

Þ void setBoolean(Object obj, boolean z)

Þ void setByte(Object obj, byte b)

Þ void setChar(Object obj, char c)

Þ void setDouble(Object obj, double d)

Þ void setFloat(Object obj, float f)

Þ void setInt(Object obj, int i)

Þ void setLong(Object obj, long l)

Þ void setShort(Object obj, short s)

Belegt das Feld eines Objekts obj mit einem primitiven Element.



implements Member



1262

18.4.5 Bean-Zustände kopieren *

In mehrschichtigen Anwendungen gibt es oft das Muster, dass eine JavaBean etwa über eine

objekt-relationale Mapping-Technologie automatisch aus einer Datenbankzeile aufgebaut

wird und dann intern in der Geschäftsschicht verwendet wird. Soll nun diese Information

über das Netzwerk an einen anderen Rechner verteilt werden, ist es nicht immer angebracht,

diese JavaBean etwa direkt über Serialisierung zu versenden. Stattdessen kann ein Transfer-

Objekt aufgebaut werden, eine spezielle JavaBean zum Beispiel, sodass der Empfänger keine

Abhängigkeit zu der Bean in der internen Geschäftsschicht hat. Nun werden sich aber diese

Geschäftsschicht-Bean und die Transfer-Bean sehr ähnlich sein, und viele Entwickler scheuen

die Mühe, lästigen Kopiercode zu erstellen. Doch manuelle Arbeit ist nicht nötig, und eine Lö-

sung für das Kopierproblem ist über Refection schnell geschrieben. Über die BeanInfo kom-

men wir an den PropertyDescriptor (siehe dazu Abschnitt 18.3.3, »Properties einer Bean erfra-

gen«), und dann liefern getReadMethod() und getWriteMethod() die Setter/Getter. Bei einer

eigenen Kopiermethode wie copyProperties(Object source, Object target) müssen wir bei der

Quell-Bean jede Property auslesen und entsprechend bei der Ziel-Bean nach der Property su-

chen und den Setter aufrufen. Wenn das Ganze ohne Typkonvertierungen programmiert wer-

den soll, sind es nur wenige Zeilen Programmcode. Kommen einfache Konvertierungen dazu,

etwa wenn einmal ein Wrapper als Property-Typ genutzt wird und einmal der primitive Da-

tentyp, ist es etwas mehr.

Der Aufwand mit einer eigenen Implementierung ist allerdings nicht nötig, denn zwei popu-

läre Implementierungen können helfen:

Þ Apache Commons BeanUtils (http://commons.apache.org/beanutils/):

Die Klasse org.apache.commons.beanutils.BeanUtils bietet praktische statische Methoden

wie copyProperty(Object bean, String name, Object value), copyProperties(Object dest, Object

orig), Object cloneBean(Object bean) oder populate(Object bean, Map properties).

Þ Dozer (http://dozer.sourceforge.net/): Dozer bringt ausgefeilte Mapping-Möglichkeiten

mit, die weit über BeansUtils hinausgehen. Das geht so weit, dass es ein Eclipse-Plugin zur

Konfiguration der Abbildungen gibt.

18.4.6 Private Attribute ändern

Wenn es der Sicherheitsmanager zulässt, kann ein Programm auch private- oder protected-

Attribute ändern und Methoden/Konstruktoren eingeschränkter Sichtbarkeit aufrufen. Die

Schlüsselfigur in diesem Spiel ist die Oberklasse java.lang.reflect.AccessibleObject, die den

Klassen Constructor, Field und Method die Methode setAccessible(boolean) vererbt. Ist das Ar-

gument true und lässt der Sicherheitsmanager die Operation zu, lässt sich auf jedes Element

(also Konstruktor, Attribut oder Methode) zugreifen:



1263

18

Listing 18.16: com/tutego/insel/meta/ReadPrivate.java


public class ReadPrivate

{

@SuppressWarnings( "all" )

private String privateKey = "Schnuppelhase";

public static void main( String[] args ) throws Exception

{

ReadPrivate key = new ReadPrivate();

Class<?> c = key.getClass();

java.lang.reflect.Field field = c.getDeclaredField( "privateKey" );

field.setAccessible( true );

System.out.println( field.get(key) ); // Schnuppelhase

field.set( key, "Schnuckibutzihasidrachelchen");

System.out.println( field.get(key) ); // Schnuckibutzihasidrachelchen

}

}

18.4.7 Methoden aufrufen

Nach dem Abfragen und Setzen von Variablenwerten und Konstruktor-Aufrufen zum Erzeu-

gen eines Objekts ist das Aufrufen von Methoden per Reflection der letzte Schritt. Wenn zur

Compilezeit der Name der Methode nicht feststeht, lässt sich zur Laufzeit dennoch eine im

Programm deklarierte Methode aufrufen, wenn ihr Name als Zeichenkette vorliegt.

Warnung

Mit dieser Technik lässt sich viel Unsinn anrichten. Es gibt Dinge, die in der Laufzeitumgebung

einfach fest sein müssen. Dazu zählen einmal angelegte Strings oder Wrapper-Objekte.

Strings sind immutable, weil sie intern in einem privaten char-Feld gehalten werden und es

keine Modifikationsmöglichkeiten gibt. Auch Wrapper-Objekte sind, wenn sie einmal mit

einem Konstruktor angelegt wurden, nicht über öffentliche Methoden veränderbar. Sie an-

schließend per Reflection zu modifzieren bringt große Unordnung, insbesondere bei den

gecachten Integer/Long-Wrapper-Objekten, die die statischen valueOf()-Methoden liefern.



1264

Zunächst gehen wir wieder von einem Class-Objekt aus, das die Klasse des Objekts beschreibt,

für das eine Objektmethode aufgerufen werden soll. Anschließend wird ein Method-Objekt als

Beschreibung der gewünschten Methode benötigt; wir bekommen dies mit der Methode get-

Method() aus dem Class-Exemplar. getMethod() verlangt zwei Argumente: einen String mit

dem Namen der Methode und ein Array von Class-Objekten. Jedes Element dieses Arrays ent-

spricht einem Parametertyp aus der Signatur der Methode. Damit werden überladene Metho-

den unterschieden. Nachdem wir das beschreibende Method-Exemplar und die Parameter-

werte für den Aufruf vorbereitet haben, ruft invoke() die Zielmethode auf – im Englischen

heißt dies dynamic invocation. invoke() erwartet zwei Argumente: ein Array mit Argumen-

ten, die der aufgerufenen Methode übergeben werden, und eine Referenz auf das Objekt, auf

dem die Methode aufgerufen werden soll und zur Auflösung der dynamischen Bindung dient.

Þ Object invoke(Object obj, Object... args)

throws IllegalAccessException, IllegalArgumentException, InvocationTargetException

Ruft eine Methode des Objekts obj mit den gegebenen Argumenten auf. Wie schon beim

Konstruktor löst die Methode eine InvocationTargetException aus, wenn die aufzurufende

Methode eine Exception auslöst.

Beispiele der Varargs sind bei getMethod() die Parametertypen und bei invoke() die Argu-

mente für setLocation(). Da getMethod() eine beliebige Anzahl von Argumenten annehmen

kann und kein Argument dazuzählt, muss die Methode nicht so parametrisiert werden:

Method method = p.getClass().getMethod( "getX", (Class[]) null );

final class java.lang.reflect.Method



Beispiel

Wir erzeugen ein Point-Objekt und setzen im Konstruktor den x-Wert auf 10. Anschließend

fragen wir mit der Methode getX(), die wir dynamisch aufrufen, den x-Wert wieder ab:

Listing 18.17: com/tutego/insel/meta/InvokeMethod.java, main()

Point p = new Point( 10, 0 );

Method method = p.getClass().getMethod( "getX" );

String returnType = method.getReturnType().getName();

Object returnValue = method.invoke( p );

System.out.printf( "(%s) %s", returnType, returnValue ); // (double) 10.0



1265

18

Auffälliger ist die Möglichkeit der variablen Argumentanzahl bei invoke(). Da ein Getter keine

Parameter besitzt, heißt es kurz method.invoke(p); statt wie vor Java 5:

method.invoke( p, (Object[]) null );

Interessant sind Methoden mit Parameterliste, wie setLocation():

Point p = new Point();

Method method = p.getClass().getMethod( "setLocation", int.class, int.class );

method.invoke( p, 1, 2 );


18.4.8 Statische Methoden aufrufen

Wir wollen ein Beispiel programmieren, in dem die Klasse InvokeMain die statische main()-Me-

thode einer anderen Klasse, HasMain, mit einem Parameter aufruft:

Listing 18.18: com/tutego/insel/meta/InvokeMain.java



import java.util.Arrays;

public class InvokeMain

{


{

String[] argv = { "-option", "Parameter" };

Method method = Class.forName( "com.tutego.insel.meta.HasMain" ).

getMethod( "main", argv.getClass() );

method.invoke( null, new Object[]{ argv } );

}

}

class HasMain

{




1266

{

System.out.println( "Got: " + Arrays.toString( args ) );

}

}

18.4.9 Dynamische Methodenaufrufe bei festen Methoden beschleunigen *

Werden über Reflection Methoden aufgerufen, deren Methodennamen erst zur Laufzeit be-

stimmt werden, so verlieren wir die Typsicherheit vom Compiler, und die Geschwindigkeit ist

nicht optimal – auch wenn es seit Java 5 nicht mehr so schlimm ist (doch immer noch zeigt

eine einfache Zeitmessung einen deutlichen Unterschied). Diese Aufrufe lassen sich prinzip-

bedingt auch durch einen JIT-Compiler nicht weiter beschleunigen. Wir müssen also nach

einer Lösung suchen, mit der wir diese Art von Aufruf beschleunigen können. Ein möglicher

Weg hierbei ist, in Kenntnis des Namens der Methode – nennen wir die Methode meth() – den

Namen in einer (abstrakten) Oberklasse dem Compiler bereits bekannt zu machen. Reflection

ist nur zum Laden einer Unterklasse mit gegebenem Namen nötig; die normale, dynamische

Methodenbindung erledigt den Rest – ganz ohne versteckte Schnüre, doppelte Böden oder

Spiegel (Reflection).

Versuchen wir, den folgenden Code nach diesem Schema zu ändern:

Listing 18.19: com/tutego/insel/meta/DynamReflection.java, main()

Class<?> clazz = Class.forName("com.tutego.insel.meta.DynamReflectionMethod" );

Object o = clazz.newInstance();

clazz.getMethod( "meth" ).invoke( o );

DynamReflection ist die Hauptklasse, die die Klasse DynamReflectionMethod über Class.forName()

anfordert:

Listing 18.20: com/tutego/insel/meta/DynamReflectionMethod.java


public class DynamReflectionMethod

{

@Override

public void meth()

{

System.out.println( "Bewusste Raucher trinken Filterkaffee" );

}

}



1267

18

Über das Class-Objekt erzeugt newInstance() ein neues Exemplar. getMethod() sucht die Be-

schreibung der Methode meth() heraus, und invoke() ruft die Methode meth() auf. Hier genau

entsteht ein kleiner Geschwindigkeitsverlust. Wenn es uns gelänge, um das invoke() herum-

zukommen, wäre das schon ein großer Fortschritt. Dies schaffen wir, indem wir eine Schnitt-

stelle (oder Oberklasse) für DynamReflectionMethod konstruieren, die genau diese Methode vor-

schreibt. Die implementierende Klasse (beziehungsweise Unterklasse) wird dann eine

Implementierung angeben:

Listing 18.21: com/tutego/insel/meta/DynamAbstract.java


interface DynamBase

{

void meth();

}

class DynamBaseMethod implements DynamBase

{

public void meth()

{

System.out.println( "Bewusste Raucher trinken Filterkaffee" );

}

}

public class DynamAbstract

{


{

Class<?> clazz = Class.forName( "com.tutego.insel.meta.DynamBaseMethod" );

DynamBase o = (DynamBase) clazz.newInstance();

o.meth();

}

}

DynamBase ist eine Schnittstelle, die zur Übersetzungszeit bekannt ist. Die virtuelle Maschine

löst den Aufruf nach den üblichen Regeln der dynamischen Bindung selbst auf. Die Klasse

DynamBaseMethod wird ebenfalls erst zur Laufzeit geladen. Wir verstecken hier sehr elegant den

Aufwand. Wir haben die gleiche Funktionalität und Flexibilität wie im vorangegangenen

Reflection-Beispiel – wenn wir die Möglichkeit, den Klassennamen durch einen String anzu-



1268

geben, außer Acht lassen –, aber mit der höheren Geschwindigkeit eines konventionellen

Methodenaufrufs ohne Reflection.

18.5 Eigene Annotationstypen *

Die in der Java-Standardbibliothek vorgegebenen Annotationen haben entweder eine beson-

dere Semantik für den Compiler, wie @Override oder @SuppressWarnings, oder dienen zum Bei-

spiel zur Definition von Web-Services (@WebService, @WebMethod, ...) oder von Komponenten mit

XML-Abbildung (@XmlRootElement, @XmlElement, ...). Insbesondere die Java Enterprise Edition

(Java EE) macht von Annotationen fleißig Gebrauch, und es lassen sich auch neue Annotati-

onstypen deklarieren.

18.5.1 Annotationen zum Laden von Ressourcen

Im Folgenden wollen wir drei Annotationstypen deklarieren, die den Inhalt von Objektvariab-

len beschreiben. Zunächst werden die Annotationstypen selbst beschrieben, und abschlie-

ßend folgt eine Klasse, die die Annotationen ausliest und die Ressourcen initialisiert.

Es soll möglich sein, mit @CurrentDateResource eine Objektvariable mit dem aktuellen Datum

zu belegen:

@CurrentDateResource

public Date now;

Hinweis

Der Aufruf von Class.forName() liefert ein Class-Objekt, bei dem Typ nicht bekannt ist. Daher

ist unsere Variable clazz mit Class<?> deklariert. Bei newInstance() ist dann auch eine expli-

zite Typanpassung auf den Ergebnistyp nötig, was nicht nötig wäre, wenn das Class-Objekt

korrekter wäre. Um das Class-Objekt von Class.forName() zu spezialisieren, gibt es eine Me-

thode asSubclass(). Dann lässt sich statt dem bekannten

Class<?> clazz = Class.forName( "DynamBaseMethod" );

DynamBase o = (DynamBase) clazz.newInstance();

Folgendes schreiben:

Class<? extends DynamBase> clazz =

Class.forName( "DynamBaseMethod" ).asSubclass( DynamBase.class );

DynamBase o = clazz.newInstance();



1269

18

Ist eine Variable mit @ListOfFilesResource annotiert, so sollen alle Dateien und Unterverzeich-

nisse aus einem gegebenen Verzeichnis aufgelistet und damit ein Feld initialisiert werden:

@ListOfFilesResource( "c:/" )

String[] files;

Die Annotation @UrlResource ist die komplexeste Annotation. Sie beschreibt im einfachsten

Fall eine URL mit Daten von einem HTTP-Server (mit dem URL-Protokoll file:// auch vom lo-

kalen Dateisystem), sodass eine Variable mit dem Inhalt initialisiert werden kann:

@UrlResource( "http://tutego.de/aufgaben/bond.txt" )

String testFile;

Der Annotation lassen sich noch einige Attribute (Element-Wert-Paare) übergeben, sodass

etwa Leerraum entfernt wird oder der String in Groß-/Kleinbuchstaben konvertiert wird:

@UrlResource( value = "http://tutego.de/aufgaben/bond.txt",

trim = true,

upperLowerCase = UpperLowerCase.UPPERCASE )

public String testFile;

Zu guter Letzt lassen sich bei @UrlResource auch beliebige Konvertierer-Klassen angeben, die

den Text der Ressource transformieren:


converter = { RemoveNoWordCharactersConverter.class,

SortConverter.class } )


18.5.2 Neue Annotationen deklarieren

Ein Annotationstyp (engl. annotation type) wird so deklariert wie eine Schnittstelle, nur steht

vor dem Schlüsselwort interface ein @-Zeichen.

Beginnen wir mit dem einfachsten Annotationstyp, CurrentDateResource:

public @interface CurrentDateResource { }

Die Ähnlichkeit von neuen Annotationstypen und Schnittstellen ist so groß, dass in der Java

Language Specification die Annotationen auch im Kapitel über Schnittstellen behandelt wer-

den. (Später erfahren wir den Grund dafür: Der Compiler übersetzt die Annotationstypen in

Schnittstellen.)



1270

Wo sich der Annotationstyp festmachen lässt, kann eingeschränkt werden. Im Standardfall

kann er überall angeheftet werden, das heißt an beliebigen Typdeklarationen, Annotationen,

Aufzählungen, Objekt-/Klassenvariablen, lokalen Variablen, Parametern, Methoden, Kon-

struktoren oder auch an Paketen (wobei die Syntax da etwas anders ist).

Damit ist Folgendes erlaubt:

@CurrentDateResource public Date now;

18.5.3 Annotationen mit genau einem Attribut

Der Annotationstyp @CurrentDateResource kann mit keinem zusätzlichen Attribut versehen

werden, da er in der bisherigen Schreibweise eine Markierungsannotation ist. Erlaubt sind

zwar ein Paar runde Klammern hinter dem Namen und auch Kommentare, aber eben kein zu-

sätzliches Attribut, wie es @ListOfFilesResource etwa wünscht:

@CurrentDateResource public Date now;

@CurrentDateResource() public Date now;

@CurrentDateRessource( "gestern" ) public Date now; // Compilerfehler

Damit zusätzliche Informationen für den Pfadnamen bei @ListOfFilesResource("c:/") mög-

lich sind, werden im Annotationstyp Deklarationen für Attribute eingesetzt, deren Schreib-

weise an Operationen einer Java-Schnittstelle erinnert. (Aber die Operationen dürfen keinen

Parameter besitzen, die Rückgabe darf nicht void sein und kein throws besitzen. Und Operati-

onen, die so heißen wie die Methoden aus Object, sind nicht zugelassen.)

Damit ein zusätzliches Attribut den Pfadnamen annehmen kann, sieht die Deklaration des

Annotationstyps ListOfFilesResource so aus:

public @interface ListOfFilesResource

{

String value();

}

Damit haben wir den zweiten Annotationstyp aus unserem Beispiel vorbereitet, und gültig

wäre:

@ListOfFilesResource( "c:/" )

String[] files;

Fehlt das erwartete Element, also der Pfad-String, gibt es einen Compilerfehler.



1271

18

Attributtypen

Das, was so wie ein Rückgabetyp einer Methode aussieht, bestimmt den Typ des Attributs und

ist im begrenzten Rahmen wählbar. Der Typ muss nicht immer nur String sein. Insgesamt er-

laubt Java:

Þ alle primitiven Datentypen (byte, short, int, long, float, double, boolean), aber keine Wrapper

Þ String

Þ Class. Insbesondere mit der generischen Angabe ermöglicht er eine präzise Klassenangabe.

Þ Enum-Typen

Þ andere Annotationen (was zu geschachtelten Annotationen führt)

Þ Felder von oben genannten Typen. Felder von Feldern (mehrdimensionale Felder) sind

aber nicht gestattet.

18.5.4 Element-Werte-Paare (Attribute) hinzufügen

Wenn der Annotationstyp ein Attribut mit dem Namen value deklariert, so muss keine An-

gabe über einen Schlüsselnamen gemacht werden. Möglich wäre das aber schon, und ge-

schrieben würde das so:

@ListOfFilesResource( value = "c:/" )

String[] files;

Eine Annotation lässt sich mit einer beliebigen Anzahl von Attributen deklarieren, und das

Attribut muss auch nur dann value heißen, wenn der Schlüssel nicht ausdrücklich genannt

werden soll – also @ListOfFilesResource("c:/") statt @ListOfFilesResource(value = "c:/"). Ist

mehr als ein Attribut nötig, muss ohnehin immer der Attributname zusammen mit der Bele-

gung genannt werden.

Hinweis

Die Attribute sind typisiert, und fehlerhafte Typen lehnt der Compiler ab. null ist als Argu-

ment nie erlaubt. Mögliche Typkonvertierungen führt der Compiler automatisch durch:

@ListOfFilesResource( "" ) String[] files; // OK

@ListOfFilesResource() String[] files; // Compilerfehler

@ListOfFilesResource( null ) String[] files; // Compilerfehler

@ListOfFilesResource( 1 ) String[] files; // Compilerfehler

@ListOfFilesResource( 'C' ) String[] files; // Compilerfehler

@ListOfFilesResource( "C:" + '/' ) String[] files; // OK



1272

Wenn @ListOfFilesResource mit einem Attribut trim ausgestattet wird, sodass die gelesenen

Texte automatisch vorne und hinten den Weißraum abgeschnitten bekommen, so könnte die

Deklaration des Annotationstyps so aussehen:

public @interface UrlResource

{

String value();

boolean trim();

}

Und in der Anwendung:

@UrlResource( value = "http://tutego.de/aufgaben/bond.txt", trim = true )

String testFile;

18.5.5 Annotationsattribute vom Typ einer Aufzählung

Bisher haben wir als Attributtyp String und boolean eingesetzt. Attribute dürfen auch Aufzäh-

lungen sein. Wir wollen das für @UrlResource nutzen, damit wir beim Einlesen wählen können,

ob der Text in Groß- oder Kleinbuchstaben konvertiert wird:


upperLowerCase = UpperLowerCase.UPPERCASE )

String testFile;

Für die Konvertierungsart deklarieren wir zunächst eine Aufzählung und deklarieren das At-

tribut upperLowerCase dann genau mit dem Aufzählungstyp:


{

public enum UpperLowerCase { UNCHANGED, LOWERCASE, UPPERCASE }

String value();

UpperLowerCase upperLowerCase();

}

Die Aufzählung UpperLowerCase als inneren Typ zu deklarieren, ist interessant, da sie ja nicht

allgemein ist, sondern ausschließlich mit der Annotation @UrlResource Sinn ergibt.



1273

18

18.5.6 Felder von Annotationsattributen

Von den unterschiedlichen Elementtypen dürfen eindimensionale Felder gebildet werden. Da

es keine anderen Sammlungen gibt, stellt das Feld die einzige Möglichkeit dar, beliebig viele

Elemente anzugeben.

Der @UrlResource sollen beliebig viele Konvertierungsfilter zugewiesen werden. Konvertie-

rungsfilter sind Klassen, die die Schnittstelle ResourceConverter implementieren und den ein-

gelesenen String transformieren. Dann heißt es in der Deklaration des Annotationstyps:


{

String value();

Class<? extends ResourceConverter>[] converter();

}

Der interessante Teil ist natürlich Class<? extends ResourceConverter>[]. Der setzt sich wie

folgt zusammen:

Þ Da Java es nicht erlaubt, dass beliebige Attributtypen verwendet werden, bleiben bei der

Angabe der Konverter nur Class-Objekte und nicht etwa ResourceConverter[].

Þ Die Typangabe Class[] wäre nicht ausreichend, da Class mit einem generischen Typ präzi-

siert werden muss. Jetzt ist aber Class<ResourceConverter> auch noch nicht präzise, denn

wir wollen ja nicht nur exakt den Typ RessourceConverter treffen, sondern Untertypen, also

Klassen, die RessourceConverter erweitern. Damit sind wir bei Class<? extends ResourceCon-

verter>.

Þ Da es eine Liste von Class-Angaben werden kann, muss das Paar eckiger Klammen an die

Deklaration.

Weisen wir zum Beispiel zwei Konverter – die Klassen wurden noch nicht vorgestellt, aber das

folgt – der @UrlResource zu:


converter = { RemoveNoWordCharactersConverter.class,

SortConverter.class } )


Bei nur einem angegebenen Konverter können die geschweiften Klammern sogar entfallen:


converter = RemoveNoWordCharactersConverter.class )



1274

18.5.7 Vorbelegte Attribute

Im bisherigen Fall mussten alle Attributbelegungen angegeben werden, und wir konnten kein

Element-Werte-Paar auslassen. Die Annotationstypen ermöglichen allerdings für Attribute

Standardwerte, sodass ein Wert angeben werden kann, aber nicht muss. Statt

@UrlResource( value = "http://tutego.de/aufgaben/bond.txt", trim = false )

Hinweis

Da ein Attribut wieder eine Annotation sein kann, ergeben sich interessante Möglichkeiten.

Neben wir an, der Annotationstyp Name speichert Vor- und Nachnamen:

@interface Name

{

String firstname();

String lastname();

}

Ein Annotationstyp Author soll Name als Elementtyp für value nutzen:

@interface Author

{

Name[] value();

}

Vor Name steht nicht das @-Zeichen. Nur in der Anwendung:

@Author( @Name( firstname = "Christian", lastname = "Ullenboom" ) )

Hätten wir das Element nicht value, sondern etwa name genannt, müsste die Angabe so hei-

ßen:

name = @Name( firstname = "Christian", lastname = "Ullenboom" )

Und hätten wir mehrere Autoren angegeben, würden wir Folgendes schreiben:

@Author(

{

@Name( firstname = "Christian", lastname = "Ullenboom" ),

@Name( firstname = "Hansi", lastname = "Hinterweltler" )

} )



1275

18

soll es möglich sein, trim = false wegzulasssen, weil es Standard sein soll:

@UrlResource( value = "http://tutego.de/aufgaben/bond.txt" )

Beziehungsweise dann wieder kürzer:


In der Syntax für Vorbelegungen hält dafür das Schlüsselwort default her, was auch zu einer

neuen Schreibweise führt, die von den Schnittstellen abweicht.

Bei unserem @UrlResource ist nur die Angabe der Textquelle vonnöten; alles andere soll mit

Default-Werten belegt sein:


{

enum UpperLowerCase { UNCHANGED, LOWERCASE, UPPERCASE }

String value();

boolean trim() default false;

UpperLowerCase upperLowerCase() default UpperLowerCase.UNCHANGED;

Class<? extends ResourceConverter>[] converter() default { };

}

Nachträgliche Änderung und die Sinnhaftigkeit von Standardwerten

Annotationstypen können ebenso wenig einfach geändert werden wie Schnittstellendeklara-

tionen. Wird eine Methode nie über den Basistyp einer Schnittstelle aufgerufen, sondern die

Schnittstelle lediglich implementiert, so kann diese ungenutzte Operation im Prinzip ge-

löscht werden3. Bei Annotationen ist das genauso: Wenn ein Annotationselement mit einem

Standardwert belegt ist, und es nie genutzt wird, kann es gelöscht werden. Aber hier gilt ana-

log zu den Schnittstellen: Gibt es eine dynamische Bindung über eine Schnittstelle und wer-

den die Operationen entfernt, so gibt es genauso einen Compilerfehler, wie wenn es einen Zu-

griff auf ein Annotationselement gibt, und es dann gelöscht wird. Auch das Ändern von

Elementtypen führt im Allgemeinen zu Compilerfehlern, denn wenn aus einem int plötzlich

ein String wird, fehlen Anführungszeichen.

Standardwerte sind für Annotationen ein sehr wichtiges Instrument, um neue Annotations-

elemente schmerzfrei einzuführen. Werden neue Elemente in bestehende Annotationstypen

eingefügt, dann müssten alle existierenden konkreten Annotationen das neue Element set-

3 Es sei denn, es wird seit Java 6 die Annotation @Override für die implementierten Methoden verwendet.



1276

zen, was eine sehr große Änderung ist, vergleichbar einer neuen Operation in einer Schnitt-

stelle. Anders als bei Schnittstellen lösen Default-Werte das Problem, da auf diese Weise für

das neue Element immer gleich ein Wert vorhanden ist, der, sofern erwünscht, neu belegt

werden kann. Ohne Probleme ist es möglich, einen Default-Wert hinzuzunehmen, während

das Entfernen von Standardwerten wiederum kritisch ist.

18.5.8 Annotieren von Annotationstypen

Von den in Java 5 eingeführten Annotationen haben wir die drei Typen aus dem Paket

java.lang schon kennengelernt. Die restlichen vier Annotationen aus dem Paket

java.lang.annotation dienen dazu, Annotationstypen zu annotieren. In diesem Fall wird von

Meta-Annotationen gesprochen.

@Target

Die Annotation @Target beschreibt, wo eine Annotation angeheftet werden kann. Ist kein aus-

drückliches @Target gewählt, gilt es für alle Elemente.

Die Aufzählung java.lang.annotation.ElementType deklariert die folgenden Ziele:

Annotation Beschreibung

@Target Was lässt sich annotieren? Klasse, Methode ...?

@Retention Wo ist die Annotation sichtbar? Nur für den Compiler oder auch für die

Laufzeitumgebung?

@Documented Zeigt den Wunsch an, die Annotation in der Dokumentation zu

erwähnen.

@Inherited Macht deutlich, dass ein annotiertes Element auch in der Unterklasse

annotiert ist.

Tabelle 18.2: Meta-Annotationen

ElementType Erlaubt Annotationen ...

ANNOTATION_TYPE an anderen Annotationstypen, was @Target(ANNOTATION_TYPE) somit

zu einer Meta-Annotation macht.

TYPE an allen Typdeklarationen, also Klassen, Schnittstellen, Aufzählungen.

CONSTRUCTOR an Konstruktoren.

Tabelle 18.3: ElementType bestimmt Orte, an denen Annotationen erlaubt sind.



1277

18

Soll eine Annotation etwa vor beliebigen Typen, Methoden, Paketen und Konstruktoren er-

laubt sein, so setzen wir Folgendes an die Deklaration der Annotation:

@Target( { TYPE, METHOD, CONSTRUCTOR, PACKAGE } )

public @interface ...

Unsere eigenen drei Annotationstypen sind nur für Attribute sinnvoll. So nutzen wir FIELD,

was hier an CurrentDateResource gezeigt wird:

@Target( java.lang.annotation.ElementType.FIELD )


Mit ElementType.TYPE ist die Annotation vor allen Typen – Klassen, Schnittstellen, Annotatio-

nen, Enums – erlaubt. Eine Einschränkung, etwa nur auf Klassen, ist nicht möglich. Interes-

sant ist die Tatsache, dass eine Unterteilung für Methoden und Konstruktoren möglich ist

und dass sogar lokale Variablen annotiert werden können.

METHOD an statischen und nicht-statischen Methoden.

FIELD an statischen Variablen und Objekt-Variablen.

PARAMETER an Parametervariablen.

LOCAL_VARIABLE an lokalen Variablen.

PACKAGE an package-Deklarationen.

Hinweis

Soll statt ElementType.FIELD einfach nur FIELD verwendet werden, so muss FIELD entspre-

chend aus ElementType statisch eingebunden werden. Damit ist folgender Programmcode eine

Alternative:

import static java.lang.annotation.ElementType.*;

import java.lang.annotation.Target;

@Target( FIELD )


ElementType Erlaubt Annotationen ...

Tabelle 18.3: ElementType bestimmt Orte, an denen Annotationen erlaubt sind. (Forts.)



1278

Annotationen für Pakete sind speziell, weil sich die Frage stellt, wo hier die Metadaten über

ein Paket stehen sollen. Eine Klasse selbst wird ja einem Paket zugeordnet – sollte das heißen,

in irgendeiner wahllosen Typdeklaration stehen dann an der package-Deklaration die Meta-

Annotationen für das Paket? Nein, denn dann würde zum einen die Annotation bei vielen

Typen vielleicht nie mehr wiedergefunden, und zum anderen gäbe es bestimmt Konflikte,

wenn aus Versehen an zwei Typen widersprüchliche Annotationen an der package-Deklara-

tion stünden. Java wählt eine andere Lösung. Es muss eine Datei mit dem Namen package-

info.java im jeweiligen Paket stehen, und dort darf die package-Deklaration annotiert sein. Da

der Dateiname schon kein Klassenname sein kann (Minuszeichen sind nicht erlaubt), wird die

Datei auch keine Typdeklaration enthalten, aber der Compiler erzeugt natürlich eine .class-

Datei für die Metadaten des Pakets. Kommentare sind selbstverständlich erlaubt, und die

Datei wurde auch schon vor Java 5 für die API-Dokumentation eines Pakets verwendet.

Dazu ein Beispiel. Ein neuer Annotationstyp AutomaticUmlDiagram soll deklariert werden, und

er soll nur an Paketen gültig sein:

Listing 18.22: com/tutego/insel/annotation/AutomaticUmlDiagram.java

package com.tutego.insel.annotation;

import java.lang.annotation.*;

@Target( value = ElementType.PACKAGE )

public @interface AutomaticUmlDiagram {}

Das Paket com.tutego.insel.annotation soll nun mit AutomaticUmlDiagram annotiert werden:

Listing 18.23: com/tutego/insel/annotation/package-info.java

@AutomaticUmlDiagram


Die Datei package-info.java ist schlank, wird aber in der Regel größer sein, da sie das JavaDoc

des Pakets enthält.

Beispiel

Beim existierenden Annotationstyp @Override ist die Annotation @Target schön zu erkennen:

@Target( value = METHOD )

public @interface Override

Die Idee der Meta-Annotation: Es gibt nur überschriebene Methoden.



1279

18

@Retention

Die Annotation @Retention steuert, wer die Annotation sehen kann. Es gibt drei Typen, die in

der Aufzählung java.lang.annotation.RetentionPolicy genannt sind:

Þ SOURCE: Nützlich für Tools, die den Quellcode analysieren, aber die Annotationen werden

vom Compiler verworfen, sodass sie nicht den Weg in den Bytecode finden.

Þ CLASS: Die Annotationen speichert der Compiler in der Klassendatei, aber sie werden nicht

in die Laufzeitumgebung gebracht.

Þ RUNTIME: Die Annotationen werden in der Klassendatei gespeichert und sind zur Laufzeit in

der JVM verfügbar.

Die Unterscheidung haben die Java-Designer vorgesehen, da nicht automatisch jede Annota-

tion zur Laufzeit verfügbar ist (eine Begründung: andernfalls würde es den Ressourcenver-

brauch erhöhen). Der Standard ist RetentionPolicy.CLASS.

Für den Zugriff auf die Annotationen gibt es dann, je nach Retention-Typ, unterschiedliche

Varianten. Im Fall von Source ist es ein Tool, das auf Textebene arbeitet, also etwa ein Compi-

ler oder ein statisches Analysetool, das Quellcode analysiert. Sind die Annotationen im Byte-

code abgelegt, so lassen sie sich über ein Werkzeug beziehungsweise eine Bibliothek auslesen.

Zwei Wege sind möglich: zunächst über die Pluggable Annotation Processing API und dann

über rohe Tools, die direkt auf der Ebene vom Bytecode arbeiten. Im ersten Fall gibt es eine

eigene API, die das Erfragen einfach macht. Die zweite Lösung sind Bytecode-Bibliotheken,

wie etwa ASM (unter http://asm.ow2.org/), die alles auslesen können, was in der Klassendatei

Beispiel

Der Annotationstyp @Deprecated ist nur für den Compiler und nicht für die Laufzeit von Inter-

esse:

@Retention( value = SOURCE )

public @interface Deprecated

Ist ein Element mit @Target annotiert, so soll diese Information auch zur Laufzeit vorliegen:

@Retention( value = RUNTIME )

@Target( value = ANNOTATION_TYPE )

public @interface Target

Das Beispiel zeigt, dass die Anwendung auch rekursiv sein kann (natürlich auch indirekt rekur-

siv, denn nicht nur @Retention annotiert @Target, auch @Target annotiert @Retention).



1280

steht, also auch die Annotationen. Sie sind aber proprietär und nicht einfach zu nutzen. Die

dritte Variante ist einfach, da hier Reflection eine Möglichkeit bietet. Das schauen wir uns

gleich im Anschluss in Abschnitt 18.5.10, »Annotierte Elemente auslesen«, an.

@Documented

Die Annotation @Documented zeigt an, dass die Annotation in der API-Dokumentation genannt

werden soll. Alle Standard-Annotationen von Java werden so angezeigt, auch @Documented

selbst. In der API-Dokumentation ist für die Annotationen ein neues Segment vorgesehen.

18.5.9 Deklarationen für unsere Ressourcen-Annotationen

Da unsere drei Annotationen zur Laufzeit ausgelesen werden sollen, muss die @Retention mit

RetentionPolicy.RUNTIME gesetzt sein. Damit sind unsere Annotationstypen vollständig, und

der Quellcode soll an dieser Stelle aufgeführt werden.

Der einfachste Annotationstyp war CurrentDateResource:

Listing 18.24: com/tutego/insel/annotation/CurrentDateResource.java, CurrentDateResource

@Documented

@Target( ElementType.FIELD )

@Retention( RetentionPolicy.RUNTIME )


Der Annotationstyp ListOfFilesResource erwartet eine Pfadangabe, ist aber nicht deutlich

komplexer als CurrentDateResource:

Listing 18.25: com/tutego/insel/annotation/ListOfFilesResource.java, ListOfFilesResource

@Documented



public @interface ListOfFilesResource

Beispiel

@Documented ist selbst @Documented:

@Documented

@Target( value = ANNOTATION_TYPE )

public @interface Documented



1281

18

{

String value();

}

Und zu guter Letzt: Der Annotationstyp UrlResource hat am meisten zu bieten. Doch beginnen

wir zunächst mit der Deklaration der Schnittstelle für die Konverter:

Listing 18.26: com/tutego/insel/annotation/ResourceConverter.java, ResourceConverter

public interface ResourceConverter

{

String convert( String input );

}

Zwei Implementierungen sollen für das Beispiel genügen:

Listing 18.27: com/tutego/insel/annotation/SortConverter.java, SortConverter

public class RemoveNoWordCharactersConverter implements ResourceConverter

{

@Override public String convert( String input )

{

return input.replaceAll( "\\W", "" );

}

}

Listing 18.28: com/tutego/insel/annotation/SortConverter.java, SortConverter

public class SortConverter implements ResourceConverter

{

@Override public String convert( String input )

{

char[] chars = input.toCharArray();

Arrays.sort( chars );

return new String( chars );

}

}

Damit kann dann der letzte Annotationstyp übersetzt werden:

Listing 18.29: com/tutego/insel/annotation/UrlResource.java, UrlResource

@Documented




1282



{

enum UpperLowerCase { UNCHANGED, LOWERCASE, UPPERCASE }

String value();

boolean trim() default false;

UpperLowerCase upperLowerCase() default UpperLowerCase.UNCHANGED;

Class<? extends ResourceConverter>[] converter() default { };

}

18.5.10 Annotierte Elemente auslesen

Ob eine Klasse annotiert ist, erfragt ganz einfach die Methode isAnnotationPresent() auf dem

Class-Objekt:

println( String.class.isAnnotationPresent( Deprecated.class ) ); // false

println( StringBufferInputStream.class.isAnnotationPresent( Deprecated.class ) ); // true

Da unterschiedliche Dinge annotierbar sind, schreibt eine Schnittstelle AnnotatedElement für

die Klassen Class, Constructor, Field, Method, Package und AccessibleObject folgende Operatio-

nen vor:

Þ <T extends Annotation> T getAnnotation(Class<T> annotationType)

Liefert die Annotation für einen bestimmten Typ. Ist sie nicht vorhanden, dann ist die

Rückgabe null. Der generische Typ ist bei der Rückgabe hilfreich. Denn das Argument ist ein

Class-Objekt, das den Annotationstyp repräsentiert. Die Rückgabe ist genau die konkrete

Annotation für das annotierte Element.

Þ boolean isAnnotationPresent(Class<? extends Annotation> annotationType)

Gibt es die angegebene Annotation?

Þ Annotation[] getAnnotations()

Liefert die an dem Element festgemachten Annotationen. Gibt es keine Annotation, ist das

Feld leer. Die Methode liefert auch Annotationen, die aus den Oberklassen kommen.

Þ Annotation[] getDeclaredAnnotations()

Liefert die Annotationen, die exakt an diesem Element festgemacht sind.

interface java.lang.reflect.AnnotatedElement



1283

18

Um die Annotationen etwa von Variablen oder Methoden zu erfragen, ist ein wenig Reflec-

tion-Wissen nötig. Ist obj ein Objekt, so findet folgende Schleife alle mit CurrentDateResource

annotierten Objektvariablen und gibt eine Meldung aus:

for ( Field field : obj.getFields() )

if ( field.isAnnotationPresent( CurrentDateResource.class ) )

System.out.println( "CurrentDateResource gesetzt" );

18.5.11 Auf die Annotationsattribute zugreifen

Um auf die einzelnen Attribute einer Annotation zuzugreifen, müssen wir etwas mehr über

die Umsetzung einer Annotation von Compiler und der JVM wissen. Übersetzt der Compiler

einen Annotationstyp, generiert er daraus eine Schnittstelle.

Rufen wir auf einem AnnotatedElement, etwa Field, eine Methode wie getAnnotation() auf, be-

kommen wir ein Objekt, das Zugriff auf unsere Element-Werte-Paare liefert. Denn zur Laufzeit

werden über java.lang.reflect.Proxy Objekte gebaut, die unsere Schnittstelle – das ist ListOf-

FilesResource – implementiert und so die Methode value() anbietet.

Testen wir die Möglichkeit, indem wir zwei annotierte Variablen in eine Klasse setzen und

dann per Reflection über alle Variablen laufen und alle Annotationen erfragen lassen:

Beispiel

Für den Annotationstyp ListOfFilesResource generiert der Compiler:

import java.lang.annotation.Annotation;

public interface ListOfFilesResource extends Annotation

{

public abstract String value();

}

Hinweis

Die Annotation ist zur Laufzeit ein Proxy-Objekt, und daher kann der Annotationstyp keine

eigene Klasse erweitern und auch keine anderen eigenen Schnittstellen implementieren. Ein

Annotationstyp kann auch keine anderen Annotationstypen erweitern. Es könnte eine eigene

Klasse zwar die Schnittstelle java.lang.annotation.Annotation implementieren, doch ent-

steht dadurch keine echte Annotation, was den Versuch sinnlos macht.



1284

Listing 18.30: com/tutego/insel/annotation/GetTheUrlResourceValues.java, GetTheUrlResourceValues

public class GetTheUrlResourceValues

{


upperLowerCase = UpperLowerCase.UPPERCASE, trim = true,

converter = { RemoveNoWordCharactersConverter.class, SortConverter.class }

)


@XmlValue @Deprecated

public String xmlValue;


{

for ( Field field : GetTheUrlResourceValues.class.getFields() )

for ( Annotation a : field.getAnnotations() )

System.out.println( a );

}

}

Die Ausgabe zeigt drei Annotationen:

@com.tutego.insel.annotation.UrlResource(converter=[class com.tutego.insel.annotation.ðRemoveNoWordCharactersConverter, class com.tutego.insel.annotation.SortConverter], ðtrim=true, upperLowerCase=UPPERCASE, value=http://tutego.de/aufgaben/bond.txt)

@javax.xml.bind.annotation.XmlValue()

@java.lang.Deprecated()

Die Default-Werte werden zur Laufzeit gesetzt.

18.5.12 Komplettbeispiel zum Initialisieren von Ressourcen

Zusammenfassend können wir jetzt eine Klasse vorstellen, die tatsächlich die mit den Res-

sourcen-Annotationen versehenen Variablen mit sinnvollem Inhalt füllt. Zunächst betrach-

ten wir ein Beispiel, das die Nutzung einer solchen Klasse aufzeigt.

Die Klasse Resources bildet den Rahmen für Objekte, die automatisch aufgebaut und korrekt

initialisiert werden sollen:



1285

18

Listing 18.31: com/tutego/insel/annotation/AnnotatedResourceExample.java, Resources

class Resources

{

@CurrentDateResource()

public Date now;

@ListOfFilesResource( value = "c:/" )

public String[] files;



}

Einer zweiten Klasse geben wir ein main() und setzen dort die Aufforderung, ein Objekt vom

Typ Resources anzulegen und zu initialisieren:

Listing 18.32: com/tutego/insel/annotation/AnnotatedResourceExample.java,

AnnotatedResourceExample

public class AnnotatedResourceExample

{


{

Resources resources =

ResourceReader.getInitializedResourcesFor( Resources.class );

System.out.println( resources.now );

System.out.println( Arrays.toString( resources.files ) );

System.out.println( resources.testFile );

}

}

Kommen wir zum Herzen, der Klasse ResourceReader:

Listing 18.33: com/tutego/insel/annotation/ResourceReader.java, ResourceReader


import java.io.File;

import java.lang.reflect.Field;

import java.net.URL;

import java.util.Date;



1286

import java.util.Scanner;

public class ResourceReader

{

public static <T> T getInitializedResourcesFor( Class<T> ressources )

{

try

{

T newInstance = ressources.newInstance();

for ( Field field : ressources.getFields() )

{


field.set( newInstance, new Date() );

else if ( field.isAnnotationPresent( ListOfFilesResource.class ) )

field.set( newInstance, new File(field.getAnnotation(

ListOfFilesResource.class ).value().toString()).list() );

else if ( field.isAnnotationPresent( UrlResource.class ) )

{

String url = field.getAnnotation( UrlResource.class ).value();

String content = new Scanner( new URL(url).openStream() )

.useDelimiter( "\\z" ).next();

if ( field.getAnnotation( UrlResource.class ).trim() )

content = content.trim();

switch ( field.getAnnotation( UrlResource.class ).upperLowerCase() )

{

case UPPERCASE: content = content.toUpperCase(); break;

case LOWERCASE: content = content.toLowerCase(); break;

default: // Nichts zu tun

}

Class<? extends ResourceConverter>[] converterClasses =

field.getAnnotation( UrlResource.class ).converter();

for ( Class<? extends ResourceConverter>

converterClass : converterClasses )

content = converterClass.newInstance().convert( content );



1287

18

field.set( newInstance, content );

}

}

return newInstance;

}

catch ( Exception e )

{

return null;

}

}

}

An den folgenden Anweisungen ist das Prinzip gut ablesbar:

T newInstance = ressources.newInstance();

for ( Field field : ressources.getFields() )


field.set( newInstance, new Date() );

Zunächst wird ein neues Exemplar, ein Behälter, aufgebaut. Dann läuft eine Schleife über alle

Variablen. Gibt es zum Beispiel die Annotation CurrentDateResource an einer Variablen, so

wird ein Date-Objekt aufgebaut und mit set() die Variable mit dem Datum initialisiert.

18.5.13 Mögliche Nachteile von Annotationen

Annotationen sind eine gewaltige Neuerung und sicherlich die wichtigste seit vielen Java-Jah-

ren. Auch wenn die Generics auf den ersten Blick bedeutsam erscheinen, sind die Annotatio-

nen ein ganz neuer Schritt in die deklarative Programmierung, wie sie Frameworks schon

heute aufzeigen. Völlig problemlos sind Annotationen allerdings nicht, und so müssen wir

etwas Wasser in den Wein gießen:

Þ Die Annotationen sind stark mit dem Quellcode verbunden, können also auch nur dort ge-

ändert werden. Ist der Original-Quellcode nicht verfügbar, etwa weil der Auftraggeber ihn

geschlossen hält, ist eine Änderung der Werte nahezu unmöglich.

Þ Wenn Annotationen allerdings nach der Übersetzung nicht mehr geändert werden kön-

nen, stellt das bei externen Konfigurationsdateien kein Problem dar. Externe Konfigura-

tionsdateien können ebenso den Vorteil bieten, dass die relevanten Informationen auf



1288

einen Blick erfassbar sind und sich mitunter nicht redundant auf unterschiedliche Java-

Klassen verteilen.

Þ Klassen mit Annotationen sind invasiv und binden auch die Implementierungen an einen

gewissen Typ, wie es Schnittstellen tun. Sind die Annotationstypen nicht im Klassenpfad,

kommt es zu einem Compilerfehler.

Þ Bisher gibt es keine Vererbung von Annotationen: Ein Annotationstyp kann keinen ande-

ren Annotationstyp erweitern.

Þ Die bei den Annotationen gesetzten Werte lassen sich zur Laufzeit erfragen, aber nicht mo-

difizieren.

Þ Warum werden Annotationen mit @interface deklariert, einer Schreibweise, die in Java

sonst völlig unbekannt ist?

Ein Problem gibt es allerdings nur bei finalen statischen Variablen (Konstanten), das bei den

Default-Werten der Annotationen nicht vorkommt: Weil die Default-Werte zur Laufzeit ge-

setzt werden, lassen sie sich in der Deklaration vom Annotationstyp leicht ändern, und eine

Neuübersetzung des Projekts kann somit unterbleiben.

Zur Ehrenrettung sei erwähnt, dass moderne Frameworks wie JPA oder JSF 2 aus dem Java EE-

Standard immer noch den Einsatz von XML vorsehen. So lässt sich auf Annotationen verzich-

ten bzw. XML einsetzen, sodass Zuweisungen aus den Annotationen überschrieben werden

können.

18.6 Zum Weiterlesen

Reflection ist ein mächtiges Werkzeug, aber wie alle Werkzeuge kann es leicht missbraucht

werden. Oftmals wird in der Softwareentwicklung eine weitere Zwischenschicht zur Abstrak-

tion gezogen und alles generisch gehalten – die Konsequenz ist unwartbare Software. Die

Bedeutung von Annotationen wurde am Anfang sicherlich unterschätzt, aber mittlerweile

sind sie ein unverzichtbares Sprachmittel. Leser können die Möglichkeiten an folgenden

Frameworks ablesen: args4j (https://args4j.dev.java.net/), JPA, EJB 3.0, JAXB, JSefa (http://

jsefa.sourceforge.net/). Mit der Pluggable Annotation Processing API lassen sich interessante

Lösungen erzielen, etwa auf den internen AST vom Java-Compiler zugreifen; zwei sehr krea-

tive Lösungen zeigt http://tutego.de/go/beyond269/ auf.


1411

Index

Index

#IMPLIED ............................................................. 538

#REQUIRED ......................................................... 538

%tD ......................................................................... 346

%tR ......................................................................... 346

%tT ......................................................................... 346

&amp ..................................................................... 534

&apos .................................................................... 534

&gt .......................................................................... 534

&lt ........................................................................... 534

&quot .................................................................... 534

, Ant ..................................................................... 1344

.class .................................................................... 1229

.java.policy ........................................................ 1364

.keystore ............................................................ 1369

.NET Remoting ................................................. 1037

@CookieParam, Annotation ....................... 1070

@deprecated .................................................... 1227

@Documented, Annotation ........................ 1280

@GET, Annotation ......................................... 1062

@Inject, Annotation ...................................... 1225

@javax.management.MXBean,

Annotation ................................................... 1332

@NotNull, Annotation .................................. 1208

@OneWay, Annotation ................................. 1074

@Override, Annotation ................................ 1268

@Path, Annotation ........................................ 1062

@PathParam, Annotation ............................ 1069

@Produces, Annotation ............................... 1062

@QueryParam, Annotation ......................... 1070

@Retention, Annotation .............................. 1279

@SOAPBinding, Annotation ....................... 1074

@SuppressWarnings, Annotation ............. 1268

@Target, Annotation ..................................... 1276

@Transient, Annotation ................................. 558

@WebMethod, Annotation ......................... 1074

@WebParam, Annotation ............................ 1074

@WebResult, Annotation ............................ 1074

@WebService, Annotation ........................... 1074

@XmlAccessorType, Annotation .................. 557

@XmlAttribute, Annotation .......................... 558

@XmlElement, Annotation ............................ 551

@XmlElementRef, Annotation ..................... 565

@XmlElementRefs, Annotation ................... 565

@XmlElementWrapper, Annotation ........... 560

@XmlJavaTypeAdapter, Annotation ........... 561

@XmlList, Annotation ..................................... 559

@XmlRootElement, Annotation ......... 549, 564

@XmlType, Annotation .................................. 558

@XmlValue, Annotation ................................ 559

[L ........................................................................... 1234

1.1.1970 ................................................................ 307

1099, Port rmiregistry .................................... 1046

200, OK HTTP-Statuscode ............................. 1004

404, Not Found HTTP-Statuscode ............... 1004

80, HTTP-Port ..................................................... 999

8080, HTTP-Port ................................................. 999

A

Abstract Syntax Notation One .................... 1369

AbstractAction, Klasse ..................................... 695

AbstractBorder, Klasse ..................................... 699

AbstractButton, Klasse .................................... 680

AbstractTableModel, Klasse ........................... 792

Accelerator .......................................................... 753

accept(), ServerSocket ...................................... 990

Access Controller ............................................. 1355

Accessible, Schnittstelle .................................. 854

AccessibleObject, Klasse ..................... 1244, 1262

Action, Schnittstelle ................................ 695, 751

ACTION_PERFORMED, ActionEvent ............ 674

Action-Command .............................................. 682

ActionListener, Schnittstelle ....... 662, 676, 678

Activatable, Klasse .......................................... 1055

Activation Daemon ........................................ 1055

activation.jar ..................................................... 1021

Adapter ................................................................. 201

Adapter, MBean ............................................... 1325

Adapterklasse ..................................................... 668

add(), Container ........................................ 653, 697

addActionListener(), JButton ......................... 678

addItem(), JComboBox .................................... 776


Index

1412

addKeyListener(), Component ...................... 703

addWindowListener() ....................................... 666

Adjustable, Schnittstelle ................................. 736

AdjustmentEvent, Klasse ................................ 734

AdjustmentListener, Schnittstelle ............... 737

Adleman, Leonard M. ..................................... 1371

Adler32, Klasse ................................................... 502

Adobe Flash ....................................................... 1124

Affine Transformation .................................... 941

AffineTransform, Klasse .................................. 942

Age, Response-Header ................................... 1005

AIFF ........................................................................ 641

Al-Chwârismî, Ibn Mûsâ .................................. 175

AlgorithmParameterSpec, Schnittstelle ... 1376

Algorithmus ........................................................ 175

-alias .................................................................... 1369

Allgemeines Semaphor ................................... 139

allowSystemProperty ..................................... 1365

AllPermission ................................................... 1366

AlphaComposite, Klasse .................................. 907

AlreadyBoundException ............................... 1049

AM_PM, Calendar .............................................. 329

Anmelde-/Versendesystem ......................... 1055

AnnotatedElement, Schnittstelle .... 1253, 1282

Annotiert ........................................................... 1228

Ant ....................................................................... 1393

Antialiasing ................................................ 871, 941

ANY ........................................................................ 537

Apache Commons BeanUtils ....................... 1262

Apache Commons Collections ...................... 304

Apache Commons Compress ......................... 626

Apache Commons DBCP ............................... 1198

Apache Commons IO ............................... 368, 434

Apache Commons Logging ........................... 1323

Apache Commons Net ..................................... 998

Apache Commons Primitives ........................ 208

Apache CXF ........................................................ 1073

Apache POI .......................................................... 622

Appendable, Schnittstelle ............................... 451

Apple, Look and Feel ......................................... 832

Applet ................................................................. 1125

AppletContext ......................................... 641, 1129

APRIL, Calendar .................................................. 323

Ära .......................................................................... 350

Arc2D, Klasse .............................................. 888–889

Area, Klasse .......................................................... 890

AreaAveragingScaleFilter ................................ 929

ARM-Block ............................................................. 51

Array, Klasse ..................................................... 1240

ArrayBlockingQueue, Klasse .......................... 287

ArrayDeque, Klasse ........................................... 222

ArrayList, Klasse ............. 176, 183, 185, 188, 197

ArrayStoreException ........................................ 205

Artefakte ............................................................... 932

Aschermittwoch ................................................. 326

asList(), Arrays ........................................... 201, 265

ASM ..................................................................... 1279

ASN.1 .................................................................. 1369

ASP (Active Server Pages) ............................. 1080

Assistive technology ......................................... 854

Assoziativer Speicher ....................................... 184

asSubclass(), Class ........................................... 1268

Astronomie .......................................................... 305

Atomar .................................................................... 99

Atomuhr ............................................................... 306

Attribute ............................................................... 533

AU ........................................................................... 641

AudioClip, Klasse ............................................... 640

AUGUST, Calendar ............................................. 323

Ausgabeformatierung ...................................... 306

Auswahlmenü ..................................................... 775

Auszeichnungssprache ........................... 531, 617

authentication required ............................... 1008

Authenticator, Klasse ....................................... 971

Authentifizierung ........................................... 1367

Auto-Commit ................................................... 1190

Automatic Resource Management (ARM) .... 51

Automatischer Bildlauf .................................... 714

Autorisierung .................................................. 1367

await(), Condition .............................................. 125

AWTEvent, Klasse .............................................. 673

AWTEventListener, Schnittstelle ................... 854

AWT-Event-Thread ................................... 672, 844

AWT-Input ............................................................. 78

AWT-Motif ............................................................. 78

Axis2 ................................................................... 1073


Index

1413

B

barrier ................................................................... 143

Base64-Encoding ............................................. 1020

Baseline ................................................................. 877

BasicFileAttributes, Schnittstelle ......... 398–399

BasicFileAttributeView,

Schnittstelle ........................................... 397, 403

BasicStroke, Klasse ............................................ 908

BatchUpdateException ................................. 1177

Bean Validation ............................................... 1207

beans.xml .......................................................... 1225

Bean-Zustände kopieren ............................... 1262

Beautifier ........................................................... 1408

Berkeley-Socket-Interface ............................... 983

Berners-Lee, Tim ................................................ 998

BevelBorder, Klasse ........................................... 699

Bézier-Kurve ........................................................ 890

Bilder skalieren ................................................... 927

Bildlaufleiste ....................................................... 733

Binäre Suche (binary search) .......................... 278

Binäres Semaphor ............................................. 139

Binärsystem .......................................................... 41

binarySearch(), Arrays ...................................... 264

bind(), Registry ................................................ 1048

Biometrisches System ................................... 1368

Birrel ................................................................... 1035

Bitmenge .............................................................. 299

BitSet, Klasse ....................................................... 299

Bitttage .................................................................. 326

Bitweise Manipulation ..................................... 299

BlockingQueue, Schnittstelle ................ 223, 287

Bootstrap Class Loader .................................. 1355

Border, Schnittstelle ......................................... 699

BorderFactory, Klasse ....................................... 700

BorderLayout, Klasse ............................... 717, 721

BoundedRangeModel, Schnittstelle ............. 734

BoxLayout ............................................................ 732

BoxLayout, Klasse ..................................... 717, 720

brighter(), Color .................................................. 901

Brightness ............................................................ 902

Bucket, Hash-Tabelle ........................................ 241

BufferedImage, Klasse ...................................... 924

BufferedInputStream, Klasse ................ 439, 471

BufferedOutputStream .................................... 469

BufferedReader, Klasse ........................... 439, 471

BufferedWriter ................................................... 469

build.xml ........................................................... 1394

ButtonGroup, Klasse ........................................ 743

ByteArrayInputStream, Klasse ...................... 467

ByteArrayOutputStream, Klasse ................... 467

ByteBuffer, Klasse ............................................. 423

Bytecode Verifier ............................................. 1355

BZip2 ............................................................ 625–626

C

Cache, Bilder ....................................................... 934

Cache-Control ................................................... 1004

CachedRowSet, Schnittstelle ........................ 1183

CAG (Constructive Area Geometry) ............. 891

Calendar, Klasse ........................................ 306, 320

Callable, Schnittstelle ......................................... 93

CallableStatement, Schnittstelle ................. 1168

Canvas .................................................................. 913

CAP_BUTT, BasicStroke ................................... 909

CAP_ROUND, BasicStroke ...................... 909, 912

CAP_SQUARE, BasicStroke .............................. 909

CardLayout, Klasse ............................................ 717

Caret ...................................................................... 685

CASE_INSENSITIVE_ORDER, String .............. 265

CDATA ................................................................... 537

CDI ....................................................................... 1224

CERN ...................................................................... 998

Certificate Authority, CA ............................... 1368

CET (Central European Time) ......................... 336

ChangeListener, Schnittstelle ........................ 733

CharArrayReader, Klasse ................................. 465

CharArrayWriter, Klasse .................................. 464

Checkbox, Klasse ............................................... 740

checkError() ......................................................... 455

Checksum, Schnittstelle .................................. 498

choice box ........................................................... 775

Christi Himmelfahrt ......................................... 326

Cipher, Klasse ................................................... 1377

CipherInputStream, Klasse ........................... 1377

CipherOutputStream, Klasse ....................... 1377

Class, Klasse ...................................................... 1228

class, Schlüsselwort ........................................ 1238

ClassLoader, Klasse ......................................... 1357


Index

1414

ClassNotFoundException ...... 1229–1230, 1242

Client ................................................................... 1038

Client, Klasse ..................................................... 1063

ClientResponse, Klasse .................................. 1064

Client-Server-Kommunikation ..................... 989

Clip-Bereich ......................................................... 867

Clipboard .................................................... 754, 836

Clipboard, Klasse ............................................... 836

Clipper ................................................................ 1372

Clipping ................................................................ 896

Clipping-Bereich ................................................ 937

Closeable, Schnittstelle .................................... 443

closePath(), Path2D ........................................... 894

Cloudscape ........................................................ 1140

Clustering, Hash-Tabelle ................................. 241

Codebase ............................................................ 1363

Codehaus XFire ................................................ 1073

Collator, Klasse ................................................... 266

Collection, Schnittstelle ......................... 176, 178

Collection-API .................................................... 175

Collections, Klasse ............................................ 176

Color, Klasse ........................................................ 897

com.sun.image.codec.jpeg, Paket ................. 915

com.sun.net.httpserver, Paket .................... 1006

com4j .................................................................. 1353

ComboBoxModel, Schnittstelle .................... 775

Command Model ............................................... 662

Component, Klasse ........................................... 697

ComponentEvent, Klasse ................................ 674

ComponentListener, Schnittstelle ............... 707

ComponentUI, Klasse ....................................... 766

Composite Pattern ............................................ 697

Composite, Schnittstelle ................................. 907

CompoundBorder, Klasse ............................... 699

CONCUR_UPDATABLE, ResultSet .... 1176, 1184

ConcurrentHashMap, Klasse ......................... 285

ConcurrentLinkedQueue, Klasse .................. 285

ConcurrentMap, Schnittstelle ....................... 284

ConcurrentModificationException ............. 259

ConcurrentSkipListMap, Klasse ........... 185, 285

ConcurrentSkipListSet, Klasse ....................... 285

Condition, Schnittstelle .................................. 125

Connection, Schnittstelle .................. 1004, 1159

Connector/J ....................................................... 1142

Connector-Level .............................................. 1325

Constraints, Validierung .............................. 1208

ConstraintValidator, Schnittstelle ............. 1217

ConstraintViolation, Schnittstelle ............. 1209

Constructor, Klasse ........................................ 1250

Contact Port ........................................................ 984

Container ............................................................. 176

contains(), Shapre .............................................. 895

containsKey(), Map ........................................... 233

Content Negotiation ...................................... 1067

Content-Encoding .......................................... 1006

Content-Handler ....................................... 965, 968

ContentHandler, Schnittstelle ....................... 583

Content-Pane ...................................................... 646

Contexts and Dependency Injection for

the Java EE platform .................................. 1224

Controller ............................................................. 765

CopyOnWriteArrayList, Klasse ............. 188, 285

CopyOnWriteArraySet, Klasse ....................... 285

CopyOption, Schnittstelle ............................... 395

CORBA (Common Object Request Broker

Architecture) ..................................... 1037, 1053

CRC32, Klasse ...................................................... 500

createCompatibleImage(),

GraphicsConfiguration ................................ 923

createDirectories(), Files .................................. 407

createDirectory(), Files ..................................... 406

createFile(), Files ................................................. 406

createGraphics(), BufferedImage .................. 924

createRegistry(), LocateRegistry ................. 1045

createStatement(), Connection ................... 1168

createSymbolicLink(), Files ............................. 407

Crimson ................................................................ 546

Cryptographic Service Provider ................. 1356

CSV (Comma-separated Values) .................... 618

CubicCurve2D, Klasse ....................................... 888

currentThread(), Thread .................................... 72

currentTimeMillis(), System ........................... 307

curveTo(), GeneralPath .................................... 891

Custom tag library .......................................... 1101

CXF, Apache ...................................................... 1073

cxxwrap ............................................................. 1352

CyberNeko ........................................................... 621

CyclicBarrier, Klasse .......................................... 143


Index

1415

D

Dämon .................................................................... 76

darker(), Color ..................................................... 901

Dash attribute ..................................................... 908

Database Management System .................. 1139

DatabaseMetaData, Schnittstelle ............... 1194

DataFlavor, Klasse ............................................. 838

Datagramm ....................................................... 1012

DatagramPacket, Klasse ................................ 1012

Datagram-Socket ............................................. 1010

DatagramSocket, Klasse ..................... 1010, 1012

DataInput, Schnittstelle .......................... 383, 506

DataInputStream, Klasse ................................. 478

DataOutput, Schnittstelle ....................... 383, 506

DataOutputStream, Klasse .............................. 478

DataSource ........................................................ 1195

DataSource, Schnittstelle ............................. 1195

DatatypeFactory, Klasse .......................... 341, 562

DATE, Calendar ................................................... 328

Date, General Header Fields ........................ 1004

Date, Klasse ................................................. 306, 317

DateFormat, Klasse ......................... 306, 346, 352

Dateiattribute ..................................................... 397

Dateiauswahldialog .......................................... 823

Dateiformat ......................................................... 617

Dateisystem-Attribute ..................................... 397

Dateiverknüpfung ............................................. 364

Datenbankausprägung .................................. 1140

Datenbankschema .......................................... 1140

Datenbankverbindung .................................. 1164

Datenbankverwaltungssystem ................... 1139

Datenbasis ........................................................ 1139

Datenkompression ............................................ 624

Datenstrukturen ................................................ 175

Datenzeiger ......................................................... 384

Datumswerte ....................................................... 306

DAY_OF_MONTH, Calendar ........................... 328

DAY_OF_WEEK, Calendar ................................ 329

DAY_OF_WEEK_IN_MONTH, Calendar ....... 329

DAY_OF_YEAR, Calendar ................................. 329

DB2 ...................................................................... 1143

dBase, JDBC ....................................................... 1155

DBMS .................................................................. 1139

-Dcom.sun.management.jmxremote ....... 1329

Deadlock .............................................................. 119

DECEMBER, Calendar ....................................... 323

Decompiler ........................................................ 1398

default, Schlüsselwort .................................... 1275

DefaultHandler, Klasse ........................... 583–584

DefaultListCellRenderer, Klasse .................... 774

DefaultListModel, Klasse ................................ 773

DefaultListModel, Schnittstelle .................... 768

DefaultMutableTreeNode, Klasse ................. 809

defaultReadObject(), ObjectInputStream ... 514

DefaultTableCellRenderer, Klasse ................ 798

DefaultTableModel, Klasse ............................. 796

defaultWriteObject(), ObjectOutput-

Stream .............................................................. 513

Deflater, Klasse .................................................. 626

Dekoration .......................................................... 649

Delegation Model .............................................. 662

delete(), Files ....................................................... 408

DELETE, HTTP-Methode ................................ 1000

deleteIfExists(), Files ......................................... 408

Dependency Injection .................................... 1221

Deployment-Descriptor ................................ 1087

Deque .................................................................... 220

Deque, Schnittstelle ................................. 184, 222

Derby .................................................................. 1140

Dereferenced-Meldung ................................. 1050

deriveFont(), Font .............................................. 880

DES (Data Encryption Standard) ................. 1375

Dezimalsystem .................................................... 41

DGC ...................................................................... 1050

Dialog ........................................................... 818–819

Digitale Unterschrift ...................................... 1371

DirectoryNotEmptyException ...................... 408

DirectoryStream, Schnittstelle ...................... 410

DirectoryStream.Filter, Schnittstelle .......... 411

Direkte ByteBuffer ............................................ 423

Distributed Component Object Model

(DCOM) .......................................................... 1037

Distributed GC ................................................. 1050

divide and conquer ........................................... 149

Divider .................................................................. 712

-Djava.rmi.dgc.leaseValue ............................ 1050

-Djava.rmi.server.codebase .......................... 1053

-Djava.security.debug .................................... 1361

-Djava.security.manager ............................... 1362


Index

1416

-Djava.security.policy .................................... 1364

-Djdbc.drivers ................................................... 1160

dll-Dateien ......................................................... 1343

DnD, Drag & Drop ............................................. 841

DNS ........................................................... 1011, 1135

Doclet ....................................................... 1228, 1390

DOCTYPE .............................................................. 539

Document Object Model ................................. 545

Document Type Definition ............................ 535

Document, Klasse .............................................. 590

DocumentBuilderFactory ............................... 547

Dokumentenformat ......................................... 620

DOM ...................................................................... 545

DOM Level 3 XPath ........................................... 607

Domain Name Server ..................................... 1135

Domain Name System ................................... 1011

Domain Specific Language (DSL) ................ 1289

DOMBuilder, Klasse .......................................... 591

Doppel-Pufferung, Swing ................................ 712

DosFileAttributes, Schnittstelle .................... 399

DosFileAttributeView, Schnittstelle ... 397, 403

Double-Buffering, Swing ................................. 712

Dozer ................................................................... 1262

Drag & Drop ........................................................ 841

draw(Shape), Graphics2D ................................ 887

draw3DRect(), Graphics ................................... 901

drawImage(), Graphics ..................................... 917

drawLine(), Graphics ........................................ 871

drawString(), Graphics ..................................... 877

Drehfeld ............................................................... 787

DriverManager, Klasse ........................ 1160, 1163

Drucken ................................................................ 944

DSAPrivateKeySpec, Klasse .......................... 1377

DST_OFFSET, Calendar ..................................... 329

DTD ........................................................................ 535

DTDHandler, Schnittstelle .............................. 583

Duration, Klasse ....................................... 342, 563

Durchschuss ....................................................... 884

-Duser.timezone ................................................ 324

Dynamic invocation ....................................... 1264

dynamic linked libraries ............................... 1343

Dynamic MBeans ............................................ 1325

Dynamische Datenstruktur ........................... 175

Dynamische Webseite ................................... 1079

Dynamischer Methodenaufruf ................... 1266

Dynamisches Layout ........................................ 651

E

EBCDIC .................................................................. 491

Echozeichen ........................................................ 686

EclipseLink ........................................................ 1201

ECML ................................................................... 1096

Editor-Kit .............................................................. 692

eFace ...................................................................... 861

Electronic Commerce Modeling

Language ....................................................... 1096

Element suchen ......................................... 278, 282

Element, Klasse .................................................. 594

Element, XML ...................................................... 533

ElementType, Aufzählung ............................ 1276

Ellipse2D, Klasse ................................................ 888

EmptyBorder, Klasse ......................................... 699

EmptyStackException ...................................... 220

End caps ................................................................ 909

Endpoint, Klasse .............................................. 1075

ENGLISH, Locale ................................................. 310

ensureCapacity(), List ....................................... 199

Entfernte Methoden ...................................... 1035

Entfernte Methodenaufrufe ........................ 1035

Entfernte Objekte ........................................... 1042

Entität ................................................................... 534

Entity .................................................................. 1005

Entity-Beans ..................................................... 1199

Entity-Body ....................................................... 1005

Entity-Header ........................................ 1002, 1005

EntityResolver, Schnittstelle .......................... 583

entrySet(), Map ................................................... 238

Enumeration, Schnittstelle ............................. 260

Enumerator ......................................................... 249

EOFException ............................................. 382, 478

ERA, Calendar ...................................................... 328

Ereignis, GUI ........................................................ 673

Ereignisauslöser ................................................. 662

Ereignisschlange ................................................ 844

ErrorHandler, Schnittstelle ............................. 583

EtchedBorder, Klasse ........................................ 699

Event Queue ........................................................ 844

Event-Dispatching-Thread .............................. 672


Index

1417

EventFilter, Schnittstelle ................................. 578

Eventquelle .......................................................... 662

EventQueue, Klasse ......................... 844, 849, 853

Event-Source ....................................................... 662

Excel-Dokumente .............................................. 623

Exchanger, Klasse .............................................. 145

executeQuery(), Statement .......................... 1168

executeUpdate(), Statement ........................ 1168

Executor, Schnittstelle ....................................... 89

ExecutorService, Schnittstelle ......................... 90

EXIT_ON_CLOSE, JFrame ................................. 647

exportObject(), UnicastRemoteObject ...... 1048

eXtensible Markup Language ......................... 532

F

Farbe ...................................................................... 897

Farbmodell ........................................................... 902

Farbsättigung ...................................................... 902

fastutil ................................................................... 208

FEBRUARY, Calendar ......................................... 323

Federal Information Processing Standards

Publication ................................................... 1372

Fenster .................................................................. 645

Fenstermenü ....................................................... 748

Field, Klasse ................................ 1243–1244, 1255

Fielding, Roy Thomas .................................... 1059

FIFO-Prinzip ......................................................... 184

File, Klasse ............................................................ 358

file.encoding ........................................................ 491

File.separatorChar ............................................. 360

FileAlreadyExistsException ............................ 406

FileAttribute, Schnittstelle .............................. 406

FileChannel, Klasse ................................... 376, 424

FileDescriptor, Klasse ....................................... 435

FileFilter, Schnittstelle ..................................... 366

FileInputStream, Klasse ................................... 431

FileNameExtensionFilter, Klasse .................. 823

FilenameFilter, Schnittstelle .......................... 366

FileOutputStream, Klasse ................................ 431

FilePermission ................................................. 1366

FileReader, Klasse .............................................. 430

FileSystem, Klasse .............................................. 386

FileSystem, Schnittstelle ................................. 416

FileSystems, Klasse ........................................... 416

FileTypeDetector, Klasse ................................. 409

FileVisitOption, Aufzählung .......................... 415

FileVisitor, Schnittstelle .................................. 413

FileVisitResult, Aufzählung ............................ 413

FileWriter, Klasse ............................................... 428

fill(), Collections ................................................. 280

FilteredRowSet, Schnittstelle ....................... 1183

FilterInputStream, Klasse ............................... 478

FilterOutputStream, Klasse ............................ 478

FilterReader, Klasse .......................................... 478

FilterWriter, Klasse ........................................... 478

final, Schlüsselwort ........................................ 1238

Fingerabdruck .................................................. 1371

FIPS ...................................................................... 1372

Firewall ............................................................... 1054

First in, First out ................................................ 184

Fitts’s Law ............................................................ 718

Five-Nine-System ............................................ 1367

Flache Kopie ........................................................ 234

FlowLayout, Klasse ................................... 717–718

Flushable, Schnittstelle ................................... 444

FocusEvent, Klasse ............................................ 674

FocusListener, Schnittstelle ........................... 702

Fokus ..................................................................... 701

Font, Klasse ................................................ 656, 878

FontFormatException ...................................... 882

FontMetrics, Klasse ........................................... 882

FontRenderContext, Klasse ............................ 885

ForkJoinPool, Klasse ......................................... 153

format() ................................................................ 455

Formatierungsanweisungen .......................... 347

Formatierungsstring ............................... 350–351

forName(), Class ............................................... 1229

Fortschrittsbalken ............................................. 745

Frame .................................................................... 645

FRANCE, Locale .................................................. 310

FRENCH, Locale .................................................. 310

Fronleichnam ..................................................... 326

FULL, DateFormat .............................................. 348

Füllfaktor ............................................................. 241

Füllmuster ........................................................... 912

Füllung, Paint ..................................................... 896

Future, Schnittstelle ........................................... 94


Index

1418

G

G1, Garbage-Collector ........................................ 60

Gebundene Property ........................................ 711

Geburtsdatum .................................................... 332

Geburtstagsparadoxon .................................. 1371

Gegenseitiger Ausschluss ......................... 99, 104

General Header ................................................ 1002

GeneralPath, Klasse .......................................... 891

-genkey ............................................................... 1369

Geordnete Liste .................................................. 183

GERMAN, Locale ................................................ 310

GERMANY, Locale .............................................. 310

get(), List ............................................................... 189

get(), Map ............................................................. 232

GET, HTTP-Methode ....................................... 1000

getAttribute(), Files ........................................... 404

getBytes(), ResultSet ....................................... 1175

getClass(), Object ............................................. 1229

getColumnClass(), TableModel ...................... 793

getColumnCount(), TableModel ................... 793

getColumnName(), TableModel .................... 793

getConnection(), DriverManager ................ 1160

getContentPane(), JFrame ............................... 646

getDefaultToolkit(), Toolkit ............................ 650

getFileAttributeView(), Files .......................... 401

getInstance(), Calendar .................................... 324

GET-Methode ............................................. 973, 999

getPriority(), Thread ........................................... 87

getProperty(), Properties ................................. 243

getResource() ...................................................... 446

getResourceAsStream() ................................... 446

getRowCount(), TableModel ........................... 793

GetStringUTFChars ......................................... 1345

getTableCellEditorComponent(),

TableCellEditor .............................................. 801

getText(), JLabel ................................................. 654

getText(), JTextComponent ............................ 685

getTimeInMillis(), Calendar ........................... 325

getValueAt(), TableModel ............................... 793

GIF .......................................................................... 914

Glass-Pane ........................................................... 815

Globbing-Syntax ................................................ 411

gluegen ............................................................... 1352

Glyphe .................................................................. 877

GMST ..................................................................... 305

GNU Trove ........................................................... 208

Google Collections Library .............................. 294

Google Guava ............................................. 294, 304

GradientPaint ..................................................... 897

grant-Anweisung ............................................ 1363

Granularität, Threads ......................................... 88

Graphics Interchange Format ........................ 914

Graphics, Klasse ................................................. 866

Graphics2D, Klasse ............................................ 866

GraphicsEnvironment, Klasse ....................... 880

Greenwich Mean Sidereal Time ..................... 305

GregorianCalendar, Klasse ..................... 320, 322

Gregorianischer Kalender ............................... 320

GridBagConstraints, Klasse ............................ 726

GridBagLayout, Klasse ............................. 717, 725

GridLayout, Klasse .................................... 717, 724

Groovy ............................................................... 1313

Groovy-Eclipse ................................................. 1313

GroupLayout, Klasse ......................................... 717

Grundlinie ........................................................... 877

Grundton ............................................................. 902

Guard ..................................................................... 131

Guarded action ................................................... 131

Guarded wait ....................................................... 131

Guava ........................................................... 294, 304

GUI-Builder ....................................................... 1227

Guice ................................................................... 1221

Gültigkeit, XML .................................................. 535

gzip ...................................................................... 1006

GZIPInputStream, Klasse ................................. 627

GZIPOutputStream, Klasse ............................. 627

H

H2 ........................................................................ 1143

Halbierungssuche .............................................. 278

Hashcode .............................................................. 241

Hash-Funktion .................................................... 241

HashMap, Klasse ....................................... 186, 229

HashSet, Klasse .......................................... 184, 213

Hash-Tabelle ........................................................ 229

Hash-Verfahren ............................................... 1371

HEAD, HTTP-Methode ................................... 1000

Header-Datei .................................................... 1341


Index

1419

HEAD-Methode ................................................... 999

Helligkeit .............................................................. 902

Hexadezimalsystem ........................................... 41

Hibernate .......................................................... 1206

Hibernate Validator ....................................... 1208

HierarchyEvent, Klasse .................................... 675

High-level event ................................................. 674

Hoare, C. A. R. ...................................................... 104

Host-Adresse ....................................................... 977

HOUR, Calendar .................................................. 329

HOUR_OF_DAY, Calendar ............................... 329

HSB ......................................................................... 902

HSQLDB ............................................................. 1141

HTML ............................................................ 531, 998

HTML-Formular .............................................. 1095

HTTP ............................................................. 957, 998

HTTP 0.9 ............................................................. 1003

HTTP 1.0 ................................................................ 999

http.proxyHost ................................................ 1008

http.proxyPort ................................................. 1008

HttpClient ............................................................ 997

HttpComponents ............................................... 997

HttpHandler, Schnittstelle ........................... 1006

HTTP-Header ....................................................... 967

https.ProxyHost .............................................. 1008

https.ProxyPort ............................................... 1008

HttpServer, Klasse .......................................... 1006

HttpServerFactory, Klasse ............................ 1063

HttpSession, Schnittstelle ............................ 1111

Hue ......................................................................... 902

Hypertext Transfer Protocol ................. 957, 998

I

ICCCM .................................................................... 837

ICMP ................................................................... 1031

ICO .......................................................................... 915

IdentityHashMap, Klasse ................................. 237

IETF ......................................................................... 957

IIOP ..................................................................... 1053

IllegalAccessException .................................. 1242

IllegalMonitorStateException ............... 129, 136

IllegalThreadStateException ............................ 67

Image, Klasse ....................................................... 914

ImageIcon, Klasse .............................................. 657

ImageIO ................................................................ 915

ImageIO, Klasse .................................................. 915

ImageObserver, Schnittstelle ........................ 918

InetAddress, Klasse ........................................... 979

InetSocketAddress, Klasse .............................. 988

Inflater, Klasse .................................................... 626

InheritableThreadLocal, Klasse ..................... 159

InputMethodEvent, Klasse ............................. 675

InputStream, Klasse ......................................... 445

InputStreamReader, Klasse ............................ 492

InstallShields .................................................... 1137

instanceof, Schlüsselwort ............................. 1235

InstantiationException ...................... 1242, 1254

instrumentalisierte Objekte ........................ 1325

Integritätsprüfung von Nachrichten ......... 1371

Inter-Client Communication Convention

Manual ............................................................. 837

Interface/Implementation-Pair .................... 792

Intermediate container ................................... 712

Internal frame .................................................... 815

Internationalisierung ...................................... 313

Internes Fenster ................................................. 815

Internet Control Message Protocol ............ 1031

Internet Engineering Task Force .................. 957

Internet Protocol ............................................... 956

Internet-Media-Types .................................... 1005

Inter-ORB Protocol .......................................... 1053

Interrupt ................................................................ 79

interrupt(), Thread ...................................... 79, 136

interrupted(), Thread ......................................... 81

InterruptedException ................ 74, 81, 126, 136

InterruptedIOException .................................. 991

Intersolv ............................................................. 1150

Introspection .................................................... 1227

invalidate(), Component ................................. 710

InvalidClassException ............................ 505, 517

Inversion of Control ....................................... 1221

Invocation API ................................................. 1353

Invocation-API ................................................. 1338

InvocationEvent, Klasse .................................. 850

InvocationTargetException .............. 1242, 1255

invoke(), Method ............................................. 1264

invokeAndWait(), SwingUtilities .................. 848

invokeLater(), SwingUtilities ................ 747, 848

Invoker-Servlet ................................................ 1117


Index

1420

IoC-Container ................................................... 1221

IP ............................................................................ 956

IP-Adresse ............................................................ 977

isCellEditable(), TableModel .................. 793, 795

isInterrupted(), Thread ...................................... 79

ISO Country Code .............................................. 309

ISO Language Code ........................................... 309

ISO-639-Code ...................................................... 309

ISO-Abkürzung ................................................... 312

ITALIAN, Locale .................................................. 310

ItemEvent, Klasse .............................................. 740

ItemListener, Schnittstelle ... 740, 742, 745, 779

ItemSelectable, Schnittstelle .......................... 741

itemStateChanged(), ItemListener ............... 742

Iterable, Schnittstelle ....................................... 187

Iterator ................................................................. 249

Iterator, Schnittstelle .............................. 249, 260

iText ...................................................................... 622

J

JAAS � Java Authentication and Authorization

Service (JAAS)

Jackson ................................................................. 620

Jad, Decompiler ................................................ 1405

Jahr ............................................................... 328, 350

JAI ........................................................................... 915

Jakarta HttpClient ............................................. 997

JANUARY, Calendar ........................................... 323

JAPAN, Locale ...................................................... 310

JAPANESE, Locale ............................................... 310

Jar-Archiv ........................................................... 1087

Jar-Datei ............................................................... 969

JarFile, Klasse ............................................. 640, 970

jarsigner, Dienstprogramm .......................... 1370

JarURLConnection, Klasse .............................. 970

Java 2D-API .......................................................... 869

Java Accessibility ............................................... 854

Java API for XML Parsing ................................. 546

Java Authentication and Authorization Service

(JAAS) ................................................... 1356, 1367

Java Cryptography Architecture ................. 1356

Java Cryptography Extension (JCE) ............ 1356

Java Database Connectivity .......................... 1148

Java DB ................................................................ 1140

Java Document Object Model ......................... 545

Java Foundation Classes (JFC) ......................... 869

Java Image Management Interface ............... 915

Java Management Beans ............................... 1325

Java Management Extensions .................... 1324

Java Message Service ..................................... 1055

Java Native Interface ...................................... 1337

Java Network Launcher Protocol ................ 1137

Java Object Serialization .................................. 502

Java OpenGL ........................................................ 953

Java Persistence API .......................................... 503

Java Persistence API (JPA) ............................. 1206

Java Plug-In ....................................................... 1123

Java Secure Socket Extension ........... 1008, 1033

Java Virtual Machine Process Status

Tool ................................................................. 1381

Java Virtual Machine Statistics

Monitoring Tool ......................................... 1382

java.awt.event, Paket ........................................ 673

java.awt.geom, Paket ........................................ 870

java.beans, Paket ................................................ 523

java.lang.management, Paket ..................... 1326

java.naming.factory.initial .......................... 1198

java.net, Paket ..................................................... 955

java.nio.file, Paket ............................................. 386

java.nio.file.attribute, Paket ........................... 397

java.rmi.server.codebase .............................. 1053

java.rmi.useCodebaseOnly .......................... 1053

java.security ..................................................... 1364

java.sql.Date, Klasse ....................................... 1173

java.sql.Time, Klasse ...................................... 1173

java.util.concurrent, Paket .............................. 286

java.util.concurrent.atomic, Paket ...... 114, 148

java.util.jar, Paket .............................................. 625

java.util.zip, Paket ..................................... 625–626

Java-Beans ......................................................... 1227

JavaBeans Activation Framework .............. 1021

JavaBeans Persistence ...................................... 502

Java-Cryptography-API ................................. 1356

JavaDoc-Tag ...................................................... 1227

JavaFX ................................................................. 1124

javah, Dienstprogramm ................................ 1341

javah-Task, Ant ................................................ 1341

Java-Look-and-Feel ............................................ 830

JavaMail API ..................................................... 1020


Index

1421

javap ................................................................... 1399

JavaScript .......................................................... 1135

JavaServer Faces .............................................. 1120

JavaServer Page ............................................... 1081

javax.crypto, Paket ......................................... 1356

javax.jws, Paket ............................................... 1074

javax.net, Paket ............................................... 1033

javax.script, Paket ................................ 1306, 1312

javax.sound, Paket .................................... 640–641

javax.sound.midi, Paket .................................. 642

javax.swing, Paket ............................................. 645

javax.swing.text, Paket .................................... 683

javax.swing.undo, Paket .................................. 842

javax.xml.bind.annotation, Paket ................ 549

Jawin ................................................................... 1353

JAXB ....................................................................... 548

JAXBContext, Klasse ......................................... 549

Jaxen ............................................................. 590, 607

JAXP .............................................................. 546–547

JAX-RPC .............................................................. 1073

JAX-RS ................................................................. 1060

JAX-RS-Injizierung .......................................... 1069

JAX-WS ............................................................... 1073

JAX-WS RI .......................................................... 1073

JBP, JavaBeans Persistence .............................. 502

JButton, Klasse ........................................... 676, 680

JCA ....................................................................... 1356

JCheckBox, Klasse .............................................. 680

JCheckBoxMenuItem, Klasse .......................... 750

jCIFS ....................................................................... 378

JComboBox, Klasse ............................................ 775

jconsole, Dienstprogramm .......................... 1328

JDBC .................................................................... 1148

JDBC 1.0 .............................................................. 1151

JDBC 2.0 API ...................................................... 1151

JDBC 2.0 Optional Package API ................... 1151

JDBC 2.1 core API ............................................. 1151

jdbc.drivers ....................................................... 1160

JDBC-ODBC-Bridge-Treiber .......................... 1149

JDBCRowSet, Schnittstelle ............................ 1182

JDesktopPane, Klasse ........................................ 815

JDialog, Klasse ..................................................... 819

JDOM ..................................................................... 545

JDOMResult, Klasse ........................................... 613

JDOMSource, Klasse .......................................... 613

JEditorPane, Klasse .................................. 683, 692

Jersey, JAX-RS Implementierung ................ 1060

Jetty ..................................................................... 1084

JFileChooser, Klasse .......................................... 823

JFormattedTextField, Klasse ................. 683, 687

JFrame, Klasse ........................................... 645, 867

JGoodies Looks ................................................... 833

Jimi ........................................................................ 915

Jindent ................................................................ 1409

JLabel, Klasse ....................................................... 653

jlGui ....................................................................... 641

JList, Klasse .......................................................... 767

jmap, Dienstprogramm ................................. 1382

JMenu, Klasse ............................................ 748, 750

JMenuBar, Klasse ............................................... 748

JMenuItem, Klasse ................................... 680, 750

JMS ....................................................................... 1055

JMX ...................................................................... 1324

JMXConnector, Schnittstelle ........................ 1336

JMXConnectorServer, Klasse ....................... 1335

JNDI ..................................................................... 1196

jndi.properties ................................................. 1196

JNI ........................................................................ 1337

Joda Time ............................................................. 355

JOGL ....................................................................... 953

join(), Thread ........................................................ 84

JOIN_BEVEL, BasicStroke ................................ 910

JOIN_MITER, BasicStroke ................................ 910

JOIN_ROUND, BasicStroke .............................. 910

JoinRowSet, Schnittstelle .............................. 1183

jOpenDocument ................................................ 624

JOptionPane, Klasse .......................................... 820

JOS, Java Object Serialization ......................... 502

JPA (Java Persistence API) ......... 503, 1199, 1206

JPA � JPA (Java Persistence API)

JPanel, Klasse ............................................. 712, 716

JPasswordField, Klasse ............................ 683, 686

JPEG ....................................................................... 914

JPopupMenu, Klasse ......................................... 760

JProgressBar, Klasse ................................. 745, 849

jps, Dienstprogramm .......................... 1328, 1381

JRadioButton, Klasse ............................... 680, 743

JRadioButtonMenuItem, Klasse .................... 750

JRMP (Java Remote Method Protocol) ....... 1053

JRootPane, Klasse .............................................. 815


Index

1422

jrunscript, Dienstprogramm ....................... 1306

JScrollBar, Klasse ...................................... 713, 734

JScrollPane ........................................................... 713

JScrollPane, Klasse ......... 691, 712–713, 769, 790

JSlider, Klasse ...................................................... 733

JSON (JavaScript Object Notation) ..... 619, 1066

JSP ........................................................................ 1081

JSpinner, Klasse .................................................. 787

JSplitPane, Klasse ..................................... 712, 715

jsr166y .................................................................. 152

JSR-203 .................................................................. 386

JSR-223 ................................................................ 1306

JSR-299 ..................................................... 1221, 1224

JSR-303:Bean Validation ................................ 1207

JSR-311 ................................................................ 1060

JSSE ...................................................................... 1008

jstack, Dienstprogramm ................................ 1383

jstat, Dienstprogramm .................................. 1382

JSTL ...................................................................... 1101

JTabbedPane, Klasse ................................ 712, 714

JTable, Klasse ...................................................... 789

JTableHeader, Klasse ........................................ 804

JTextArea, Klasse ............................................... 683

JTextComponent, Klasse ................................. 685

JTextField, Klasse ...................................... 683–684

JTextPane, Klasse ............................................... 683

JTidy ...................................................................... 621

JToggleButton, Klasse ............................. 680, 682

JToolBar, Klasse ......................................... 712, 756

JTree, Klasse ........................................................ 809

JULY, Calendar .................................................... 323

JUNE, Calendar ................................................... 323

JViewport, Klasse ............................................... 713

JWindow, Klasse ................................................. 818

JXPath ................................................................... 616

K

Kanonischer Pfad .............................................. 361

Keller ..................................................................... 218

Kerberos ............................................................. 1368

Key, Schnittstelle .................................... 184, 1375

KeyEvent, Klasse ....................................... 675, 703

KeyGenerator, Klasse ..................................... 1376

KeyListener, Schnittstelle ............................... 703

KeyPairGenerator, Klasse ............................. 1376

KeySelectionManager, Schnittstelle ............ 779

keySet(), Map ....................................................... 238

Keystore ............................................................. 1370

keytool, Dienstprogramm ............................ 1369

Klasse ..................................................................... 929

Klassenlader ..................................................... 1357

Kollision, Signatur .......................................... 1371

Kollisionsangriff ............................................. 1371

Kompressionsfunktion ................................. 1371

Kompressionsstufe ........................................... 932

Komprimierungsfaktor ................................... 914

Konstruktive Flächengeometrie ................... 891

Kontextmenü ..................................................... 759

Kontraktionsfunktion ................................... 1371

Kontrollfeldgruppe ........................................... 743

Koordinierte Weltzeit ....................................... 306

Kopfdefinition .................................................... 535

KOREA, Locale ..................................................... 310

KOREAN, Locale .................................................. 310

Kritischer Abschnitt ............................................ 99

Kryptografische Prüfsumme ....................... 1371

Kubische Kurvensegmente ............................. 890

Kurve ..................................................................... 890

L

Last-in-First-out ................................................. 218

Latin-1 ................................................................... 491

Laufwerksname .................................................. 374

LayoutManager, Schnittstelle ........................ 718

lazy activation ................................................. 1054

LD_LIBRARY_PATH ........................................ 1340

leading .................................................................. 884

Lease ................................................................... 1050

lib/security ....................................................... 1364

LIFO ........................................................................ 218

line joins ...................................................... 908, 910

line.separator ................................................... 1360

Line2D, Klasse ............................................ 887–888

LinearGradientPaint ......................................... 897

LineBorder, Klasse ............................................. 699

LineMetrics, Klasse ............................................ 885


Index

1423

LineNumberReader, Klasse ............................. 474

lineTo(), GeneralPath ........................................ 891

Linie ....................................................................... 870

Linienende ........................................................... 909

Linien-Pattern ..................................................... 908

Linienverbindung .............................................. 910

LinkedBlockingDeque, Klasse ........................ 222

LinkedBlockingQueue, Klasse ........................ 287

LinkedHashSet, Klasse ...................................... 218

LinkedList, Klasse ................... 183–185, 188, 200

LinkOption, Aufzählung .................................. 396

List, Schnittstelle ....................................... 183, 188

ListCellRenderer, Schnittstelle ....................... 774

Liste ........................................................................ 188

Liste füllen ........................................................... 280

Listener ................................................................. 662

ListIterator, Schnittstelle ................................. 202

ListSelectionEvent, Klasse ...................... 769, 771

ListSelectionListener, Schnittstelle ..... 769, 771

ListSelectionModel, Schnittstelle ................. 805

Load Factor .......................................................... 241

load(), System ................................................... 1340

loadLibrary(), System ..................................... 1339

Locale ..................................................................... 310

Locale, Klasse ...................................................... 309

LocateRegistry, Klasse ................................... 1045

Location, Response-Header ......................... 1005

Lock ............................................................... 104, 114

lock(), Lock ........................................................... 106

Lock-free-Algorithmus ..................................... 284

Locking .................................................................. 376

log4j ......................................................... 1315, 1320

Logback .............................................................. 1324

logClass .............................................................. 1049

Logging, RMI .................................................... 1049

Login-Modul ..................................................... 1367

Logisch atomar ................................................... 128

Log-Level ........................................................... 1317

lokale Objekte .................................................. 1042

Lokaler Host ........................................................ 980

Lokalisierung ...................................................... 313

LONG, DateFormat ............................................ 348

Low-level event .................................................. 674

M

MAC ..................................................................... 1371

MAC-Adresse .................................................... 1032

Magische Zahlenwerte ................................... 1238

Mail User Agent ............................................... 1019

MalformedURLException ............................... 959

Management Interface .................................. 1325

ManagementFactory, Klasse ........................ 1330

Manipulation Detection Code ..................... 1371

Map, Schnittstelle ........................... 176, 185, 228

Map.Entry, Klasse .............................................. 239

MappedByteBuffer, Klasse .............................. 425

MARCH, Calendar .............................................. 323

Markierungsschnittstelle ............................... 508

Marshaller, Schnittstelle ................................. 549

Marshalling ....................................................... 1038

MatteBorder, Klasse ......................................... 699

Mausrad ............................................................... 705

Maven ................................................................. 1393

max(), Collections ............................................. 267

MAX_PRIORITY, Thread .................................... 87

MAY, Calendar .................................................... 323

MBean ................................................................. 1325

MBean-Server ................................................... 1325

MD ....................................................................... 1371

MD2 ..................................................................... 1371

MD4 ..................................................................... 1371

MD5 ..................................................................... 1371

MDC ..................................................................... 1371

MediaTracker, Klasse ....................................... 934

MediaType, Klasse ........................................... 1062

MEDIUM, DateFormat ..................................... 348

Megginson, David ............................................. 545

Memory Map .................................................... 1382

Menü ..................................................................... 748

Menübalken ........................................................ 748

Menüeintrag ....................................................... 748

Menütrennlinie ................................................. 750

Merant ................................................................ 1150

Meridian .............................................................. 305

Message Authentication Code ..................... 1371

Message Integrity Check ............................... 1371

Message Queues .............................................. 1055

Message Store ................................................... 1019


Index

1424

Message Transfer Agent ................................ 1019

Message Transfer System ............................. 1019

Message-Digest ................................................ 1371

MessageDigest, Klasse ................................... 1372

Metadaten .............................................. 1003, 1191

META-INF/services ......................................... 1222

Meta-Information ........................................... 1005

Metal, Look and Feel ......................................... 830

Meta-Objekt ...................................................... 1228

Meta-Programming ........................................ 1227

Method, Klasse ................................................. 1246

Methode des Aufrufes .................................... 1000

MIC ...................................................................... 1371

Microsoft Access .............................................. 1143

Microsoft Silverlight ...................................... 1124

Microsoft SQL Server ...................................... 1143

Middleware ....................................................... 1040

MIDI ....................................................................... 642

MidiSystem, Klasse ........................................... 642

MILLISECOND, Calendar .................................. 329

Millisekunde ....................................................... 329

MIME ................................................................... 1020

MimeMultipart, javax.mail .......................... 1028

MIME-Nachrichten ......................................... 1003

MIME-Typ ............................................................ 968

min(), Collections .............................................. 267

MIN_PRIORITY, Thread ..................................... 87

Minute .................................................................. 329

MINUTE, Calendar ............................................. 329

Mitteleuropäische Zeit (MEZ) ........................ 336

Mnemonic ........................................................... 753

Modal .................................................................... 819

Model .................................................................... 765

Model MBeans .................................................. 1325

Model-View-Controller .................................... 765

Modifizierer ...................................................... 1238

Monat ................................................................... 328

Monitor ................................................................ 104

monitorenter ...................................................... 104

monitorexit ........................................................ 104

Monitoring ........................................................ 1324

MONTH, Calendar ............................................. 328

Mouse wheel ....................................................... 705

MouseEvent, Klasse .......................................... 675

MouseListener, Schnittstelle ......................... 662

MouseMotionListener, Schnittstelle ........... 662

MouseWheelEvent, Klasse .............................. 705

MS ........................................................................ 1019

MTA ..................................................................... 1019

MTS ..................................................................... 1019

MUA .................................................................... 1019

Multicast-Kommunikation .......................... 1033

Multi-catch ............................................................ 44

Multi-Map ............................................................ 295

Multi-Menge ....................................................... 295

MULTIPLE_INTERVAL_SELECTION,

ListSelectionModel ....................................... 771

Multipurpose Internet Mail

Extensions .................................................... 1020

Multi-Set ............................................................... 295

MutableTreeNode, Schnittstelle .................... 809

Mutex .................................................................... 104

MVC ....................................................................... 765

MXBeans ............................................................ 1325

MySQL ................................................................ 1142

N

Namensdienst ....................................... 1038, 1045

Namensraum ...................................................... 542

Native Methode ............................................... 1337

Native Protocol All-Java Driver ................... 1150

native, Schlüsselwort ..................................... 1338

Native-API Java Driver ................................... 1150

Natürliche Ordnung .......................................... 263

NavigableMap, Schnittstelle .................. 185, 230

NavigableSet, Schnittstelle ............................. 216

Navigation ........................................................... 701

Nearest neighbor algorithm ........................... 929

Nelson ................................................................ 1035

NetPermission ................................................. 1366

netstat ................................................................... 989

Network Filesystem ....................................... 1011

network-address.cache.ttl, Property ............ 981

NetworkInterface, Klasse ................................. 981

Netz-Protokoll All-Java Driver .................... 1151

new, Schlüsselwort ......................................... 1253

newDirectoryStream(), Files .................. 410–411

newInstance(), Array ...................................... 1240

newInstance(), Constructor ......................... 1253


Index

1425

newLine(), BufferedWriter .............................. 471

NFS ...................................................................... 1011

Nicht ausführend ............................................... 126

Nicht direkte ByteBuffer .................................. 423

Nicht-modal ........................................................ 819

Nimbus, Look and Feel ..................................... 830

NIO.2 ...................................................................... 386

NO_SUCH_PAGE, Printable ............................ 945

NoClassDefFoundError ................................. 1230

NoSuchAlgorithmException ....................... 1373

NoSuchElementException ..................... 221, 249

NoSuchFieldException .................................. 1242

NoSuchMethodException ............................ 1242

NoSuchProviderException ........................... 1373

notify(), Object ........................................... 124, 135

notifyAll() ............................................................. 128

NotSerializableException .............. 505, 508, 510

NOVEMBER, Calendar ....................................... 323

Null Object Pattern ............................................ 274

NULL, SQL .......................................................... 1175

O

Oberklasse finden ........................................... 1236

Oberlänge ............................................................. 884

Obfuscator .................................. 1230, 1398, 1406

Object Management Group .............. 1037, 1053

Object Serialization Stream Protocol ........... 511

ObjectInputStream, Klasse .............................. 505

ObjectName, Klasse ........................................ 1333

ObjectOutputStream, Klasse .......................... 504

ObjectStreamField, Klasse ............................... 511

Objekt-relationales Mapping ......................... 503

Observer-Pattern ............................................... 765

Ocean, Look and Feel ........................................ 830

OCTOBER, Calendar ........................................... 323

ODBC ....................................................... 1144, 1149

ODBC-Datenquellen-Administrator .......... 1144

ODF Toolkit .......................................................... 624

ODF, OpenDocument ....................................... 624

Oktalsystem .......................................................... 41

Olsen-Datenbank ............................................... 339

OMG (Object Management Group) ............ 1037

Opak ....................................................................... 711

Open Database Connectivity Standard .... 1149

Open MBeans ................................................... 1325

OpenDocument ................................................. 624

openStream(), URL ............................................ 963

OperatingSystemMXBean,

Schnittstelle .................................................. 1326

Optionale Operation ........................................ 273

Optionsfeld ......................................................... 743

Oracle Database ............................................... 1143

OracleDriver ..................................................... 1162

org.jdom, Paket .................................................. 589

OR-Mapping ........................................................ 503

Ostersonntag ...................................................... 326

OutputStream, Klasse ...................................... 441

OutputStreamWriter, Klasse .......................... 491

OverlayLayout, Klasse ...................................... 732

P

P2P ....................................................................... 1055

Pack200 ................................................................ 625

PAGE_EXISTS, Printable .................................. 945

paint(), Frame ..................................................... 865

Paint, Schnittstelle ............................................ 896

paintComponent() ............................................ 867

Palmsonntag ....................................................... 326

Parsed Character Data ...................................... 537

ParseException .................................................. 353

Passionssonntag ................................................ 326

Path, Klasse ......................................................... 386

Paths, Klasse ....................................................... 386

PCDATA ................................................................ 537

PDFBox ................................................................. 622

Peer-Elemente .................................................... 845

Permissions ...................................................... 1366

Persistence Unit ............................................... 1203

PersistenceDelegate, Klasse ........................... 525

Persistenz ............................................................ 502

Pfad ........................................................................ 891

Pfingstsonntag ................................................... 326

PHP ...................................................................... 1080

PipedInputStream, Klasse .............................. 494

PipedOutputStream, Klasse ........................... 494

PipedReader, Klasse .......................................... 494

PipedWriter, Klasse ........................................... 494

Plain Old Java Object ...................................... 1220


Index

1426

Plattenspeicher .................................................. 375

Pluggable Authentication Module

(PAM) .............................................................. 1367

POCO ................................................................... 1220

Point-to-Point .................................................. 1055

POJO .................................................................... 1220

Policy-Datei ....................................................... 1363

policytool, Dienstprogramm ....................... 1365

Polygon ................................................................ 874

Polygon, Klasse ......................................... 874, 888

Polyline ................................................................ 874

POP before send ............................................... 1027

POP3 .................................................................... 1020

Popup-Menü ....................................................... 759

Port 1234 .............................................................. 989

Port, RMI-Namensdienst ............................... 1046

Port-Adresse ....................................................... 983

Position des Fensters ....................................... 649

PosixFileAttributes, Schnittstelle ................. 399

PosixFileAttributeView, Schnittstelle ......... 403

PosixFilePermission, Aufzählung ................ 400

PosixFilePermissions, Klasse ......................... 400

POST, HTTP-Methode ..................................... 1000

PostgreSQL ........................................................ 1142

POST-Methode .......................................... 973, 999

POST-Request ..................................................... 976

PowerPoint-Dokumente ................................. 623

Prädikat ................................................................ 298

Pragma ............................................................... 1004

Preimage-Angriff ............................................. 1372

PreparedStatement, Schnittstelle ... 1168, 1187

Primzahlen .......................................................... 304

Principal .................................................. 1363, 1368

print() .................................................................... 455

Printable, Schnittstelle .................................... 944

PrinterJob, Klasse .............................................. 944

printf() .................................................................. 455

PrintJob, Klasse .................................................. 944

println() ................................................................ 455

PrintService, Schnittstelle .............................. 946

PrintStream ......................................................... 455

PrintWriter .......................................................... 455

Priorität, Thread .................................................. 87

Prioritätswarteschlange .................................... 87

PriorityBlockingQueue, Klasse ...................... 290

PriorityQueue, Klasse ....................................... 184

PriorityQueue, Schnittstelle ........................... 290

private, Schlüsselwort ................................... 1238

PrivateKey, Schnittstelle .............................. 1375

probeContentType, Files ................................. 409

Programm-Icon .................................................. 921

ProGuard ........................................................... 1407

Properties, Klasse .............................................. 243

PropertyChangeEvent, Klasse ........................ 711

Property-Datei .................................................... 618

PropertyDescriptor, Klasse .......................... 1250

PropertyPermission ....................................... 1366

Proposed Standard ............................................ 957

protected, Schlüsselwort .............................. 1238

Protocol Buffers ........................................ 503, 526

Protocol Handler ....................................... 967–968

Protokoll ............................................................... 957

Proxy .................................................................. 1035

Proxy-Authenticate, Response-Header .... 1005

Proxy-Authorization ........................................ 972

ProxySelector, Klasse .................................... 1009

Proxy-Server .................................................... 1007

Public, Response-Header .............................. 1005

public, Schlüsselwort ..................................... 1238

PublicKey, Schnittstelle ................................ 1375

Publish-Subscribe ........................................... 1055

Pulldown-Menü ................................................. 748

PushbackInputStream, Klasse ....................... 474

PushbackReader, Klasse ................................... 474

put(), Map ............................................................. 231

PUT, HTTP-Methode ...................................... 1000

Q

QuadCurve2D, Klasse ....................................... 888

Quadratische Kurvensegmente ..................... 890

quadTo(), GeneralPath ..................................... 891

Quartz ................................................................... 172

Quellcode-Verschönerer ............................... 1408

Query-String ........................................................ 973

Queue, Schnittstelle ........................ 184, 220–221

Quoted Printing Encoding ........................... 1020


Index

1427

R

Race condition .................................................... 102

Race hazard .......................................................... 102

RadialGradientPaint ......................................... 897

Rahmen ................................................................. 699

RandomAccess, Schnittstelle ......................... 197

RandomAccessFile, Klasse ............................... 379

readAttributes() , Files ...................................... 398

Reader, Klasse ..................................................... 451

readLine(), BufferedReader ............................. 473

readObject(), ObjectInputStream .................. 505

readResolve() ....................................................... 515

readSymbolicLink(), Files ................................ 408

readUTF(), RandomAccessFile ........................ 382

ReadWriteLock, Schnittstelle ......................... 109

rebind(), Registry ............................................ 1048

Rectangle2D, Klasse .......................................... 888

RectangularShape, Klasse ................................ 888

Reentrant ............................................................. 122

Reentrant, Klasse ...................................... 106, 125

ReentrantReadWriteLock, Klasse .................. 109

Reference Concrete Syntax ............................. 533

Referenced-Meldung ..................................... 1050

Reflection .......................................................... 1227

ReflectiveOperationException ................... 1242

ReflectPermission ........................................... 1366

Registry ................................................... 1038, 1045

REGISTRY_PORT, Registry ............................ 1045

Relationales Datenbanksystem .................. 1148

Remote Manager ............................................. 1325

Remote Object Activation ............................ 1054

Remote Procedure Call .................................. 1037

Remote, Schnittstelle ..................................... 1042

RenderedImage, Schnittstelle ........................ 929

Rendering-Algorithmus ................................... 941

Renderpack Render Pipelines ........................ 809

Rendezvous .................................................. 84, 145

repaint() ................................................................ 869

replaceAll(), Collections ................................... 279

ReplicateScaleFilter, Klasse ............................. 929

Representational State Transfer (REST) .... 1059

Request .............................................................. 1000

Request For Comment ...................................... 956

requestFocusInWindow(), JComponent ...... 702

Request-Header ............................................... 1002

ResourceBundle, Klasse ................................... 313

Response-Header ................................. 1002, 1005

RESTful Web-Services ..................................... 1058

Result, Schnittstelle .......................................... 613

ResultSet, Schnittstelle .................................. 1169

ResultSetMetaData, Schnittstelle ............... 1191

resume(), Thread ................................................. 87

RetentionPolicy, Aufzählung ....................... 1279

Retry-After, Response-Header ..................... 1005

Reverse Engineering ....................................... 1404

RFC ......................................................................... 956

RFC 2616 ............................................................... 998

RGB ........................................................................ 902

Rhino ................................................................... 1306

Rich Text Format ............................................... 692

RMI ...................................................................... 1037

RMI Wire Protocol ........................................... 1039

rmi:// .................................................................. 1048

rmic, Dienstprogramm .................................. 1044

RMIClassLoader, Klasse ................................. 1053

rmid, Dienstprogramm ................................. 1055

RMI-Klassenlader ............................................ 1052

RMI-Logging ..................................................... 1050

rmiregistry, Dienstprogramm .......... 1046, 1198

RMI-Transportschicht .................................... 1039

Rollbalken ............................................................ 733

Rollenbasierte Rechtevergabe ..................... 1367

Rollrad .................................................................. 705

Ron Rivest .......................................................... 1371

Rotation ............................................................... 941

RoundRectangle2D, Klasse ............................. 888

RowFilter, Klasse ............................................... 807

RowSet, Schnittstelle ...................................... 1182

RPC ....................................................................... 1037

RTF ......................................................................... 692

run(), Runnable .................................................... 65

Runnable, Schnittstelle ..................................... 65

Runtime Packages ........................................... 1355

RuntimePermission ....................................... 1366

S

Sandbox ............................................................. 1357

Saturation ............................................................ 902


Index

1428

SAX ........................................................................ 545

SAXBuilder .......................................................... 591

SAXBuilder, Klasse ............................................ 591

SAXParser, Klasse .............................................. 584

SCALE_AREA_AVERAGING, Image ............... 927

SCALE_DEFAULT, Image .................................. 927

SCALE_FAST, Image .......................................... 927

SCALE_REPLICATE, Image ............................... 927

SCALE_SMOOTH, Image .................................. 927

Schablonen-Muster .......................................... 443

Schaltjahr ............................................................. 306

ScheduledThreadPoolExecutor,

Klasse ............................................................ 89, 97

Scheduler ............................................................... 98

Schema ................................................................. 539

schemagen, JDK-Tool ....................................... 554

Scherung .............................................................. 941

Schieberegler ...................................................... 733

Schlange ............................................................... 184

Schlüssel .............................................................. 184

Schlüsselpaare .................................................. 1369

Schlüsselspeicher ............................................ 1370

Schriftlinie ........................................................... 877

Schwyzerdütsch ................................................. 316

Screen_Updater ................................................... 78

ScriptEngine, Schnittstelle ........................... 1307

ScriptEngineManager, Klasse ...................... 1307

Scriptlet .............................................................. 1105

Scrollable, Schnittstelle ................................... 714

Scrollbar ............................................................... 733

ScrollPaneLayout, Klasse ................................ 732

SECOND, Calendar ............................................. 329

SecretKey, Schnittstelle ................................. 1375

SecretKeySpec, Klasse .................................... 1377

Secure Hash Algorithm ................................. 1372

Secure Hash Standard .................................... 1372

Secure Sockets Layer ...................................... 1033

Security Manager ............................................ 1358

Security-API ...................................................... 1355

SecurityException ........................................... 1363

SecurityManager ............................................. 1125

SecurityManager, Klasse ................... 1357–1358

SecurityPermission ........................................ 1366

SeekableByteChannel, Schnittstelle ... 422, 424

Sekunde ................................................................ 329

Semantisches Ereignis ..................................... 674

Semaphore, Klasse ............................................. 139

SEPTEMBER, Calendar ...................................... 323

Sequence, Klasse ................................................ 642

SequenceInputStream, Klasse ........................ 447

Sequencer ............................................................. 642

Sequencer, Schnittstelle .................................. 642

Sequenz ....................................................... 176, 183

Serializable, Schnittstelle ................................ 508

SerializablePermission .................................. 1366

serialPersistentFields ....................................... 511

serialver, Kommandozeilenprogramm ...... 519

serialVersionUID ................................................ 518

Server ................................................................. 1038

Server, Response-Header .............................. 1005

ServerSocket, Klasse .......................................... 989

Service ................................................................ 1221

ServiceLoader, Klasse ......................... 1160, 1221

Service-Provider .............................................. 1222

Servlet ................................................................ 1080

Servlet-Container ............................................ 1080

Session, Klasse ...................................... 1021, 1027

Set, Schnittstelle ........................................ 183, 208

setAttribute(), Files ............................................ 405

setBorder(), JComponent ................................. 699

setContentType(), JEditorPane ....................... 692

setDefaultCloseOperation(), JFrame ... 647, 667

setDefaultRenderer(), JTable ........................... 800

setDoInput(), URLConnection ............... 967, 977

setDoOutput(), URLConnection ........... 967, 977

setFont(), Graphics ............................................ 878

setLayout(), Container ...................................... 717

setLookAndFeel(), UIManager ........................ 830

setModel(), JSpinner .......................................... 787

setModel(), JTable .............................................. 794

setPaint(), Graphics2D ...................................... 897

setPriority(), Thread ............................................ 87

setProperty(), Properties ................................. 243

setRenderingHint(), Graphics2D ................... 887

setRequestMethod(), HttpURLConnection 977

setRequestProperty(), URLConnection ....... 977

setSize(), Window ............................................... 648

setText(), JButton ............................................... 677

setText(), JLabel .................................................. 654

setText(), JTextComponent ............................. 685


Index

1429

setUseCaches(), URLConnection .................... 977

setVisible(), Window ......................................... 648

SGML ...................................................................... 532

SHA ..................................................................... 1372

Shallow Copy ....................................................... 234

Shamir, Adi ....................................................... 1371

Shape, Schnittstelle .................................. 886, 888

shared objects .................................................. 1343

ShellFolder, Klasse ............................................. 364

SHORT, DateFormat .......................................... 348

showConfirmDialog(), JOptionPane .... 821–822

showInputDialog(), JOptionPane .................. 822

showMessageDialog(), JOptionPane ............ 822

showOptionDialog(), JOptionPane ............... 822

SHS ...................................................................... 1372

Shutdown-Hook ................................................. 173

Sicherheitsmanager ................. 1357–1358, 1362

signal(), Condition ............................................. 125

Signierung .............................................. 1363, 1368

Simple API for XML Parsing ............................ 545

Simple Logging Facade for Java .................. 1323

Simple Mail Transfer Protocol .................... 1019

SimpleDateFormat, Klasse .............................. 346

SimpleFileVisitor, Klasse ................................. 413

SIMPLIFIED_CHINESE, Locale ......................... 310

SINGLE_INTERVAL_SELECTION,

ListSelectionModel ....................................... 771

SINGLE_SELECTION, ListSelectionModel .... 771

Singleton .............................................................. 282

Skalierung ............................................................ 941

Skipjack .............................................................. 1372

Skript-Engine ................................................... 1306

Slash ....................................................................... 358

sleep(), Thread ....................................................... 73

SLF4J .................................................................... 1323

Slider, Schieberegler ......................................... 733

Smart-Card ........................................................ 1368

SMB (Server Message Block) ........................... 378

SMTP ................................................................... 1019

SMTP-Server ..................................................... 1020

SOAP ................................................................... 1071

SOAP Web-Services ......................................... 1058

SOCK_DGRAM ................................................. 1032

SOCK_STREAM ................................................ 1032

Socket, Klasse ...................................................... 984

SocketPermission ............................................ 1366

Sockets .................................................................. 983

SOCKS ................................................................. 1008

SoftBevelBorder, Klasse ................................... 699

Sommerzeitabweichung ................................. 329

sort(), Arrays ....................................................... 264

sort(), Collections .............................................. 264

SortedMap, Schnittstelle ................................. 230

SortedSet, Schnittstelle ................................... 216

Sortieren .............................................................. 264

Soundbank .......................................................... 641

Source, Schnittstelle ......................................... 613

Sourcecode Beautifier .................................... 1408

SpinnerDateModel, Klasse .............................. 788

SpinnerListModel, Klasse ................................ 787

SpinnerModel, Schnittstelle .......................... 787

Splash-Screen ..................................................... 922

Spring-Framework .......................................... 1221

SpringLayout, Klasse ........................................ 717

SQLWarning, Klasse ........................................ 1180

SQuirreL ............................................................. 1145

SSL ........................................................................ 1033

SSLSocket, Klasse ............................................. 1033

SSLSocketFactory, Klasse .............................. 1033

Stabil sortieren ................................................... 264

Stabiler Sortieralgorithmus ........................... 267

Stack ...................................................................... 218

Stack, Klasse ........................................................ 218

Standard Generalized Markup Language ... 532

Standard MBeans ............................................ 1325

Standard Tag Library ...................................... 1101

Standard Widget Toolkit ................................. 862

Standardberechtigungen .............................. 1364

StandardCopyOption, Aufzählung ............... 396

Standardserialisierung .................................... 502

Stapelspeicher .................................................... 218

start(), Thread ....................................................... 66

Statement, Schnittstelle ................................ 1168

Statusanzeige ..................................................... 745

Statuscode ......................................................... 1003

Statuszeile ......................................................... 1002

StAX ....................................................................... 570

Stellenwertsystem .............................................. 41

Stellvertreterobjekt ............................. 1035, 1044

Sternzeit ............................................................... 305


Index

1430

STL-Bibliothek .................................................... 267

stop(), Thread ........................................................ 79

Store-and-Forward .......................................... 1019

StreamEncoder ................................................... 491

StreamFilter, Schnittstelle .............................. 578

StreamTokenizer, Klasse ................................. 526

StringReader, Klasse ................................ 439, 465

StringWriter, Klasse .......................................... 463

Stroke, Schnittstelle .......................................... 908

Subject ................................................................ 1368

Subprotokoll ..................................................... 1164

SUID ....................................................................... 519

sun.jdbc.odbc.JdbcOdbcDriver .................... 1161

sun.nio.cs ............................................................. 491

suspend(), Thread ................................................ 87

SWIG .................................................................... 1353

Swing JavaBuilder ............................................. 861

swing.properties ................................................ 830

SwingUtilities, Klasse ....................................... 849

SwingWorker, Klasse ........................................ 851

SwingWT .............................................................. 863

SWT ........................................................................ 862

SWTSwing ............................................................ 863

Symbolleiste ....................................................... 756

sync() ............................................................ 435–436

Synchronisation .................................................. 98

synchronized, Schlüsselwort ......................... 113

synchronizedCollection(), Collections ........ 286

synchronizedList(), Collections ..................... 286

synchronizedMap(), Collections ................... 286

synchronizedSet(), Collections ...................... 286

synchronizedSortedMap(), Collections ...... 286

synchronizedSortedSet(), Collections ......... 286

System.in .................................................... 445, 460

SystemColor ........................................................ 897

SystemColor, Klasse ......................................... 903

Systemfarben ..................................................... 903

SystemTray, Klasse ........................................... 764

T

TableCellEditor, Schnittstelle ........................ 801

TableCellRenderer, Schnittstelle ................... 798

TableColumn, Klasse ........................................ 803

TableLayout, Klasse .......................................... 732

TableModel, Schnittstelle ....................... 791, 803

TableModelEvent, Klasse ................................. 795

TableModelListener, Schnittstelle ................ 791

TableRowSorter, Klasse .................................... 806

Tag ................................................................. 328, 531

Tag des Jahres ..................................................... 329

Tage im Monat .................................................... 333

Tagesdatum ......................................................... 332

TagLib ................................................................. 1101

TagLib-Deskriptor ........................................... 1101

TAI .......................................................................... 306

TAIWAN ................................................................ 310

Tango Desktop Projekt ..................................... 659

Tar-Archiv ............................................................ 626

Task, Fork and Join ............................................ 152

Tastatur-Shortcut .............................................. 753

Tastenkürzel ........................................................ 753

TCP ...................................................................... 1012

TCP/IP .................................................................... 983

Tear-off-Menü ..................................................... 749

Teile und herrsche ............................................. 149

Teletubbies .......................................................... 975

template pattern ................................................ 443

Template-Code ................................................ 1090

Terminiert .............................................................. 76

TextArea, Klasse ................................................. 688

TextLayout, Klasse ............................................ 885

TexturePaint ....................................................... 897

Thread, Klasse ....................................................... 66

ThreadDeath, Klasse ........................................... 83

ThreadGroup, Klasse ......................................... 162

Thread-Gruppe ................................................... 166

Thread-local storage (TLS) ............................... 156

ThreadLocal, Klasse ........................................... 156

ThreadLocalRandom, Klasse .......................... 161

Thread-lokale Variablen .................................. 156

Thread-Pool ........................................................... 89

ThreadPoolExecutor, Klasse ............................. 89

Thread-safe ............................................................ 99

Thread-sicher ........................................................ 99

tick marks ............................................................ 733

Tiefe Objektkopie ............................................... 515

Timeout ............................................................. 1039

Timer, Klasse ....................................................... 171

Timer, Swing-Klasse ................................. 855–856


Index

1431

TimerTask, Klasse .............................................. 171

Timestamp, Klasse .......................................... 1173

TimeUnit, Aufzählung ...................................... 307

Titelleiste .............................................................. 652

TitledBorder, Klasse .......................................... 699

TLS ....................................................................... 1033

toArray(), Collection .......................................... 204

Tödliche Umarmung ......................................... 119

Tomcat ............................................................... 1083

Toolkit, Klasse ..................................................... 650

Topic, JMS .......................................................... 1055

Top-Level-Container ......................................... 645

Transferable, Schnittstelle .............................. 837

Transfer-Encoding .......................................... 1004

TransferHandler, Klasse ................................... 841

Transfer-Objekt ............................................... 1262

Transformation .................................................. 896

transient, Schlüsselwort .................................. 511

translate(), Graphics .......................................... 936

Transparency, Schnittstelle ............................ 897

TransparentLayout ............................................ 732

Transport Layer Security .............................. 1033

Transportschicht ............................................. 1038

TrayIcon, Klasse ................................................. 764

TreeMap, Klasse ....................... 176, 185–186, 229

TreeModel, Schnittstelle ......................... 809, 811

TreeNode, Schnittstelle .................................... 811

TreeSelectionListener, Schnittstelle ............. 811

TreeSet, Klasse .................................................... 214

TrueType-Zeichensatz ...................................... 881

TrueZIP .................................................................. 626

try mit Ressourcen .............................................. 51

Tupel ................................................................... 1139

TYPE, Wrapper-Klasse .................................... 1229

TYPE_INT_RGB, BufferedImage ..................... 924

TYPE_SCROLL_INSENSITIVE, ResultSet .... 1176

Types, Klasse .................................................... 1170

tz database ........................................................... 339

U

Überblendung, Grafik ....................................... 907

Überwachtes Warten ........................................ 131

UDP .......................................................... 1011–1012

UIDefaults, Klasse ............................................. 656

UI-Delegate .......................................................... 708

UIManager, Klasse ............................................ 830

UK, Locale ............................................................ 310

Umrisslinie .......................................................... 908

Umrisslinie, Stroke ........................................... 896

UncaughtExceptionHandler, Schnittstelle .. 81

UNDECIMBER, Calendar .................................. 323

Undo/Redo .......................................................... 842

UndoableEditEvent, Klasse ............................. 844

UndoManager, Klasse ...................................... 842

UnicastRemoteObject, Klasse ...................... 1048

Unicast-Verbindung ....................................... 1033

Uniform Resource Locator ............................. 957

Universal Time ................................................... 306

UnknownHostException ................................ 985

unlock(), Lock ..................................................... 106

Unmarshaller, Schnittstelle ........................... 549

UnsatisfiedLinkError ...................................... 1339

UnsupportedOperationException ..... 181, 202,

251, 271

Unterlänge .......................................................... 884

Untermenü .......................................................... 748

Unterstrich

in Zahlen ............................................................ 42

Upgrade .............................................................. 1004

URI (Uniform Resource Identifier) ............... 957

URI, Klasse ........................................................... 957

URL ........................................................................ 958

URL, Klasse .......................................................... 958

URLConnection, Klasse .................................... 965

URLDecoder, Klasse ................................. 974–975

URLEncoder, Klasse .......................................... 974

US, Locale ............................................................. 310

user.timezone .................................................... 324

UserDefinedFileAttributeView,

Schnittstelle .................................................... 405

UTC ........................................................................ 306

UTF-16 ................................................................... 535

UTF-8 ..................................................................... 535

UTF-8-Format

modifiziertes ................................................... 383

UTF-8-Kodierung ............................................... 383

UUencode .......................................................... 1020


Index

1432

V

Valid, XML ........................................................... 535

validateProperty(), Validator ....................... 1210

Validation, Klasse ............................................ 1209

Validator, Schnittstelle .................................. 1209

Value ..................................................................... 184

values(), Map ....................................................... 238

Vary, Response-Header ................................. 1005

Vector, Klasse ..................................................... 188

Verbindungsloses Protokoll ........................ 1011

Verbindungsorientiert .................................. 1011

Verkettete Liste ......................................... 177, 200

Verklemmung .................................................... 119

Verlaufsbalken ................................................... 745

Verschiebung ...................................................... 941

Verzeichnis anlegen ......................................... 365

Verzeichnis umbenennen .............................. 365

Via ........................................................................ 1004

View ....................................................................... 765

ViewPortLayout, Klasse ................................... 732

volatile, Schlüsselwort ..................................... 146

Vorschaubild ...................................................... 915

W

wait(), Object .............................................. 124, 135

Wait-free-Algorithmus .................................... 284

walkFileTree(), Files .......................................... 413

Warning, Response-Header .......................... 1005

Warning:Applet Window .............................. 1363

Watchable, Schnittstelle .................................. 421

WatchEvent, Klasse ........................................... 421

WatchKey, Klasse .............................................. 421

WatchService, Klasse ........................................ 420

WAV ....................................................................... 641

Web Application Security ............................. 1121

WebApplicationException ............................ 1069

Webbrowser ........................................................ 692

WebRowSet, Schnittstelle ................. 1183–1184

Web-Service ...................................................... 1058

Webstart ............................................................. 1137

Wechselknopf ..................................................... 682

WEEK_OF_MONTH, Calendar ........................ 328

WEEK_OF_YEAR, Calendar ............................. 328

Weichzeichnen .......................................... 871, 941

Weld .................................................................... 1224

Well-known System Ports ............................... 984

Wettlaufsituation .............................................. 102

WHITE, Color ....................................................... 900

WIND_NON_ZERO, GeneralPath ................... 893

Winding Rule ...................................................... 892

windowClosed(), WindowListener ................ 667

windowClosing(), WindowListener .............. 667

WindowEvent, Klasse ....................................... 665

WindowListener, Schnittstelle ....................... 662

Windows Icon-Format ...................................... 915

Windungsregel ................................................... 892

Woche .................................................................... 328

Woche des Monats ............................................ 328

Wohlgeformt ....................................................... 534

Word-Dokumente .............................................. 623

Worker-Thread ................................................... 853

work-stealing ...................................................... 153

writeObject(), ObjectOutputStream ............. 504

Writer, Klasse ...................................................... 449

writeReplace() ..................................................... 515

writeUTF(), RandomAccessFile ...................... 382

wsimport, Dienstprogramm ............ 1074, 1076

Wurzelelement ................................................... 595

Wurzelverzeichnis ............................................. 373

WWW-Authenticate, Response-Header .... 1005

X

X.509 ................................................................... 1369

XAML ..................................................................... 861

Xerces .................................................................... 546

XFire, Codehaus ............................................... 1073

XHTML .................................................................. 543

xjc ........................................................................... 565

XML ........................................................................ 532

XMLDecoder, Klasse .......................................... 522

XMLEncoder, Klasse .......................................... 522

XMLEvent, Klasse ............................................... 571

XMLEventFactory, Klasse ................................ 579

XMLEventReader, Klasse ................................. 576

XMLEventReader, Schnittstelle ..................... 579

XMLEventWriter, Klasse .................................. 572

XMLEventWriter, Schnittstelle ...................... 580


Index

1433

XMLGregorianCalendar, Klasse ..................... 562

XMLInputFactory, Klasse ................................ 579

XMLOutputFactory, Klasse .................... 579–580

XMLOutputter, Klasse ...................................... 592

XMLStreamConstants, Schnittstelle ............ 572

XMLStreamReader, Schnittstelle .................. 571

XMLStreamWriter, Klasse ............................... 572

XMLStreamWriter, Schnittstelle .......... 579–580

XMLVM .............................................................. 1294

XOR ........................................................................ 867

Xor-Modus, Zeichnen ....................................... 907

XPath ............................................................ 606, 610

XPath, Klasse ....................................................... 607

XPath-Wurzel ...................................................... 606

XSLT ....................................................................... 610

XStream ................................................................ 525

Y

YAJSW ................................................................. 1409

YEAR, Calendar ................................................... 328

yield(), Thread ....................................................... 75

Z

Zehnersystem ....................................................... 41

Zeichenbereich ................................................... 896

Zeitablauf ........................................................... 1039

Zeitgenauigkeit .................................................. 317

Zeitzone ....................................................... 306, 351

Zeitzonenabweichung ..................................... 329

Zertifizierungsstelle ....................................... 1368

ZipEntry, Klasse ................................................. 633

ZipFile, Klasse ..................................................... 633

ZONE_OFFSET, Calendar ................................. 329

Zugriffsmodifizierer ....................................... 1245

Zustände, Threads ............................................... 72

Zwischenablage .................................................. 836

Zyklische Redundanzprüfung ....................... 499


Documents

Java 7 - Mehr als eine Insel · 2.8.2 Paralleles Lösen von D&C-Algorithmen ... 4.9.1 Ausgaben mit printf() ... 1123 15.1.2 (J)