O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Groovy – kurz & gut

Book Description

Groovy ist eine dynamische Programmiersprache für die JVM, die unter Java-Entwicklern immer beliebter wird. Groovy erweitert Java um spannende neue Features, die von Sprachen wie Python und Ruby inspiriert sind, und greift gleichzeitig auf die Stärken von Java zurück. Dieses verständliche Buch richtet sich an Java-Entwickler, die einen schnellen Einstieg in die Arbeit mit Groovy suchen. Es macht Sie mit den konzeptionellen Grundlagen der Sprache, ihrer Syntax sowie den Besonderheiten im Vergleich zu Java vertraut.

Table of Contents

  1. Einleitung
  2. 1. Grundlagen
    1. Groovy ist (nicht) Java
      1. Script- und Compilersprache
      2. Die Syntax: Java mit vielen Erweiterungen
      3. Dynamik und optionale Typisierung
      4. Massiv erweiterte Laufzeitumgebung
    2. Mit Groovy arbeiten
      1. Groovy installieren
        1. Voraussetzung: Java-Laufzeitumgebung
        2. Herunterladen und entpacken
        3. Alternative Installationsmöglichkeiten
        4. Verzeichnisse der Groovy-Installation
        5. Das Arbeitsverzeichnis
      2. Programme schreiben und starten
        1. Groovy-Compiler
        2. Groovy-Starter
        3. Groovy-Shell
        4. Groovy-Konsole
        5. Groovy-Webkonsole
      3. Java-IDEs nutzen
      4. Build-Tools und Repositories einsetzen
        1. Ant
        2. Maven
        3. Gradle
        4. Repository
  3. 2. Die Sprache im Überblick
    1. Codestruktur
      1. Programme in Scriptform
      2. Shell-Scripts mit Groovy
      3. Klassen und Quelldateien
      4. Importe
        1. Importanweisungen an beliebiger Stelle
        2. Standardimporte
        3. Aliasnamen für importierte Typen
      5. Klassenpfade
        1. Den Klassenpfad konfigurieren
        2. Den Klassenpfad dynamisch erweitern
        3. Grape und @Grab
    2. Globale Funktionen
      1. Konsolenausgaben mit print(), println() und printf()
      2. Pausieren mit sleep()
      3. Typen erweitern mit use()
    3. Syntaxabwandlungen
      1. Anweisungen mit und ohne Semikolon
      2. Keine checked Exceptions
      3. Klassenliterale ohne class
      4. Mehrfachzuweisungen
      5. this im statischen Kontext
      6. Annotationen
      7. Einschränkungen
        1. Innere Klassen
        2. Array-Initialisierer
        3. Zeichenliterale
        4. Generische Typen
        5. Die klassische for-Schleife
        6. Zuweisungen in Bedingungen
    4. Namensregeln
      1. Reservierte Wörter
      2. Namen in Anführungszeichen
      3. Konventionen
    5. Sichtbarkeiten
      1. Typen und Methoden standardmäßig öffentlich
      2. Felder werden zu Properties
      3. Private Member bleiben ungeschützt
    6. Datentypen
      1. Alles ist ein Objekt
      2. Dynamische Typisierung
      3. Dynamische Methodenauflösung
      4. Typen sind dynamisch erweiterbar
        1. Das Groovy-JDK (oder GDK)
      5. Typanpassungen
        1. Implizite Typanpassung
        2. Explizite Typanpassung
    7. Literale
      1. Zahlen
      2. Zeichenketten
        1. Einfache Anführungszeichen
        2. Doppelte Anführungszeichen
        3. Dreifache Anführungszeichen
        4. Schrägstrich und Dollar-Schrägstrich
    8. Operatoren
      1. Operatormethoden
      2. Gleichheit und Identität
      3. Weitere Operatoren
    9. Methoden und Konstruktoren
      1. Argumentlisten ohne Klammern
      2. Optionale Parameter
      3. Benannte Parameter bei Methoden
      4. Benannte Parameter bei Konstruktoren
      5. Variable Argumentlisten
      6. Der Spread-Operator
      7. Methoden mit einem Parameter
      8. Optionale Return-Anweisung
    10. Properties
      1. Konventionelle Properties
        1. Properties und Annotationen
      2. Auf Properties zugreifen
        1. Der Feldzugriff-Operator @
        2. Interne Zugriffe auf Properties
        3. Vorhandene Properties ermitteln
    11. Listen und Maps
      1. Listen erzeugen
      2. Auf Listenelemente zugreifen
      3. Der Spread-Dot-Operator
      4. Maps erzeugen
      5. Auf Map-Elemente zugreifen
      6. Wertebereiche (Ranges)
    12. Funktionen als Objekte
      1. Einfache Closures
      2. Closures mit expliziten Parametern
      3. Closures als Methodenreferenzen
      4. Closures als Methodenparameter
    13. Traits
      1. Traits definieren
      2. Traits implementieren
      3. Das Problem der Mehrfachvererbung
      4. Instanzspezifische Implementierung von Traits
    14. Kontrollstrukturen
      1. Die Groovy-Wahrheit
      2. For-Each-Schleifen
      3. Mächtiges Switch-Case
        1. Switch mit Enums
      4. Bedingte Ausdrücke
      5. Informative Zusicherungen mit assert
        1. Assert-Syntax
        2. Vielsagende Fehlermeldungen
  4. 3. Scripting
    1. Scriptobjekte
      1. Die Scriptklasse
      2. Eigene Scriptbasisklassen
        1. Scriptannotation
        2. Aufrufoptionen
      3. Das Binding
        1. Aufrufargumente
      4. Script im Script
      5. Standardausgaben im Script
    2. Programme als Scripts starten
      1. Ausführbare Klassen
    3. Eingebettete Scripts
      1. Benötigte Bibliotheken
      2. Scripts kompilieren und starten
      3. Ausdrücke auswerten
      4. Dynamische Klassen nutzen
      5. Absicherung
      6. Zusätzliche Funktionalität im Script
        1. Closures als Methoden
        2. Alternative Scriptklassen
  5. 4. Closures
    1. Closure-Objekte
      1. Parameter
      2. Der Closure-Kontext
    2. Operationen mit Closures
      1. Currying
      2. Rekursion
        1. Trampoline
      3. Memoisation
    3. Interfaces und abstrakte Klassen implementieren
      1. Funktionale Interfaces
      2. Interfaces mit mehreren Methoden
      3. Abstrakte Klassen implementieren
    4. Closures und Java-8-Lambdas
      1. Closures ersetzen Lambda-Ausdrücke
      2. Ähnlich und doch verschieden
      3. Vor- und Nachteile
  6. 5. Dynamische Objekte
    1. Das Interface GroovyObject
    2. Die Metaklasse und das Metaobjekt-Protokoll
      1. Metaklassen auswechseln
    3. Dynamische Methoden und Properties
      1. Wozu Dynamik in Objekten?
      2. Dynamische Mechanismen
      3. Vererbungsregeln
      4. Dynamische Aufrufe
        1. Methoden
        2. Properties
    4. Informationen über Objekte
      1. Existenz von Methoden und Properties prüfen
      2. Vorhandene Methoden und Properties ermitteln
    5. Metaprogrammierung in der Klasse
      1. Methodenaufrufe abfangen
      2. Properties umdefinieren
      3. Pseudomethoden und -properties
    6. Kategorien
      1. Die use()-Funktion
      2. Die @Category-Transformation
      3. Kategorienklassen als Mixins
    7. Erweiterungsmodule
      1. Die Erweiterungsklassen
      2. Die Beschreibungsdatei
      3. Das Erweiterungsmodul einsetzen
    8. Die ExpandoMetaClass
      1. Zusätzliche Methoden
        1. Methoden überladen
        2. Zusätzliche Methoden an einzelnen Objekten
        3. Statische Methoden
      2. Zusätzliche Properties
      3. Die ExpandoMetaClass-DSL
    9. Dynamik abschalten
      1. Statische Typprüfung
      2. Statisches Kompilieren
        1. Ausnahmen zulassen
        2. Closure-Delegates deklarieren
  7. 6. JDK-Erweiterungen
    1. GDK-Methoden und -Properties
      1. Das Prinzip
      2. Methoden für alle Objekte
    2. Zahlen und Arithmetik
      1. Typanpassungen bei arithmetischen Operationen
      2. Numerische Methoden
    3. Texte und Zeichen
      1. GDK-Erweiterungen für String und StringBuffer
        1. Operatoren und Methoden zur Textmanipulation
        2. String-Inhalt prüfen
        3. Strings als Listen von Zeichen
      2. Die Klasse GString
      3. Reguläre Ausdrücke
    4. Listen und andere iterierbare Objekte
      1. Operatoren für Listen
      2. Erweiterungen für Listen und Kollektionen
    5. Dateien und Datenströme
      1. Navigieren im Dateisystem
      2. Textdaten
        1. Auf komplette Textdateien zugreifen
        2. Zeichensätze berücksichtigen
        3. Texte aus anderen Quellen lesen
        4. Texte zeilenweise lesen und schreiben
        5. Filter und Transformationen
        6. Writable-Objekte
      3. Binärdaten
        1. Binärdaten komplett lesen und schreiben
        2. Daten byteweise lesen
  8. 7. Zusätzliche APIs
    1. Builder
      1. Funktionsweise
      2. Der NodeBuilder
      3. Deklarativen und algorithmischen Stil mischen
      4. Unterbäume ausgliedern
      5. Baumnavigation mit GPath
    2. Templates
      1. Das Vorgehen
      2. Die Template-Syntax
      3. Die SimpleTemplateEngine
      4. Fehlerbehandlung
    3. SQL
      1. Datenbankverbindung öffnen und schließen
      2. Allgemeine SQL-Befehle
      3. Prepared Statements mit GStrings
      4. SQL-Abfragen
      5. Datasets
    4. XML und JSON
      1. XML-Dokumente einlesen
        1. Der XmlParser
        2. Der XmlNodePrinter
        3. Der XmlSlurper
      2. XML-Dokumente aufbauen
        1. Der MarkupBuilder
        2. Der StreamingMarkupBuilder
      3. JSON-Dokumente lesen und schreiben
        1. Der JsonSlurper
        2. Der JsonBuilder
        3. Der StreamingJsonBuilder
    5. Webanwendungen
      1. Vorbereitungen
      2. Groovlets und das GroovyServlet
      3. Das TemplateServlet
  9. 8. Referenzteil
    1. Die Groovy-Laufzeitumgebung
      1. Package-Struktur
      2. Teilbibliotheken
    2. Tools und Optionen
      1. grape – Verwaltung der Modulabhängigkeiten
      2. groovy – Groovy-Starter
      3. groovyc – Groovy-Compiler
      4. groovyConsole – interaktive Konsole
      5. groovydoc – Groovy-Dokumentationsgenerator
      6. groovysh – Groovy-Shell
    3. AST-Transformationen
      1. Package groovy.lang
      2. Package groovy.transform
      3. Package groovy.beans
      4. Package groovy.util.logging
  10. Stichwortverzeichnis
  11. Copyright