infos zu klassen und methoden
parent
12f70d21f8
commit
9e02f2a64c
|
|
@ -0,0 +1,292 @@
|
|||
## Klassen
|
||||
|
||||
- Definition einer Klasse
|
||||
Klassen in Groovy werden ähnlich wie in Java definiert, jedoch mit einigen
|
||||
syntaktischen Erleichterungen
|
||||
|
||||
Beispiel
|
||||
```
|
||||
class Person {
|
||||
String name
|
||||
int age
|
||||
}
|
||||
```
|
||||
|
||||
- Eigenschaften
|
||||
Eigenschaften können direkt als Felder definiert werden. Groovy
|
||||
generiert automatisch Getter- und Setter-Methoden (wie in Ruby)
|
||||
|
||||
Beispiel
|
||||
```
|
||||
Person person = new Person()
|
||||
person.name = "John"
|
||||
person.age = 30
|
||||
person.age = 30
|
||||
println person.name
|
||||
//John
|
||||
```
|
||||
|
||||
Getter und Setter können aber auch manuell überschrieben werden
|
||||
|
||||
Beispiel
|
||||
|
||||
```
|
||||
class Fruits {
|
||||
private String fruitName
|
||||
private String fruitColor
|
||||
|
||||
def setFruitName(String name) {
|
||||
fruitName = name
|
||||
}
|
||||
|
||||
def getFruitName() {
|
||||
return "The fruitname is $fruitName"
|
||||
}
|
||||
|
||||
def setFruitColor(String color) {
|
||||
fruitColor = color
|
||||
}
|
||||
|
||||
def getFruitColor(){
|
||||
return "The color is $fruitColor"
|
||||
}
|
||||
|
||||
static void(args) {
|
||||
//Instanz erstellen
|
||||
Fruits apple = new Fruits()
|
||||
apple.setFruitName("apple")
|
||||
apple.setFruitColor("red")
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
-Konstruktoren
|
||||
Groovy fügt automatisch einen Standardkonstruktor hinzu. Man kann auch
|
||||
benutzerdefinierte Konstruktoren definieren.
|
||||
```
|
||||
class Person {
|
||||
String name
|
||||
int age
|
||||
|
||||
Person(String name, int age) {
|
||||
this.name = name
|
||||
this.age = age
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
-Standardkonstruktor mit Map
|
||||
Groovy bietet eine spezielle Initialisierungsform mit einer Map an
|
||||
```
|
||||
Person person = new Person(name: 'John', age: 30)
|
||||
```
|
||||
|
||||
## Methoden
|
||||
|
||||
- Definition einer Methode
|
||||
Methoden werden ähnlich wie in Java definiert, können aber optional einen Rückgabetyp
|
||||
haben
|
||||
```
|
||||
class Calculator {
|
||||
int add(int a, int b) {
|
||||
return a + b
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
In Groovy können Methoden direkt ohne Klasse und main-Methode definiert und aufgerufen werden.
|
||||
|
||||
Beispiel 1
|
||||
```
|
||||
def printHello() {
|
||||
println "Hello..."
|
||||
}
|
||||
|
||||
printHello()
|
||||
|
||||
def sum(int a, int b) {
|
||||
println "Sum is "+(a+b)
|
||||
}
|
||||
|
||||
sum(5,2)
|
||||
//Hello...
|
||||
// 7
|
||||
```
|
||||
|
||||
- Instanzmethoden
|
||||
Methoden können Instanzmethoden sein und auf Instanzvariablen zugreifen.
|
||||
```
|
||||
class Method {
|
||||
|
||||
static void main(args) {
|
||||
Method myFunc = new Method()
|
||||
myFunc.myMethod()
|
||||
}
|
||||
|
||||
def myMethod() {
|
||||
println("I am inside my method")
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
- Statische Methoden
|
||||
```
|
||||
class MathUtils {
|
||||
// Definition einer statischen Methode
|
||||
static int add(int a, int b) {
|
||||
return a + b
|
||||
}
|
||||
|
||||
static void main(String[] args) {
|
||||
// Aufruf der statischen Methode ohne Instanz der Klasse
|
||||
int result = MathUtils.add(5, 10)
|
||||
println("Sum is $result") // Ausgabe: Sum is 15
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
- Dynamische Methoden
|
||||
Groovy erlaubt es, Methoden zur Laufzeit hinzuzufügen.
|
||||
In diesem Beispiel wird die Methode sayHello zur Klasse DynamicExample hinzugefügt, nachdem die Klasse bereits definiert wurde
|
||||
|
||||
Beispiel
|
||||
```
|
||||
class DynamicExample {}
|
||||
|
||||
// Hinzufügen einer Methode zur Laufzeit
|
||||
DynamicExample.metaClass.sayHello = { -> println "Hello, World!" }
|
||||
|
||||
def example = new DynamicExample()
|
||||
example.sayHello()
|
||||
```
|
||||
|
||||
- Expando
|
||||
Ist eine spezielle Klassen in Groovy, die ermöglicht Objekten zur Laufzeit dynamisch Methoden und Eigenschaften hinzuzufügen. Dadurch ist die vorherige Deklaration der Felder in der Klasse nicht nötig
|
||||
|
||||
Beispiel
|
||||
```
|
||||
// Erstellen eines Expando-Objekts
|
||||
def expando = new Expando()
|
||||
|
||||
// Hinzufügen einer Eigenschaft 'name' und Zuweisung des Wertes "Groovy"
|
||||
expando.name = "Groovy"
|
||||
|
||||
// Hinzufügen einer Methode 'sayHello', die eine Nachricht ausgibt, die die Eigenschaft 'name' verwendet
|
||||
expando.sayHello = { -> println "Hello from $name" }
|
||||
|
||||
// Aufrufen der Methode 'sayHello', was die Nachricht "Hello from Groovy" ausgibt
|
||||
expando.sayHello() // Ausgabe: Hello from Groovy
|
||||
```
|
||||
|
||||
- Default-Parameterwerte
|
||||
Methodenparameter können Standdardwerte haben(wie in Ruby)
|
||||
|
||||
Beispiel 1
|
||||
```
|
||||
class Greeter {
|
||||
void greet(String name = "World") {
|
||||
println "Hello, $name!"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Ruft man die Methode ohne Parameter auf, werden die Default-Paramter eingesetzt
|
||||
Beispiel 2
|
||||
```
|
||||
def sum(int a=10, int b=3) {
|
||||
println "Sum is "+(a+b)
|
||||
}
|
||||
|
||||
sum()
|
||||
```
|
||||
|
||||
|
||||
- Closures
|
||||
Closures können auf Variablen aus ihrem umgebenden Gültigkeitsbereich zugreifen und diese „einfangen“. Dadurch können sie auf Werte zugreifen, die zum Zeitpunkt ihrer Erstellung existierten.
|
||||
|
||||
1. Parameter
|
||||
```
|
||||
def greet = { String name -> println "Hello, $name!" }
|
||||
greet.call("John")
|
||||
```
|
||||
|
||||
2. Referenzierung von Variablen und Rückgabewerte
|
||||
```
|
||||
def createCounter() {
|
||||
def count = 0
|
||||
return { ->
|
||||
count += 1
|
||||
return count
|
||||
}
|
||||
}
|
||||
|
||||
def counter = createCounter()
|
||||
println(counter()) // Ausgabe: 1
|
||||
println(counter()) // Ausgabe: 2
|
||||
```
|
||||
|
||||
|
||||
3. Übergabe als Parameter
|
||||
```
|
||||
def performOperation(int x, Closure operation) {
|
||||
return operation(x)
|
||||
}
|
||||
|
||||
def closure = { y -> y * 2 }
|
||||
def result = performOperation(5, closure)
|
||||
println(result) // Ausgabe: 10
|
||||
```
|
||||
|
||||
Methoden können auch auf Maps und Listen angewendet werden, besonders nützlich mit Closures.
|
||||
```
|
||||
def myMap = [ 'subject': 'groovy', 'topic': 'closures']
|
||||
println myMap.each { it }
|
||||
|
||||
def myList = [1, 2, 3, 4, 5]
|
||||
println myList.find { item -> item == 3 } // 3
|
||||
println myList.findAll { item -> item > 3 } // [4, 5]
|
||||
println myList.any { item -> item > 5 } // false
|
||||
println myList.every { item -> item > 3 } // false
|
||||
println myList.collect { item -> item * 2 } // [2, 4, 6, 8, 10]
|
||||
```
|
||||
|
||||
- Methodenverkettung
|
||||
Durch das Rückgeben von this kann man Methodenaufrufe verketten.
|
||||
|
||||
Beispiel
|
||||
```
|
||||
class FluentPerson {
|
||||
String name
|
||||
int age
|
||||
|
||||
FluentPerson setName(String name) {
|
||||
this.name = name
|
||||
return this
|
||||
}
|
||||
|
||||
FluentPerson setAge(int age) {
|
||||
this.age = age
|
||||
return this
|
||||
}
|
||||
}
|
||||
|
||||
def person = new FluentPerson().setName("John").setAge(30)
|
||||
```
|
||||
|
||||
- Mixin(Misching)
|
||||
Man kann Funktionalität zu Klassen hinzufügen, ohne Vererbung zu verwenden, indem man Mixins verwendet.
|
||||
|
||||
Beispiel
|
||||
```
|
||||
class ExtraMethods {
|
||||
String shout(String str) {
|
||||
return str.toUpperCase()
|
||||
}
|
||||
}
|
||||
|
||||
@Mixin(ExtraMethods)
|
||||
class MyClass {}
|
||||
|
||||
def myObject = new MyClass()
|
||||
println myObject.shout("hello")
|
||||
```
|
||||
Loading…
Reference in New Issue