Groovy im Einsatz (eBook)

Dierk König, Andrew Glover, Paul King, Guillaume Laforge (Autoren)

eBook Download: PDF

2007 | 1. Auflage
629 Seiten
Carl Hanser Fachbuchverlag
978-3-446-41412-9 (ISBN)

Infos

Groovy, die brandneue Sprache für die Java-Plattform, stellt für Java viele der neuen dynamischen Features zur Verfügung, die Ruby und Rails populär gemacht haben. In diesem Buch stellen Mitglieder und der Manager des Groovy-Projekt-Teams die definitive Einführung in die Programmierung mit Groovy zur Verfügung. Auf der Basis von vielen Beispielen, deren Code in eigenen Projekten wieder verwendet werden kann, werden die grundlegenden Konzepte der Sprache vorgestellt. So können Groovy-Neulinge einfach zur dynamischen Programmierung wechseln und deren Vorteile nutzen. Groovy-Experten finden hier eine umfassende Referenz, mit deren Hilfe sie noch weiter in die Tiefe gehen können und Groovy kreativ einsetzen lernen. Das Buch stellt die Grundlagen von Groovy vor und zeigt welche Bereicherungen die Sprache für Java bringt. Ein eigenes Kapitel geht auf Grails ein, das Groovy Web Application Framework. Im Internet: Der Sourcecode der Beispiele aus dem Buch.

Ein Buch für alle Java-Programmierer.

Inhalt

