Klasse


# Vererbungsbeziehung

Die Vererbung ist eines der grundlegenden Konzepte der Objektorientierung und hat große Bedeutung in der Softwareentwicklung. Die Vererbung dient dazu, aufbauend auf existierenden Klassen (Oberklasse) neue :t[Klassen]{#klasse} (Unterklassen) zu schaffen, wobei die Beziehung zwischen ursprünglicher und neuer Klasse dauerhaft ist. Die Vererbung dient der Dokumentation von Ähnlichkeiten zwischen Klassen, was insbesondere in den frühen Phasen des Softwareentwurfs von Bedeutung ist.

Das folgende :t[Entwurfsdiagramm] zeigt eine Vererbungssituation, bei der die Unterklasse Sportauto und SUV Erweiterungen einer Basisklasse Auto darstellen.

```mermaid
classDiagram

    SUV --|> Auto
    Sportauto --|> Auto

    class Auto {
        geschwindigkeit: Zahl
        farbe: Farbe
        anzahlTueren: Zahl
        kennzeichen: Text

        beschleunigen()
        bremsen()
        umlackieren(neueFarbe: Farbe)
        gibGeschwindigkeit(): Zahl
    }

    class SUV {
        kofferraumOffen: Wahrheitswert
        kofferraumOeffnen()
        kofferraumSchliessen()
    }

    class Sportauto {
        tiefergelegt: Wahrheitswert
        tunen()
        beschleunigen()
    }
```

## Übernehmen, ergänzen und überschreiben

Bei der Vererbung übernimmt die Unterklasse die Attribute und Methoden der Oberklasse.

Eine übernommene Methode kann dabei neu definiert (überschrieben) werden. Im Klassendiagramm ist zum Beispiel gezeigt, dass die Klasse `Sportauto` die Methode `beschleunigen` neu definiert.

Die Unterklasse kann um zusätzliche Attribute und Methoden erweitert werden. Im Klassendiagramm ist zum Beispiel gezeigt, dass die Klasse `SUV` ein neues Attribut `kofferraumOffen` besitzt.

## Spezialisierung und Generalisierung

Wenn eine neue Oberklasse definiert wird, dann sprechen wir von einer Generalisierung.

Wird hingegen eine neue Unterklasse definiert, dann sprechen wir von einer Spezialisierung.

## Überprüfe dich

1. Gegeben ist folgendes Klassendiagramm ([Link zum Mermaid-Live Editor](https://mermaid.live/edit#pako:eNqtkU1LxDAQhv9KmJNCEetK3c1N8eppD8KSy9BON4E0KcmE_Sj976Yfoix4cy55efIO7zAzQO0bAgm1xRjfDR4DdsqJXDMRr31LVgwLmuoYPMVIUhxQ21-YTqbWfIv7QCbeQhN5j4mCFJ-ogybD8USBlfuxTBHu7n4B4_fPMtIbOnT0TzP9FQkFdBQ6NE1ezhylgDV1pEBm2VCLybIC5SYrJvb7i6tBckhUQOobZFrXCbJFGzPt0YEc4Ayyqgq4gCyfq4fd9rF6Kjebl-0ui7GAq_e5pZzth1mv7dQY9uFjvdf0jF8tZody)). Modifiziere das Klassendiagramm so, dass das Konzept der Vererbung sinnvoll genutzt ist.

```mermaid
classDiagram
    class Apfel {
        groesse: Zahl
        gewicht: Zahl
        preis: Zahl
        istSauer: Wahrheitswert

        essen()
    }

    class Banane {
        groesse: Zahl
        gewicht: Zahl
        preis: Zahl
        herkunfsland: Wahrheitswert

        essen()
    }
```

:::collapsible{id="loesung1" title="Lösung"}
```mermaid
classDiagram
    Apfel --|> Frucht
    Banane --|> Frucht
    class Frucht {
        groesse: Zahl
        gewicht: Zahl
        preis: Zahl

        essen()
    }
    class Apfel {
        istSauer: Wahrheitswert
    }

    class Banane {
        herkunfsland: Text
    }
```
:::
 

2. Es existieren die Klassen Fussballer, Turnerin und Judoka. Eine neue Klasse Sportlerin wird angelegt. Handlet es sich um eine Spezialisierung oder Generalisierung?

:::collapsible{id="loesung2" title="Lösung"}
Generalisierung
:::


Vererbungsbeziehung

verbungsbeziehung


# Datentypen

In Java gibt es verschiedene Datentypen, die man Variablen zuweisen kann, um bestimmte Daten der Variablen zuzuweisen. In Java kann man zwischen primitiven Datentypen und Referenzdatentypen unterscheiden.

Wenn eine :t[Variable]{#variable} von einem primitiven Datentyp ist, dann wird der gewünschte Wert direkt der Variablen zugewiesen.

Wenn eine :t[Variable]{#variable} hingegen von einem Referenzdatentyp ist, dann wird eine Referenz, die auf ein :t[Objekt]{#objekt} vereweist, der Variablen zugewiesen. Erst über das sogenannte Dereferenizieren,
mit dem Punktoperator, können wir auf das Objekt zugreifen.

Das folgende Beispiel zeigt den Unterschied zwischen primitiven Datentypen (hier int) und Referenzdatentypen (hier String).

:::onlineide{id="623835" height=200 fileList=false}

```java
int a = 1;
String b = "Hallo";
```

:::

So können wir uns die Zuweisung zu den beiden Variablen visuell vorstellen. Während bei der Variable a direkt der gewünschte Wert steht, verweist der Wert der Variable b auf ein anderes Objekt.

![](/images/datentypen-arbeitsspeicher.png)

## Referenzdatentypen

Jede :t[Klasse]{#klasse}, die du definierst oder die schon definiert ist, stellt einen Referenzdatentypen dar. Das heißt, dass alle Variablen dieser Datentypen verweisen auf ein Objekt. In Java gibt es unter anderem die vordefinierte Klasse String.

### String

In einer Variable vom Datentyp String kann man beliebige Abfolgen von Zeichen (Buchstaben, Ziffern, Sonderzeichen) speichern. Der wörtlichen englischen Übersetzung entspricht der entsprechende deutsche Fachbegriff Zeichenkette.
Zeichenketten-Konstanten schreibt man in Gänsefüßchen, also z.B. "Das ist ein Text." oder "3, 2, 1, 0, Liftoff!".
Strings kann man mit dem Operator + hintereinanderhängen ("konkatenieren"). Der Wert des Terms "Das ist " + "praktisch." ist "Das ist praktisch". 

:::onlineide{id="105544" height=200 fileList=false}

```java Test.java
String a = "Das stört ";
String b = "keinen großen Geist.";

String c = a + b;
System.out.println(c);
```

:::


## Primitive Datentypen

Im Folgenden werden nun die alle relevanten primitiven Datentypen, die in der Programmiersprache Java zur Verfügung stehen, erklärt.

### int

Der Datentyp `int` ist zum Speichern von ganzzahligen Werten (z. B. 1, 2, -4, 20, ...).

:::onlineide{id="622663" height=200 fileList=false}

```java Int.java
int a = 1;
int b = 2;

System.out.println("Addieren: " + (a + b));
System.out.println("Multiplizieren: " + (a * b));
// Die Division bei Integern ist nur ganzzahlig möglich!
System.out.println("Dividieren: " + (a / b));
System.out.println("Subtrahieren: " + (a - b));
System.out.println("Modulo: " + (a % b));
```

:::

### float

Variablen vom Datentyp float können rationale Zahlen (ggf. näherungsweise!) speichern. Die Bezeichnung dieses Datentyps ist eine Kurzform für "floating point number", auf Deutsch "Fließkommazahl" oder "Gleitkommazahl".

Führe das folgende Beispielprogramm in Einzelschritten aus und schau' Dir dabei den Inhalt des Reiters "Variablen" auf der rechten Seite an!

:::onlineide{id="892926" height=300 fileList=false}

```java FloatTest.java
float radius = 1.5;
float umfang = 2 * 3.14159 * radius;
float flaecheninhalt = 3.14159 * radius * radius;

println("Ein Kreis mit Radius " + radius + " hat den Umfang " + umfang + " und den Flächeninhalt " + flaecheninhalt);
```

:::

### double

Variablen vom Datentyp double können - ähnlich wie float-Variablen - rationale Zahlen (näherungsweise) speichern, verwenden dazu jeweils doppelt so viel Speicherplatz (64 Bit je Wert) und sind daher doppelt genau. → Daher auch der Name ;-).

Ein double-Wert besitzt ca. 14 gültige Ziffern.

Ein einfaches Beispiel:

Ein Kapital von 1000 € wird jährlich mit 3 % verzinst. Wie viel Geld ist nach 0, 1, 2, … Jahren auf dem Konto?

:::onlineide{id="995525" height=300 fileList=false}

```java Test.java
double kapital = 1000;
double zinssatzInProzent = 3;

for (int i = 0; i < 6; i++) {
   println("Kapital nach " + i + " Jahren: " + kapital);
   kapital = kapital + kapital * zinssatzInProzent / 100;
}
```

:::

### char

In einer Variable vom Datentyp char kann man genau ein Zeichen (Buchstabe, Ziffer oder Sonderzeichen) speichern. char ist die Kurzform von character (Zeichen).
Zeichen-Konstanten schreibt man in einfachen Anführungszeichen also z.B. char c = 'T'. 

:::alert{info}
Die Methode charAt der Klasse String gibt einen Wert vom Datentyp char zurück.
:::

:::onlineide{id="490934" height=200 fileList=false}

```java Test.java
String text = "Das ist ein Text";
char zeichen = 'T';
if(text.charAt(12) == 'T') {
   println("Das 12. Zeichen des Textes ist ein T.");
}
```

:::

### boolean

Variablen vom Datentyp boolean können nur zwei verschiedene Werte speichern: true oder false. Man nennt sie auch Wahrheitswerte.

Wahrheitswerte können mit den Operatoren && (und) und || (oder) verknüft werden. Mit dem vorangestellten Operator ! (nicht) erhält man das "Gegenteil" des Wahrheitswertes. 

:::onlineide{id="810483" height=200 fileList=false}

```java Test.java
boolean b1 = 3 < 5;
System.out.println(b1);
boolean b2 = 7 > 12;
System.out.println(b2);
System.out.println(b1 || b2);
System.out.println(b1 && b2);
System.out.println(!b1);
```

:::

Datentypen

datentypen


# Weitere Klassen

Unser Spiel besteht im Moment aus zwei Klassen. Im Laufe dieser Seite wollen wir weitere Klassen implementieren und die folgende Ausgabe erreichen.

![](/images/bunny-hop/weitere-klassen/ausgabe.png)

## Aufgaben

### Klassen implementieren

Setze das folgende :t[UML-Klassendiagramm]{#klassendiagramm} im BlueJ-Projekt um. Die Klassen **Sprite** und **Stage** stammen aus der **Scratch for Java** Bibliothek. Die Klassen **Sprite** und **Stage** haben eine Vielzahl von Methoden, die den Blöcken in Scratch ähneln. Wir werden diese nach und nach kennenlernen. Im Klassendiagramm werden nur im Moment relevante dargestellt, damit es übersichtlich bleibt.

```mermaid
classDiagram
    Stage <|-- BunnyHop
    Sprite <|-- Spieler
    Sprite <|-- Feind
    Sprite <|-- Plattform
    Feind <|-- StachelFeind

    class Stage {
        Stage(width: int, height: int)
        add(sprite: Sprite)
        remove(sprite: Sprite)
        setColor(r: int, g: int, b: int)
        addBackdrop(name: String, filePath: String)
        switchBackdrop(name: String)
        nextBackdrop()
    }

    class BunnyHop {
        Spieler bugs
        StachelFeind ingo
        Plattform p1
        Plattform p2
        Plattform p3
        Plattform p4
    }

    class Sprite {
        getX(): float
        getY(): float
        setX(x: float)
        setY(y: float)
        setPosition(x: float, y: float)
        changeX(x: float)
        changeY(y: float)
        setSize(percentage: float)
        move(steps: float)
        setDirection(direction: float)
        turnLeft(amount: float)
        turnRight(amount: float)
        addCostume(name: String, filePath: String)
        switchCostume(name: String)
        nextCostume()
    }

    class Spieler {
    }

    class Plattform {
        istKaputt: boolean
    }

    class Feind {
    }

    class StachelFeind {
    }
```

:::alert{info}
Wenn du dir nicht sicher bist wie man das Klassendiagramm in Java umsetzen kann, dann orientiere dich an der Klasse Spieler oder schaue hier: :t[Vererbung in Java]{#vererbung-java}
:::

### Ausgabe nachstellen

Da wir nun alle notwendigen Klassen zur Verfügung haben, können wir jetzt die Klasse **BunnyHop** so verändern, dass sie der obigen Ausgabe entspricht.

Modifiziere die Klasse **BunnyHop** so, dass sie der obigen Ausgabe entspricht.

Setze dazu die Größe der Stage BunnyHop auf 800x400 (`super(800, 400)`) und nutze die folgenden Objektdiagramme:

::excalidraw{src="/images/bunny-hop/weitere-klassen/object-diagram.excalidraw" aspectRatio="4/3" autoZoom=true center=true}



:::collapsible{title="Tipp: Position" id="tipp-1"}
Mit den Methoden [**setX**](https://scratch4j.openpatch.org/reference/sprite/motion/setX), [**setY**](https://scratch4j.openpatch.org/reference/sprite/motion/setY), [**setPosition**](https://scratch4j.openpatch.org/reference/sprite/motion/setPosition) kannst du die Position von Objekten der Klasse Sprite verändern.
:::

:::collapsible{title="Tipp: Koordinaten" id="tipp-2"}
Falls du Hilfe bzgl. der Koordinaten brauchst, kannst du im Konstruktor der **BunnyHop**-Klasse die Methode `this.setDebug(true)` aufrufen.
:::

### Lösung

::archive[Projekt Weitere Klassen.zip]{name="bunny-hop-bugs-weitere-klassen"}


Weitere Klassen

weitere-klassen


# Erste Modellierung Klassen

Um die [Spielidee](/projekte/bunny-hop/die-spielidee) umsetzen zu können, müssen zuerst alle :t[Objekte]{#objekt} und deren :t[Attribute]{#attribut} (Eigenschaften) und :t[Methoden]{#methode} (Fähigkeiten) identifiziert und entsprechende :t[Klassen]{#klasse} in einem :t[UML-Klassendiagramm]{#klassendiagramm} modelliert werden.

Das Team hat schon begonnen :t[Klassen]{#klasse} zu modellieren.

```mermaid
classDiagram

    class Spiel {

    }

    class Spieler{
      String bildGehen1
      String bildGehen2
      int x
      int y
      ...
    }
    class StachelFeind{

    }
    class FluegelFeind {

    }
    class ProppelerFeind {

    }
    class SteinFeind {

    }
    class Plattform{

    }
```

## 🖊 Aufgaben

1. Vervollständigt das :t[Klassendiagramm]{#klassendiagramm}. Nutzt dazu die Vorlage im [Mermaid-Editor](https://mermaid.live/edit#pako:eNp9kU1vgzAMhv9K5DNCo51Ym_PUXidxq3LxiAvR8oFCkEoR_32BtqiaWH167fdx7CQDlE4ScCg1tu2nwsqjEVZYFmOusaJRpNlwK01xU-MKRX7BiuCVrdi30vJINdnsP2PzMJQN7PKc9OyRpWm6DH0aGbCsSR9IWbnMXeEOuqPqzk33WEG-vGuaaf9XUBGi-fIUjSGcnTd_t4EEDHmDSsaXnk0BoSZDAniUEv2PAGEnDrvgit6WwIPvKIGukRjo_jHAz6jbWG3QAh_gAjzPE-iBZ-95ut-95Ztsu_3Y7aMYE7g6F1uyGT_Nem4ffwEYd5ly).
2. Identifiziert Gemeinsamkeiten der Klassen. Schreibt die Gemeinsamkeiten auf.
3. 🚀: Lest den Glossareintrag zur :t[Vererbung]{#vererbung} und überlegt euch, inwiefern das Konzept der :t[Vererbung]{#vererbung} hier angewendet werden kann.


🖊 Erste Modellierung von Klassen

erste-modellierung-von-klassen


# Epic Pause

Das Spiel soll beim Drücken einer Taste pausiert werden. Beim erneuten Drücken der Taste soll das Spiel wieder aufgenommen werden.

:::collapsible{title="Hilfe: Attribut Pause" id="461068"}

Damit wir das Spiel global pausieren können, brauchen wir ein :t[Attribut]{#attribut} in der Level-Klasse und eine :t[Methode]{#methode} `istPausiert`.

Außerdem müssen wir das :t[Attribut]{#attribut} verändern, wenn die P-Taste gedrückt wird.

```java
public class Level extends Stage {
    // ...
    private boolean pause;

    // ...
    public boolean istPausiert() {
        return pause;
    }
    // ...
    public void whenKeyPressed(int pKeyCode) {
        if(pKeyCode == KeyCode.VK_P) {
            // pause umkehren;
            this.pause = !this.pause;
        }
    }
    // ...
```

:::

:::collapsible{title="Hilfe: Pause in anderen Klassen nutzen" id="392533"}

In den anderen :t[Klassen]{#klasse} wie Spieler und Plattform, müssen wir das Level bekannt machen und in der run-Methode abfragen, ob das Spiel pausiert ist. Wenn dies der Fall ist, dann beenden wir den Methodenaufruf an dieser Stelle.

```java
public void run() {
    if (level.istPausiert()) {
        return;
    }
}
```

:::

:::collapsible{title="Hilfe: Beispiel Implementierung" id="967325"}

::archive[Beispiel Implementierung]{name="bunny-hop-epic-pause"}

:::

🥈 Pause

pause


# Epic: Schneller mit der Zeit

Das Spiel soll alle paar Sekunden schneller werden.

:::collapsible{title="Hilfe: Globale Geschwindigkeit" id="570315"}

Zunächst wollen wir ein :t[Attribut]{#attribut} "geschwindigkeit" in der Level haben, welches die Geschwindigkeit des Spiels repräsentiert. Dieses :t[Attribut]{#attribut} verändern wir alle 5000 Millisekunden (5 Sekunden).

```java
public class Level extends Stage {
    private float geschwindigkeit = 1;

    // ...

    public void run() {
        if (this.getTimer().everyMillis(5000)) {
            geschwindigkeit += 0.5;
        }
    }
}
```

:::

:::collapsible{title="Hilfe: Geschwindigkeit nutzen" id="330385"}

Damit wir die Geschwindigkeit in anderen :t[Klassen]{#klasse} nutzen können, müssen zunächst einen :t[Methode]{#methode} in der Klasse Level hinzufügen.

```java
public float getGeschwindigkeit() {
    return geschwindigkeit;
}
```

Jetzt können wir die :t[Methode]{#methode} in anderen :t[Klassen]{#klasse} nutzen.

:::

:::collapsible{title="Hilfe: Beispiel Implementierung" id="967234"}

::archive[BlueJ Projekt: Schneller mit der Zeit]{name="bunny-hop-epic-schneller-mit-der-zeit"}

:::

🥉 Schneller mit der Zeit

schneller-mit-der-zeit


# Epic: Tag und Nacht

:::collapsible{title="Hilfe: Globale Eigenschaft" id="536496"}

Ob Tag ist, kannst du dir am besten als :t[Attribut]{#attribut} in deiner Level-Klasse speichern. Definiere einen :t[Getter]{#vererbung-java} und schon können alle Objekte, die die :t[Klasse]{#klasse} kennen darauf zugreifen.

```java
private boolean tag = false;

public boolean istTag() {
    return tag;
}
```

:::

:::collapsible{title="Hilfe: Tag abhängig von der Zeit" id="303419"}

Mit einem Timer können für alle paar Sekunden unterschiedliche Anweisungen ausführen.

```java
if (this.getTimer().interalMillis(6000, 4000)) {
    // 6 Sekunden ist Tag
} else {
    // 4 Sekunden ist Nacht
}
```

:::

:::collapsible{title="Hilfe: Beispiel Implementierung" id="9672143"}

::archive[Beispiel Implementierung]{name="bunny-hop-epic-tag-und-nacht"}

:::

🥉 Tag und Nacht

Setup

setup


# Wände

::youtube[title]{#nA74SVB2FV4}

## Neue Begriffe

- :t[for-Schleife]{#zaehlergesteuerte-schleife}
- :t[Klasse]{#klasse}
- :t[Vererbung]{#vererbung}

## Übungen zu den neuen Begriffen

- [Wiederholungen](/oop/wiederholungen)
- [Vererbung](/oop/vererbung)

## Scratch for Java API

- [Window](https://scratch4j.openpatch.org/de/reference/window)
    - [setDebug](https://scratch4j.openpatch.org/de/reference/window/setDebug)
- [Stage](https://scratch4j.openpatch.org/de/reference/stage)
    - [add](https://scratch4j.openpatch.org/de/reference/stage/looks/add)
- [Sprite](https://scratch4j.openpatch.org/de/reference/sprite)
    - [setX](https://scratch4j.openpatch.org/de/reference/sprite/motion/setX)
    - [setY](https://scratch4j.openpatch.org/de/reference/sprite/motion/setY)
    - [switchCostume](https://scratch4j.openpatch.org/de/reference/sprite/looks/switchCostume)
    - [setHitbox](https://scratch4j.openpatch.org/de/reference/sprite/sensing/setHitbox)


Klasse🔖

Klasse