View
219
Download
4
Category
Preview:
Citation preview
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
1507.book Seite 3 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 5 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 6 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 7 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 8 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 9 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 10 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 11 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 12 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 13 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 14 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 15 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 16 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 17 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 18 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 19 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 20 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 21 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 22 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 23 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 24 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 25 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 26 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 27 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 28 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 29 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 30 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 31 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 32 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 33 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 34 Mittwoch, 12. Oktober 2011 12:49 12
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.
1507.book Seite 35 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 36 Mittwoch, 12. Oktober 2011 12:49 12
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.
1507.book Seite 37 Mittwoch, 12. Oktober 2011 12:49 12
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.
1507.book Seite 38 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 39 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 41 Mittwoch, 12. Oktober 2011 12:49 12
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;
1507.book Seite 42 Mittwoch, 12. Oktober 2011 12:49 12
1.1 Sprachänderungen
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.
1507.book Seite 43 Mittwoch, 12. Oktober 2011 12:49 12
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-
1507.book Seite 44 Mittwoch, 12. Oktober 2011 12:49 12
1.1 Sprachänderungen
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;
}
1507.book Seite 45 Mittwoch, 12. Oktober 2011 12:49 12
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 )
{
System.err.printf( "Datenformat falsch%n%s%n", e );
}
catch ( ArrayIndexOutOfBoundsException e )
{
System.err.printf( "Datenformat falsch%n%s%n", 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.
1507.book Seite 46 Mittwoch, 12. Oktober 2011 12:49 12
1.1 Sprachänderungen
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.)
1507.book Seite 47 Mittwoch, 12. Oktober 2011 12:49 12
1 Neues in Java 7
48
BufferedImage screenshot = new Robot().createScreenCapture( r );
ImageIO.write( screenshot, "png", new File( filename ) );
}
catch ( AWTException e )
{
throw e;
}
catch ( IOException 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
catch ( IOException e )
{
new File( filename ).delete();
throw e;
}
schreiben wir:
catch ( Throwable e )
{
new File( filename ).delete();
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*/
{
1507.book Seite 48 Mittwoch, 12. Oktober 2011 12:49 12
1.1 Sprachänderungen
49
1...
catch ( AWTException /*1*/ e )
{
throw e;
}
catch ( Throwable /*?*/ e )
{
new File( filename ).delete();
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 )
{
new File( filename ).delete();
e = new IllegalStateException();
throw e;
}
1507.book Seite 49 Mittwoch, 12. Oktober 2011 12:49 12
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();
}
catch ( IOException e )
{
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.
1507.book Seite 50 Mittwoch, 12. Oktober 2011 12:49 12
1.1 Sprachänderungen
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.)
1507.book Seite 51 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 52 Mittwoch, 12. Oktober 2011 12:49 12
1.1 Sprachänderungen
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'«.
1507.book Seite 53 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 54 Mittwoch, 12. Oktober 2011 12:49 12
1.1 Sprachänderungen
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
1507.book Seite 55 Mittwoch, 12. Oktober 2011 12:49 12
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.)
1507.book Seite 56 Mittwoch, 12. Oktober 2011 12:49 12
1.1 Sprachänderungen
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
{
public static void main( String[] args )
{
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)
at SuppressedClosed.main(SuppressedClosed.java:15)
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:
1507.book Seite 57 Mittwoch, 12. Oktober 2011 12:49 12
1 Neues in Java 7
58
Exception in thread "main" java.lang.UnsupportedOperationException: close() mag ich nicht
at SuppressedClosed$1NotCloseable.close(SuppressedClosed.java:9)
at SuppressedClosed.main(SuppressedClosed.java:15)
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
at SuppressedClosed.main(SuppressedClosed.java:15)
Suppressed: java.lang.UnsupportedOperationException: close() mag ich nicht
at SuppressedClosed$1NotCloseable.close(SuppressedClosed.java:9)
at SuppressedClosed.main(SuppressedClosed.java:16)
Suppressed: java.lang.UnsupportedOperationException: close() mag ich nicht
at SuppressedClosed$1NotCloseable.close(SuppressedClosed.java:9)
at SuppressedClosed.main(SuppressedClosed.java:16)
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.
1507.book Seite 58 Mittwoch, 12. Oktober 2011 12:49 12
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.
1507.book Seite 59 Mittwoch, 12. Oktober 2011 12:49 12
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)
1507.book Seite 60 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 61 Mittwoch, 12. Oktober 2011 12:49 12
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.
1507.book Seite 62 Mittwoch, 12. Oktober 2011 12:49 12
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.
1507.book Seite 63 Mittwoch, 12. Oktober 2011 12:49 12
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.
1507.book Seite 64 Mittwoch, 12. Oktober 2011 12:49 12
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 );
}
1507.book Seite 1227 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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.«
1507.book Seite 1228 Mittwoch, 12. Oktober 2011 12:49 12
18.2 Metadaten der Klassen mit dem Class-Objekt
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 = ...
System.out.println( c2 ); // class java.util.Date
try {
Class<?> c3 = Class.forName( "java.util.Date" );
System.out.println( c3 ); // class 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.
1507.book Seite 1229 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
1507.book Seite 1230 Mittwoch, 12. Oktober 2011 12:49 12
18.2 Metadaten der Klassen mit dem Class-Objekt
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
{
public static void main( String[] args )
{
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
1507.book Seite 1231 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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.
final class java.lang.Class<T>
implements Serializable, GenericDeclaration, Type, AnnotatedElement
1507.book Seite 1232 Mittwoch, 12. Oktober 2011 12:49 12
18.2 Metadaten der Klassen mit dem Class-Objekt
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
1507.book Seite 1233 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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.)
1507.book Seite 1234 Mittwoch, 12. Oktober 2011 12:49 12
18.2 Metadaten der Klassen mit dem Class-Objekt
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:
final class java.lang.Class<T>
implements Serializable, GenericDeclaration, Type, AnnotatedElement
1507.book Seite 1235 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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();
1507.book Seite 1236 Mittwoch, 12. Oktober 2011 12:49 12
18.2 Metadaten der Klassen mit dem Class-Objekt
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.
final class java.lang.Class<T>
implements Serializable, GenericDeclaration, Type, AnnotatedElement
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() );
1507.book Seite 1237 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
final class java.lang.Class<T>
implements Serializable, GenericDeclaration, Type, AnnotatedElement
Beispiel (Forts.)
1507.book Seite 1238 Mittwoch, 12. Oktober 2011 12:49 12
18.2 Metadaten der Klassen mit dem Class-Objekt
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
1507.book Seite 1239 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
1507.book Seite 1240 Mittwoch, 12. Oktober 2011 12:49 12
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]]
18.3 Attribute, Methoden und Konstruktoren
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.
1507.book Seite 1241 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
1507.book Seite 1242 Mittwoch, 12. Oktober 2011 12:49 12
18.3 Attribute, Methoden und Konstruktoren
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();
1507.book Seite 1243 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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()) + " "
final class java.lang.Class<T>
implements Serializable, GenericDeclaration, Type, AnnotatedElement
1507.book Seite 1244 Mittwoch, 12. Oktober 2011 12:49 12
18.3 Attribute, Methoden und Konstruktoren
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.
Þ int getModifiers()
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.
Þ String toString()
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
1507.book Seite 1245 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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.
1507.book Seite 1246 Mittwoch, 12. Oktober 2011 12:49 12
18.3 Attribute, Methoden und Konstruktoren
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
{
public static void main( String[] args )
{
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.
final class java.lang.Class<T>
implements Serializable, GenericDeclaration, Type, AnnotatedElement
1507.book Seite 1247 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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( )
1507.book Seite 1248 Mittwoch, 12. Oktober 2011 12:49 12
18.3 Attribute, Methoden und Konstruktoren
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.
Þ int getModifiers()
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.
Þ String toString()
Liefert eine String-Repräsentation der Methode, ähnlich dem Methodenkopf in einer Dekla-
ration.
final class java.lang.reflect.Method
extends AccessibleObject
implements GenericDeclaration, Member
1507.book Seite 1249 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
1507.book Seite 1250 Mittwoch, 12. Oktober 2011 12:49 12
18.3 Attribute, Methoden und Konstruktoren
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)
throws NoSuchMethodException
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.Class<T>
implements Serializable, GenericDeclaration, Type, AnnotatedElement
final class java.lang.reflect.Constructor<T>
extends AccessibleObject
implements GenericDeclaration, Member
1507.book Seite 1251 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
1252
Þ Class[] getExceptionTypes()
Þ int getModifiers()
Þ String getName()
Þ Class[] getParameterTypes()
Abbildung 18.3: UML-Diagramm mit den Unterklassen von Member
1507.book Seite 1252 Mittwoch, 12. Oktober 2011 12:49 12
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.
18.4 Objekte erzeugen und manipulieren
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
1507.book Seite 1253 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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)
throws NoSuchMethodException
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.Class<T>
implements Serializable, GenericDeclaration, Type, AnnotatedElement
final class java.lang.reflect.Constructor<T>
extends AccessibleObject
implements GenericDeclaration, Member
1507.book Seite 1254 Mittwoch, 12. Oktober 2011 12:49 12
18.4 Objekte erzeugen und manipulieren
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():
1507.book Seite 1255 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
1256
Listing 18.12: com/tutego/insel/meta/GetFieldElements.java
package com.tutego.insel.meta;
import java.lang.reflect.*;
class GetFieldElements
{
public static void main( String[] args )
{
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 ) {
e.printStackTrace();
}
1507.book Seite 1256 Mittwoch, 12. Oktober 2011 12:49 12
18.4 Objekte erzeugen und manipulieren
1257
18
catch ( IllegalAccessException e ) {
e.printStackTrace();
}
}
}
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.
Þ int getModifiers()
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
final class java.lang.reflect.Field
extends AccessibleObject
implements Member
1507.book Seite 1257 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
package com.tutego.insel.meta;
import java.lang.reflect.*;
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 )
{
e.printStackTrace();
}
}
1507.book Seite 1258 Mittwoch, 12. Oktober 2011 12:49 12
18.4 Objekte erzeugen und manipulieren
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
package com.tutego.insel.meta;
class Ober
{
int i = 123;
/* private */double d = 3.1415;
}
public class ToStringHelperDemo extends Ober
{
String hello = "world";
int i = 42;
public static void main( String[] args )
{
ToStringHelperDemo t = new ToStringHelperDemo();
System.out.println( ToStringHelper.toString( t ) );
// ToStringHelperTest[hello=world, i=42, i=123, d=3.1415]
}
}
1507.book Seite 1259 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
package com.tutego.insel.meta;
import java.lang.reflect.*;
import java.awt.*;
class SetFieldElements
{
public static void main( String[] args )
{
Point p = new Point( 11, 22 );
System.out.println( p );
modify( p, "x", 1111 ); // java.awt.Point[x=11,y=22]
modify( p, "y", 2222 ); // java.awt.Point[x=1111,y=2222]
System.out.println( p );
modify( p, "z", 0 ); // java.lang.NoSuchFieldException: z
}
static void modify( Object o, String name, Integer param )
{
1507.book Seite 1260 Mittwoch, 12. Oktober 2011 12:49 12
18.4 Objekte erzeugen und manipulieren
1261
18
try
{
Field field = o.getClass().getField( name );
field.set( o, param );
}
catch ( NoSuchFieldException e ) {
e.printStackTrace();
}
catch ( IllegalAccessException e ) {
e.printStackTrace();
}
}
}
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.
final class java.lang.reflect.Field
extends AccessibleObject
implements Member
1507.book Seite 1261 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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:
1507.book Seite 1262 Mittwoch, 12. Oktober 2011 12:49 12
18.4 Objekte erzeugen und manipulieren
1263
18
Listing 18.16: com/tutego/insel/meta/ReadPrivate.java
package com.tutego.insel.meta;
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.
1507.book Seite 1263 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
extends AccessibleObject
implements GenericDeclaration, Member
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
1507.book Seite 1264 Mittwoch, 12. Oktober 2011 12:49 12
18.4 Objekte erzeugen und manipulieren
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 );
System.out.println( p );
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
package com.tutego.insel.meta;
import java.lang.reflect.*;
import java.util.Arrays;
public class InvokeMain
{
public static void main( String[] args ) throws Exception
{
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
{
public static void main( String[] args )
1507.book Seite 1265 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
package com.tutego.insel.meta;
public class DynamReflectionMethod
{
@Override
public void meth()
{
System.out.println( "Bewusste Raucher trinken Filterkaffee" );
}
}
1507.book Seite 1266 Mittwoch, 12. Oktober 2011 12:49 12
18.4 Objekte erzeugen und manipulieren
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
package com.tutego.insel.meta;
interface DynamBase
{
void meth();
}
class DynamBaseMethod implements DynamBase
{
public void meth()
{
System.out.println( "Bewusste Raucher trinken Filterkaffee" );
}
}
public class DynamAbstract
{
public static void main( String[] args ) throws Exception
{
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-
1507.book Seite 1267 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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();
1507.book Seite 1268 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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:
@UrlResource( value = "http://tutego.de/aufgaben/bond.txt",
converter = { RemoveNoWordCharactersConverter.class,
SortConverter.class } )
public String testFile;
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.)
1507.book Seite 1269 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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.
1507.book Seite 1270 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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
1507.book Seite 1271 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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:
@UrlResource( value = "http://tutego.de/aufgaben/bond.txt",
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 @interface UrlResource
{
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.
1507.book Seite 1272 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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:
public @interface UrlResource
{
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:
@UrlResource( value = "http://tutego.de/aufgaben/bond.txt",
converter = { RemoveNoWordCharactersConverter.class,
SortConverter.class } )
public String testFile;
Bei nur einem angegebenen Konverter können die geschweiften Klammern sogar entfallen:
@UrlResource( value = "http://tutego.de/aufgaben/bond.txt",
converter = RemoveNoWordCharactersConverter.class )
1507.book Seite 1273 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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" )
} )
1507.book Seite 1274 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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:
@UrlResource( "http://tutego.de/aufgaben/bond.txt" )
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:
public @interface UrlResource
{
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.
1507.book Seite 1275 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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.
1507.book Seite 1276 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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 )
public @interface CurrentDateResource { }
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 )
public @interface CurrentDateResource { }
ElementType Erlaubt Annotationen ...
Tabelle 18.3: ElementType bestimmt Orte, an denen Annotationen erlaubt sind. (Forts.)
1507.book Seite 1277 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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
package com.tutego.insel.annotation;
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.
1507.book Seite 1278 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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).
1507.book Seite 1279 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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 )
public @interface CurrentDateResource { }
Der Annotationstyp ListOfFilesResource erwartet eine Pfadangabe, ist aber nicht deutlich
komplexer als CurrentDateResource:
Listing 18.25: com/tutego/insel/annotation/ListOfFilesResource.java, ListOfFilesResource
@Documented
@Target( ElementType.FIELD )
@Retention( RetentionPolicy.RUNTIME )
public @interface ListOfFilesResource
Beispiel
@Documented ist selbst @Documented:
@Documented
@Target( value = ANNOTATION_TYPE )
public @interface Documented
1507.book Seite 1280 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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
@Target( ElementType.FIELD )
1507.book Seite 1281 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
1282
@Retention( RetentionPolicy.RUNTIME )
public @interface UrlResource
{
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
1507.book Seite 1282 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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.
1507.book Seite 1283 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
1284
Listing 18.30: com/tutego/insel/annotation/GetTheUrlResourceValues.java, GetTheUrlResourceValues
public class GetTheUrlResourceValues
{
@UrlResource( value = "http://tutego.de/aufgaben/bond.txt",
upperLowerCase = UpperLowerCase.UPPERCASE, trim = true,
converter = { RemoveNoWordCharactersConverter.class, SortConverter.class }
)
public String testFile;
@XmlValue @Deprecated
public String xmlValue;
public static void main( String[] args ) throws Exception
{
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:
1507.book Seite 1284 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
1285
18
Listing 18.31: com/tutego/insel/annotation/AnnotatedResourceExample.java, Resources
class Resources
{
@CurrentDateResource()
public Date now;
@ListOfFilesResource( value = "c:/" )
public String[] files;
@UrlResource( "http://tutego.de/aufgaben/bond.txt" )
public String testFile;
}
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
{
public static void main( String[] args )
{
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
package com.tutego.insel.annotation;
import java.io.File;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.Date;
1507.book Seite 1285 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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() )
{
if ( field.isAnnotationPresent( CurrentDateResource.class ) )
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 );
1507.book Seite 1286 Mittwoch, 12. Oktober 2011 12:49 12
18.5 Eigene Annotationstypen *
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() )
if ( field.isAnnotationPresent( CurrentDateResource.class ) )
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
1507.book Seite 1287 Mittwoch, 12. Oktober 2011 12:49 12
18 Reflection und Annotationen
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.
1507.book Seite 1288 Mittwoch, 12. Oktober 2011 12:49 12
1411
Index
Index
#IMPLIED ............................................................. 538
#REQUIRED ......................................................... 538
%tD ......................................................................... 346
%tR ......................................................................... 346
%tT ......................................................................... 346
& ..................................................................... 534
&apos .................................................................... 534
> .......................................................................... 534
< ........................................................................... 534
" .................................................................... 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
1507.book Seite 1411 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1412 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1413 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1414 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1415 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1416 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1417 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1418 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1419 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1420 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1421 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1422 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1423 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1424 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1425 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1426 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1427 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1428 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1429 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1430 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1431 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1432 Mittwoch, 12. Oktober 2011 12:49 12
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
1507.book Seite 1433 Mittwoch, 12. Oktober 2011 12:49 12
Recommended