Inhalt 7
Vorwort 17
Vorwort zur deutschen Ausgabe 19
Einleitung 21
Danksagungen 25
Über dieses Buch 27
Aufbau 27
Wer sollte dieses Buch lesen? 28
Code-Konventionen 28
Aktualisierungen 29
Die Autoren 31
1 Ihr Weg zu Groovy 33
1.1 Die Groovy-Story 34
1.1.1 Was ist Groovy? 35
1.1.2 Gutes Zusammenspiel mit Java: nahtlose Integration 36
1.1.3 Power in Ihrem Code: eine reichhaltige Sprache 37
1.1.4 Community-gesteuert, aber von Unternehmen gestützt 40
1.2 Was Groovy für Sie tun kann 41
1.2.1 Groovy für Java-Profis 41
1.2.2 Groovy für Skriptprogrammierer 42
1.2.3 Groovy für pragmatische, extreme und agile Programmierer 43
1.3 Groovy ausführen 44
1.3.1 „Hello World“ auf groovysh 44
1.3.2 Die groovyConsole 47
1.3.3 Der Befehl groovy 48
1.4 Groovy kompilieren und ausführen 49
1.4.1 Groovy mit groovyc kompilieren 50
1.4.2 Ein kompiliertes Groovy-Skript mit Java ausführen 50
1.4.3 Kompilieren und Ausführen mit Ant 51
1.5 IDE- und Editor-Unterstützung für Groovy 52
1.5.1 Das Plugin für IntelliJ IDEA 53
1.5.2 Das Eclipse-Plugin 53
1.5.3 Groovy-Unterstützung in anderen Editoren 54
1.6 Zusammenfassung 55
Teil 1 Die Programmiersprache Groovy 57
2 Die Ouvertüre: Groovy-Grundlagen 59
2.1 Allgemeines Aussehen des Codes 59
2.1.1 Kommentare in Groovy 60
2.1.2 Vergleich der Syntax von Groovy und Java 60
2.1.3 Kurz und gut 61
2.2 Testen der Sprache durch Zusicherungen 62
2.3 Groovy auf einen Blick 64
2.3.1 Klassen deklarieren 65
2.3.2 Verwendung von Skripten 65
2.3.3 GroovyBeans 66
2.3.4 Umgang mit Text 67
2.3.5 Zahlen sind Objekte 69
2.3.6 Listen, Maps und Ranges 69
2.3.7 Code als Objekt: Closures 72
2.3.8 Groovy-Kontrollstrukturen 74
2.4 Groovys Platz in der Java-Umgebung 75
2.4.1 Meine Klasse ist deine Klasse 76
2.4.2 GDK: Die Groovy-Bibliothek 77
2.4.3 Der Groovy-Lebenszyklus 78
2.5 Zusammenfassung 81
3 Die einfachen Groovy-Datentypen 83
3.1 Objekte, Objekte überall 83
3.1.1 Das Typsystem von Java: Basistypen und Referenztypen 84
3.1.2 Die Antwort ist Groovy – alles ist ein Objekt 84
3.1.3 Zusammenwirken mit Java – automatisches Boxing und Unboxing 86
3.1.4 Kein zwischengeschaltetes Unboxing 87
3.2 Das Konzept der optionalen Typisierung 88
3.2.1 Typen zuweisen 88
3.2.2 Statische versus dynamische Typisierung 89
3.3 Operatoren überschreiben 90
3.3.1 Überschreibbare Operatoren 90
3.3.2 Überschriebene Operatoren in Aktion 92
3.3.3 Automatische Typumwandlung 93
3.4 Umgang mit Strings 95
3.4.1 Varianten von Stringliteralen 95
3.4.2 Der Umgang mit GStrings 98
3.4.3 Von Java zu Groovy 99
3.5 Arbeiten mit regulären Ausdrücken 102
3.5.1 Angabe von Patterns in Stringliteralen 103
3.5.2 Anwendung von Patterns 105
3.5.3 Patterns in Aktion 107
3.5.4 Patterns und Performance 109
3.5.5 Patterns für die Klassifizierung 110
3.6 Arbeiten mit Zahlen 111
3.6.1 Automatische Typumwandlung mit numerischen Operatoren 111
3.6.2 GDK-Methoden für numerische Typen 113
3.7 Zusammenfassung 114
4 Die mengenwertigen Groovy-Datentypen 117
4.1 Der Umgang mit Ranges 118
4.1.1 Ranges spezifizieren 119
4.1.2 Ranges sind Objekte 120
4.1.3 Ranges in Aktion 121
4.2 Der Umgang mit Listen 123
4.2.1 Listen angeben 123
4.2.2 Der Umgang mit Listenoperatoren 124
4.2.3 Verwenden von Listenmethoden 127
4.2.4 Listen in Aktion 131
4.3 Der Umgang mit Maps 133
4.3.1 Maps angeben 133
4.3.2 Verwendung von Map-Operatoren 135
4.3.3 Maps in Aktion 139
4.4 Hinweise zu Groovy-Collections 140
4.4.1 Nebenläufige Änderungen 141
4.4.2 Der Unterschied zwischen Kopier- und Änderungs-Semantik 141
4.5 Zusammenfassung 142
5 Closures 143
5.1 Eine sanfte Einführung in Closures 144
5.2 Ein Fall für Closures 145
5.2.1 Verwendung von Iteratoren 145
5.2.2 Ressourcenbehandlung 146
5.3 Deklarieren von Closures 149
5.3.1 Die einfache Deklaration 149
5.3.2 Zuweisungen zur Deklaration verwenden 150
5.3.3 Methoden als Closures referenzieren 151
5.3.4 Die verschiedenen Möglichkeiten im Vergleich 153
5.4 Verwendung von Closures 154
5.4.1 Aufrufen einer Closure 154
5.4.2 Weitere Closure-Methoden 156
5.5 Gültigkeitsbereiche 159
5.5.1 Der einfache Gültigkeitsbereich einer Variablen 160
5.5.2 Der allgemeine Gültigkeitsbereich von Closures 161
5.5.3 Gültigkeitsbereiche: der klassische Akkumulator-Test 164
5.6 Rückgabe aus Closures 165
5.7 Unterstützung für Entwurfsmuster 166
5.7.1 Beziehung zum Besuchermuster 167
5.7.2 Beziehung zum Erbauermuster 167
5.7.3 Beziehung zu anderen Mustern 168
5.8 Zusammenfassung 169
6 Groovy-Kontrollstrukturen 171
6.1 Die Groovy-Wahrheit 171
6.1.1 Boolesche Tests auswerten 172
6.1.2 Zuweisungen in Booleschen Tests 173
6.2 Bedingte Ausführung 175
6.2.1 Die ganz bescheidene if-Anweisung 175
6.2.2 Der Bedingungsoperator ?: 176
6.2.3 Die switch-Anweisung 176
6.2.4 Plausibilitätsprüfung mit Zusicherungen 179
6.3 Schleifen 183
6.3.1 while-Schleifen 183
6.3.2 for-Schleifen 183
6.4 Blöcke und Methoden abbrechen 186
6.4.1 Normale Beendigung: return/break/continue 186
6.4.2 Exceptions: throw/try-catch-finally 187
6.5 Zusammenfassung 188
7 Dynamische Objektorientierung nach Groovy-Art 189
7.1 Definieren von Klassen und Skripten 190
7.1.1 Definieren von Feldern und lokalen Variablen 190
7.1.2 Methoden und Parameter 193
7.1.3 Mit dem Operator ?. sicher dereferenzieren 197
7.1.4 Konstruktoren 198
7.2 Organisieren von Klassen und Skripten 201
7.2.1 Beziehung zwischen Datei und Klasse 201
7.2.2 Organisieren von Klassen in Packages 202
7.2.3 Weitere Überlegungen zum Klassenpfad 206
7.3 Fortgeschrittene OO-Merkmale 207
7.3.1 Vererbung 207
7.3.2 Interfaces 208
7.3.3 Multimethoden 209
7.4 GroovyBeans 211
7.4.1 Deklaration von Beans 211
7.4.2 Umgang mit Beans 213
7.4.3 Bean-Methoden für alle Objekte 216
7.4.4 Felder, Zugriffsmethoden, Maps und Expando 217
7.5 Power-Features 218
7.5.1 Objekte mit GPaths abfragen 219
7.5.2 Den Spread-Operator injizieren 223
7.5.3 Kategorienmix mit use 223
7.6 Meta-Programmierung in Groovy 226
7.6.1 Das Konzept der MetaClass 226
7.6.2 Methoden aufrufen und abfangen 228
7.6.3 Abfangen von Methoden 230
7.7 Zusammenfassung 233
Teil 2 Die Groovy-Bibliothek 235
8 Builder 237
8.1 Learning by doing – Verwendung eines Builders 238
8.2 Erstellen von Objektbäumen mit NodeBuilder 241
8.2.1 NodeBuilder in Aktion – der Builder-Code 242
8.2.2 Das Builder-Konzept 243
8.2.3 Intelligente Builder mit Logik 244
8.3 Arbeiten mit MarkupBuilder 246
8.3.1 Erstellen von XML 246
8.3.2 Erstellen von HTML 247
8.4 Aufgaben automatisieren mit AntBuilder 249
8.4.1 Von Ant-Skripten zu Groovy-Skripten 250
8.4.2 Wie AntBuilder funktioniert 251
8.4.3 Intelligente Automatisierungsskripte mit Logik 252
8.5 GUIs ganz easy mit SwingBuilder 253
8.5.1 Passwort lesen mit dem SwingBuilder 254
8.5.2 Erstellen von Swing-Widgets 256
8.5.3 Widgets anordnen 259
8.5.4 Referenzieren von Widgets 262
8.5.5 Swing-Actions 265
8.5.6 Verwendung von Modellen 267
8.5.7 Von den Teilen zum Ganzen 269
8.6 Eigene Builder erstellen 275
8.6.1 Unterklassen für BuilderSupport 276
8.6.2 Das DebugBuilder-Beispiel 278
8.7 Zusammenfassung 280
9 Das GDK 281
9.1 Objekte 282
9.1.1 Interaktive Objekte 282
9.1.2 Bequemlichkeitsmethoden von Object 288
9.1.3 Iterative Object-Methoden 290
9.2 Arbeiten mit Dateien und I/O 293
9.2.1 Durchquerung des Dateisystems 295
9.2.2 Eingabequellen lesen 296
9.2.3 Ausgaben schreiben 298
9.2.4 Filter und Konvertierungen 299
9.2.5 Serialisierte Objekt-Streams 301
9.3 Threads und Prozesse 302
9.3.1 Groovy-Multithreading 302
9.3.2 Integrieren externer Prozesse 304
9.4 Die Arbeit mit Templates 309
9.4.1 Das Format von Templates 309
9.4.2 Templates in Aktion 310
9.4.3 Templates für Fortgeschrittene 312
9.5 Groovlets 313
9.5.1 „Hello World“ 313
9.5.2 Die Groovlet-Bindung 315
9.5.3 Templates und Groovlets 318
9.6 Zusammenfassung 320
10 Datenbankprogrammierung mit Groovy 323
10.1 Grundlegende Datenbankoperationen 324
10.1.1 Datenbankzugriff einrichten 325
10.1.2 SQL ausführen 328
10.1.3 Daten abfragen 333
10.1.4 Von den Teilen zum Ganzen 336
10.2 DataSets für SQL ohne SQL 338
10.2.1 DataSet-Operationen verwenden 339
10.2.2 DataSets auf Datenbank-Views 342
10.3 Organisieren der Datenbankarbeit 344
10.3.1 Überblick über die Architektur 344
10.3.2 Verhalten der Anwendung spezifizieren 346
10.3.3 Implementierung der Infrastruktur 347
10.3.4 Ein transparentes Domain-Modell 351
10.3.5 Implementierung der Anwendungsschicht 352
10.4 Groovy und ORM 353
10.5 Zusammenfassung 354
11 Groovy-Integration 357
11.1 Vorbereitung auf die Integration 358
11.1.1 Richtig integrieren 358
11.1.2 Abhängigkeiten einrichten 360
11.2 Ausdrücke und Skripte auswerten mit GroovyShell 361
11.2.1 Aller Anfang ist leicht 361
11.2.2 Übergabe von Parametern in einer Bindung 363
11.2.3 Dynamische Klassen zur Laufzeit generieren 365
11.2.4 Skripte parsen 365
11.2.5 Skripte oder Klassen ausführen 366
11.2.6 Weitere Parametrisierung von GroovyShell 367
11.3 Die Groovy-Skript-Engine 371
11.3.1 Einrichten der Engine 371
11.3.2 Skripte ausführen 371
11.3.3 Abweichenden Ressourcenkonnektor definieren 372
11.4 Der GroovyClassLoader 373
11.4.1 Groovy-Klassen parsen und laden 373
11.4.2 Was war zuerst da: Die Henne oder das Ei? 375
11.4.3 Ein benutzerdefinierter Resource-Loader 378
11.4.4 Sicherheit in der Sandbox 379
11.5 Spring-Integration 382
11.5.1 GroovyBeans mit Spring verdrahten 383
11.5.2 Aktualisierbare Beans 385
11.5.3 Inline-Skripte 385
11.6 Mustang und JSR-223 386
11.6.1 Einführung in JSR-223 386
11.6.2 Der Skript-Engine-Manager und seine Skript-Engines 387
11.6.3 Kompilierbare und aufrufbare Skript-Engines 388
11.7 Die Wahl des richtigen Integrationsmechanismus 391
11.8 Zusammenfassung 392
12 Arbeiten mit XML 393
12.1 XML-Dokumente lesen 394
12.1.1 Arbeiten mit einem DOM-Parser 395
12.1.2 Daten lesen mit dem Groovy-Parser 399
12.1.3 Lesen mit einem SAX-Parser 404
12.1.4 Lesen mit einem StAX-Parser 405
12.2 XML verarbeiten 407
12.2.1 Vor Ort-Verarbeitung 408
12.2.2 Streaming-Verarbeitung 410
12.2.3 Kombination mit XPath 415
12.3 Verteilte Verarbeitung mit XML 422
12.3.1 Überblick über Webdienste 422
12.3.2 RSS und ATOM lesen 423
12.3.3 Ein REST-basiertes API 425
12.3.4 XML-RPC 428
12.3.5 Anwendung von SOAP 430
12.4 Zusammenfassung 435
Teil 3 Groovy für jeden Tag 437
13 Tipps und Tricks 439
13.1 Was Sie sich merken sollten 440
13.1.1 Gleichheit versus Identität 440
13.1.2 Klammern richtig setzen 440
13.1.3 Rückkehr aus Methoden und Closures 441
13.1.4 Methoden aufrufen im Builder-Code 442
13.1.5 Qualifizierter Zugriff auf „this“ 444
13.1.6 Numerische Typen 445
13.1.7 Ant 446
13.1.8 Skripte sind Klassen, nur anders 448
13.2 Nützliche Codefragmente 451
13.2.1 Eine Collection mischen 451
13.2.2 Text durcheinanderwürfeln mit regulären Ausdrücken 452
13.2.3 Fortschrittsanzeige auf der Konsole 452
13.2.4 Selbstkommentierende Einzelschritte 453
13.2.5 GString für Fortgeschrittene 454
13.3 Groovy auf der Kommandozeile 455
13.3.1 Kommandozeilenskripte auswerten 456
13.3.2 Die Optionen print und line 457
13.3.3 Der Lauschmodus 458
13.3.4 Vor-Ort-Bearbeitung auf der Kommandozeile 459
13.4 Automatisierungsskripte 459
13.4.1 Konsistente Unterstützung für Kommandozeilenoptionen 460
13.4.2 Klassenpfad mit RootLoader erweitern 463
13.4.3 Ausführungsfahrplan für Skripte 465
13.5 Beispiele für die Automatisierung von Tasks 467
13.5.1 Scraping von HTML-Seiten 467
13.5.2 Automatisieren von Webaktionen 469
13.5.3 Versionskontrolle inspizieren 471
13.5.4 Pragmatische Codeanalyse 472
13.5.5 Weitere interessante Punkte 473
13.6 Layout des Arbeitsbereichs 474
13.6.1 IDE-Setup 475
13.6.2 Debugging 476
13.6.3 Profiling 480
13.6.4 Refactoring 481
13.7 Zusammenfassung 482
14 Unit Testing mit Groovy 483
14.1 Erste Schritte 484
14.1.1 Tests schreiben ist einfach 484
14.1.2 GroovyTestCase: Eine Einführung 485
14.1.3 GroovyTestCase 486
14.2 Unit Testing für Groovy-Code 487
14.3 Unit Testing für Java-Code 491
14.4 Tests organisieren 494
14.5 Fortgeschrittene Testmethoden 495
14.5.1 Testen wird groovy 496
14.5.2 Stubs und Mocks 497
14.5.3 GroovyLogTestCase 502
14.6 IDE-Integration 504
14.6.1 Verwenden von GroovyTestSuite 504
14.6.2 Verwenden von AllTestSuite 506
14.6.3 Fortgeschrittene IDE-Integration 507
14.7 Tools für Groovy-Testing 509
14.7.1 Code-Abdeckung mit Groovy 509
14.7.2 JUnit-Erweiterungen 512
14.8 Build-Automatisierung 515
14.8.1 Build-Integration mit Ant 515
14.8.2 Build-Integration mit Maven 516
14.9 Zusammenfassung 519
15 Windows wird Groovy 521
15.1 Scriptom herunterladen und installieren 522
15.2 Scriptom intern 523
15.2.1 Jacob 523
15.2.2 Instanzieren einer ActiveX-Komponente 525
15.2.3 Methoden aufrufen 527
15.2.4 Zugriff auf Properties und Rückgabewerte 529
15.2.5 Event-Unterstützung 529
15.3 Praxis-Szenario: Automatisieren der Lokalisierung 532
15.3.1 Entwurf des Dokumentformats 533
15.3.2 Entwurf des Thesaurus 533
15.3.3 Erstellen eines Word-Dokuments 535
15.3.4 Erstellung des endgültigen Dokuments 537
15.4 Automatisierung weiterer Anwendungen 539
15.4.1 Zugriff auf die Windows-Registrierung 539
15.4.2 Ein eigenes Automatisierungssystem programmieren 540
15.5 Verfügbare Dokumentation 542
15.6 Zusammenfassung 543
16 Ich sehe das Licht: Grails 545
16.1 Die Ausgangssituation 545
16.1.1 Grails installieren 546
16.1.2 Die ersten Schritte 547
16.2 Erstellen des Domain-Modells 549
16.2.1 Die Use Cases 550
16.2.2 Beziehungen designen 550
16.3 Implementierung des Domain-Modells 551
16.3.1 Scaffolding der Domain-Klassen 552
16.3.2 Scaffolding der Views und Controller 553
16.3.3 Testen der Webanwendung 554
16.3.4 Vervollständigen des Domain-Modells 555
16.4 Anpassen der Views 557
16.4.1 Bootstrapping von Daten 557
16.4.2 Arbeiten mit Groovy Server Pages 558
16.4.3 Arbeiten mit Tag-Bibliotheken 561
16.5 Arbeiten mit Controllern und Finder-Methoden 563
16.6 Ausarbeitung des Modells 566
16.7 Arbeiten mit der Session 567
16.8 Das Finish 571
16.8.1 Constraints validieren 571
16.8.2 Die Anwendung herausgeben 572
16.8.3 Abschied 574
A Installation und Dokumentation 577
A.1 Installation 577
A.2 Aktuelle Dokumentation beschaffen 578
A.2.1 Online-Ressourcen 578
A.2.2 Abonnieren von Mailinglisten 579
A.2.3 Verbindung mit dem Forum und Chat 579
B Infos zur Programmiersprache Groovy 581
B.1 Schlüsselwörter 582
C GDK-API-Kurzreferenz 583
C.1 Arrays und Primitives 583
C.2 Das Package java.lang 584
C.3 Das Package java.math 588
C.4 Die Packages java.util und java.sql 589
C.5 Das Package java.util.regex 591
C.6 Das Package java.io 592
C.7 Das Package java.net 595
D Spickzettel 597
D.1 Listen 597
D.2 Closures 598
D.3 Reguläre Ausdrücke 598
D.4 Unit Testing 600
D.5 Mocks und Stubs 600
D.6 XML-GPath-Notation 601
Register 603

