groovy-lecture/skript/klassen.md

# Klassen

### Definition einer Klasse


Klassen in Groovy werden ähnlich wie in Java definiert, jedoch mit einigen
syntaktischen Erleichterungen: mit dem class-Schlüsselwort, ohne Semikolon

Beispiel
  ```Groovy
  class Person {
    String name
    int age
}
  ```
  
  
### Konstruktoren

Groovy fügt automatisch einen Standardkonstruktor (="Default-Konstruktor") hinzu, wenn
keine Konstruktoren explizit definiert sind. Dieser Standardkonstruktor initialisiert alle
Eigenschaften der Klasse mit ihren Standardwerten.
Man kann auch benutzerdefinierte Konstruktoren definieren oder die beiden Konstruktorarten
auch gleichzeitig nutzen. Man spricht dabei von Konstruktorüberladung (auch wie in Java,
C++, C#...)

  ```Groovy
class Person {
  String name
  int age
  
  //Default-Konstruktor
  def person = new Person()
  
  //benutzerdefinierter Konstruktor
  Person(String name, int age) {
      this.name = name
      this.age = age
    }
}
```

```Groovy
class Person {
    String name
    int age

    Person() {
        // Standardkonstruktor
    }

    Person(String name, int age) {
        this.name = name
        this.age = age
    }
}

def person1 = new Person()
println(person1.name)  // Ausgabe: null
println(person1.age)   // Ausgabe: 0

def person2 = new Person("Alice", 30)
println(person2.name)  // Ausgabe: Alice
println(person2.age)   // Ausgabe: 30
```


### Standardkonstruktor mit Map

Groovy bietet eine spezielle Initialisierungsform mit einer Map an. Dieser Konstruktor
ermöglicht Objekte einfach und übersichtlich zu initialisieren, indem die Eigenschaften
des Objekts direkt in Form von Schlüssel-Wert-Paaren in der Map angegeben werden.
Groovy kümmert sich dann um die Zuordnung der Werte zu den entsprechenden Feldern der Klasse.
Der Map-Konstruktor muss nicht explizit definiert werden (hier nur als Beispiel), da es ein eingebautes Standard-Feature von Groovy ist.
  ```Groovy
  class Person {
    String name
    int age

    // Map-Konstruktor
    Person(Map properties) {
        properties.each { key, value -> this."$key" = value }
    }
}

Person person = new Person(name: 'John', age: 30)
println(person.name)  // Ausgabe: John
println(person.age)   // Ausgabe: 30
  ```

  
### Eigenschaften

Eigenschaften können direkt als Felder definiert werden. Groovy
generiert automatisch Getter- und Setter-Methoden (wie in Ruby)
  
  Beispiel
```Groovy
Person person = new Person()
person.name = "John"
person.age = 30
println person.name
//John
```
    
    
Getter und Setter können aber auch manuell überschrieben werden

Beispiel

```Groovy
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")
    }
}
```