Textauszug

Teil 1
Die Programmiersprache Groovy (S. 25-26)

Eine neue Programmiersprache zu lernen ist, als wolle man sich eine Fremdsprache aneignen: Man muss neue Vokabeln, grammatische Strukturen und Ausdrücke pauken, doch dieser Anfangsaufwand zahlt sich mehrfach aus. Einzigartige Ausdrucksmöglichkeiten, neue Konzepte und ein neuer Stil bereichern Ihre persönlichen Fähigkeiten, und vielleicht sehen Sie sogar die Welt mit anderen Augen. So ging es uns mit Groovy, und wir hoffen, dass Groovy für Sie denselben Effekt hat.

Der erste Teil dieses Buchs ist eine Einführung in die Grundlagen der Sprache – in die Syntax, Grammatik und typischen Idiome von Groovy, die allerdings nicht in einem akademischen Stil, sondern anhand von Beispielen präsentiert werden.

Diesen Teil können Sie beim ersten Lesen überfliegen, und später, wenn Sie ernsthaft mit Groovy programmieren, noch einmal durchgehen. Wenn Sie ihn zuerst überfliegen, sollten Sie aber zumindest Kapitel 2 und die dortigen Beispiele gründlicher lesen. Diese enthalten Querverweise zu den Detailkapiteln, damit Sie leichter die Einzelheiten jedes Themas, das Sie interessiert, nachschlagen können.

Eine Schwierigkeit bei der Erläuterung einer Programmiersprache anhand von Beispielen besteht darin, dass man ja irgendwo beginnen muss – doch wo man auch beginnt, irgendwann benötigt man unweigerlich ein Konzept oder Merkmal, das bisher noch nicht eingeführt wurde. Abschnitt 2.3 behebt dieses Problem durch eine Sammlung von selbsterklärenden Beispielen zum Warmwerden.

Wir erläutern den Hauptteil der Programmiersprache anhand von vordefinierten Datentypen und führen im Laufe der Zeit Ausdrücke, Operatoren und Schlüsselwörter ein. Dadurch, dass wir immer mit den vertrauten Aspekten der Sprache beginnen und auf diesem Wissen aufbauen, gelingt uns hoffentlich, dass Sie sich auch bei der Erkundung neuen Terrains wohlfühlen.

In Kapitel 3 werden die Groovy-Typisierungsstrategie und die Text- und Zahlentypen eingeführt, die Groovy auf der Sprachebene unterstützt.

In Kapitel 4 geht es weiter mit den vielen integrierten Groovy-Datentypen, wobei die mengenwertigen Typen im Vordergrund stehen: Ranges, Listen und Maps.

Kapitel 5 baut auf dem Vorherigen auf und erläutert genauer das Konzept der Closures. In Kapitel 6 werden logische Verzweigungen, Schleifen und das Abkürzen der Programmausführung behandelt.

Abschließend erläutert Kapitel 7, wie Groovy, aufbauend auf der Objektorientierung von Java, neue Höhen der dynamischen Ausführung ermöglicht.

Am Ende von Teil 1 ist das Gesamtbild der Programmiersprache Groovy komplett. Auf dieser Grundlage können Sie am besten aus Teil 2 profitieren, der die Groovy-Bibliothek erläutert – also die Klassen und Methoden, die Groovy der Java-Plattform hinzufügt. In Teil 3, „Groovy für jeden Tag", wird das in den Teilen 1 und 2 aufgebaute Wissen auf die alltäglichen Aufgaben der Programmierung angewendet.

Produkt-Details

• Erscheint lt. Verlag: 1.1.2007
• Sprache: deutsch
• Themenwelt: Informatik ► Programmiersprachen / -werkzeuge ► Java
• ISBN-10: 3-446-41412-6 / 3446414126
• ISBN-13: 978-3-446-41412-9 / 9783446414129