From 9648dcad1630c48d1d67233d83aaf63b2823903c Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Mon, 4 Sep 2023 16:41:30 +0200
Subject: [PATCH 01/33] Update control-structures.md

---
 .../control-structures/control-structures.md         | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/control-structures/control-structures.md b/docs/documentation/control-structures/control-structures.md
index fc36418418..0282f3d757 100644
--- a/docs/documentation/control-structures/control-structures.md
+++ b/docs/documentation/control-structures/control-structures.md
@@ -8,5 +8,15 @@ tags: [control-structures]
 Kontrollstrukturen wie [Verzweigungen](cases.md) und [Schleifen](loops.md) sind wesentliche Bestandteile der Programmierung. Verzweigungen ermöglichen die Ausführung unterschiedlicher Anweisungsblöcke, mit Hilfe von Schleifen können Anweisungsblöcke wiederholt 
 ausgeführt werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209095715-801a859e-a9d1-4478-94c6-e51596c9da4e.png)
+```mermaid
+graph
+    a((Start)) --> b(Ausgabe: Zahl 1 eingeben)
+    b --> c(Eingabe: Zahl 1)
+    c --> d(Ausgabe: Zahl 2 eingeben)
+    d --> e(Eingabe: Zahl 2)
+    e --> f{Zahl 2 = 0}
+    f -->|Ja| e
+    f -->|Nein| h(Rückgabe: Zahl 1 : Zahl 2)
+    h --> i((Stop))
+```
 

From ff30b65c8f547bbabf8abce96d6b778c8366b0fb Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 09:36:18 +0200
Subject: [PATCH 02/33] Update activity-diagrams.md

---
 docs/documentation/uml/activity-diagrams.md | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/uml/activity-diagrams.md b/docs/documentation/uml/activity-diagrams.md
index a797ad0b4e..5dcb2cd71e 100644
--- a/docs/documentation/uml/activity-diagrams.md
+++ b/docs/documentation/uml/activity-diagrams.md
@@ -17,4 +17,20 @@ Datenknoten und Kontrollknoten) und Kanten (Kontrollflüsse und Datenflüsse) ve
 - Datenknoten sind Hilfsknoten, die als ein- oder ausgehende Parameter einer Aktion verwendet werden können
 - Kontroll- und Datenflüsse legen Abläufe zwischen Vorgänger- und Nachfolger-Knoten fest
 
-![image](https://user-images.githubusercontent.com/47243617/209096940-5f248445-9c58-45b4-adf0-3c1ef8811e92.png)
+```mermaid
+stateDiagram-v2
+    state "Eingabe: 1. Zahl" as input1
+    state "Eingabe: 2. Zahl" as input2
+    state "Ausgabe: 1. Zahl eingeben" as output1
+    state "Ausgabe: 2. Zahl eingeben" as output2
+    state "Rückgabe: 1. Zahl : 2. Zahl" as activity1
+    state if <<choice>>
+    [*] --> output1
+    output1 --> input1
+    input1 --> output2
+    output2 --> input2
+    input2 --> if
+    if --> output2 : 2. Zahl ist gleich 0
+    if --> activity1: 2. Zahl ist ungleich 0
+    activity1 --> [*]
+```

From f2468f623c0c05697ad6a58a4400b5e1b4d33448 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 09:41:37 +0200
Subject: [PATCH 03/33] Update programming.md

---
 docs/documentation/programming.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/programming.md b/docs/documentation/programming.md
index 17484edca0..1ac0aa841e 100644
--- a/docs/documentation/programming.md
+++ b/docs/documentation/programming.md
@@ -7,7 +7,10 @@ tags: [programming]
 
 Als ein Teilbereich der Softwareentwicklung umfasst das Programmieren vor allem die Umsetzung eines Softwareentwurfes in Quellcode. Generell versteht man unter Programmieren die Umsetzung von Algorithmen in lauffähige Computer-Programme.
 
-![image](https://user-images.githubusercontent.com/47243617/209094888-fa91bfac-1968-4213-916f-7ebc1c36ee02.png)
+```mermaid
+flowchart LR
+    Analyse --> Entwurf --> Umsetzung --> Auslieferung --> Wartung --> Analyse
+```
 
 :::note Hinweis
 Ein Algorithmus ist eine Handlungsvorschrift zur Lösung eines Problems.

From 023580f515e210257f91265978ac35982679b686 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 10:09:28 +0200
Subject: [PATCH 04/33] Update class-structure.md

---
 docs/documentation/class-structure.md | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/class-structure.md b/docs/documentation/class-structure.md
index 973f1d1a90..06ceb463b0 100644
--- a/docs/documentation/class-structure.md
+++ b/docs/documentation/class-structure.md
@@ -129,7 +129,17 @@ public class MainClass {
 ## Entwicklungspakete
 Entwicklungspakete ermöglichen das hierarchische Strukturieren von Klassen. Um die Klassen eines Entwicklungspaketes verwenden zu können, müssen die jeweiligen Klassen explizit mit Hilfe des Schlüsselworts `import` importiert werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209095274-3ac925e8-1636-4d92-afbe-936058a3eac0.png)
+```mermaid
+flowchart
+    pA[packageA] --> pB[packageB]
+    pA --> cA[ClassA]
+    pB --> pC[packageC]
+    pB --> cB[ClassB]
+    pB --> pD[packageD]
+    pC --> cC[ClassC]
+    pC --> cD[ClassD]
+    pD --> cE[ClassE]
+```
 
 :::note Hinweis
 Die Klassen des Entwicklungspaketes `java.lang` müssen nicht importiert werden.

From 7b2a197980a58feccaa6106d90aaf1a37e165d63 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 11:20:13 +0200
Subject: [PATCH 05/33] Update data-objects.md

---
 docs/documentation/data-objects.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/data-objects.md b/docs/documentation/data-objects.md
index 0cb360c112..247b04ac73 100644
--- a/docs/documentation/data-objects.md
+++ b/docs/documentation/data-objects.md
@@ -9,7 +9,12 @@ Ein Datenobjekt ist ein Platzhalter, der zur Laufzeit eine bestimmte Stelle des
 ermöglichen das Ansprechen im Programmablauf. Man unterscheidet zwischen variablen Datenobjekten (_Variablen_) und fixen Datenobjekten (_Konstanten_ und _Literale_). Konstanten sind fixe Datenobjekte, die über einen Bezeichner angesprochen werden können. Sie werden 
 mit dem Schlüsselwort `final` deklariert. Literale sind sogenannte wörtliche Konstanten, d.h. fixe Datenobjekte ohne Bezeichner. Da Literale über keinen Bezeichner verfügen, können Sie im Programm nicht angesprochen werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209095425-92e2425a-e9f8-4051-a1dc-c0130f8f88d6.png)
+```mermaid
+flowchart
+    hans(Bezeichner: hans\nDatentyp: String\nWert: Hans)
+    i(Bezeichner: i\nDatentyp: int\nWert: 5)
+    isAvailable(Bezeichner: isAvailable\nDatentyp: boolean\nWert: true)
+```
 
 ## Deklaration von Datenobjekten
 Durch Angabe von Datentyp und Bezeichner wird ein Datenobjekt deklariert, d.h. dem Compiler bekannt gegeben. Deklarationen werden wie jede Anweisung mit einem Semikolon abgeschlossen. Datenobjekte gleichen Datentyps können mit Komma getrennt aufgeführt werden.

From 05a2e00d1ccc83bb1c3cbc17470a38b5e0118567 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 11:23:25 +0200
Subject: [PATCH 06/33] Update control-structures.md

---
 .../control-structures/control-structures.md  | 24 ++++++++++++-------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/docs/documentation/control-structures/control-structures.md b/docs/documentation/control-structures/control-structures.md
index 0282f3d757..7cd50092b9 100644
--- a/docs/documentation/control-structures/control-structures.md
+++ b/docs/documentation/control-structures/control-structures.md
@@ -9,14 +9,20 @@ Kontrollstrukturen wie [Verzweigungen](cases.md) und [Schleifen](loops.md) sind
 ausgeführt werden.
 
 ```mermaid
-graph
-    a((Start)) --> b(Ausgabe: Zahl 1 eingeben)
-    b --> c(Eingabe: Zahl 1)
-    c --> d(Ausgabe: Zahl 2 eingeben)
-    d --> e(Eingabe: Zahl 2)
-    e --> f{Zahl 2 = 0}
-    f -->|Ja| e
-    f -->|Nein| h(Rückgabe: Zahl 1 : Zahl 2)
-    h --> i((Stop))
+stateDiagram-v2
+    state "Eingabe: 1. Zahl" as input1
+    state "Eingabe: 2. Zahl" as input2
+    state "Ausgabe: 1. Zahl eingeben" as output1
+    state "Ausgabe: 2. Zahl eingeben" as output2
+    state "Rückgabe: 1. Zahl : 2. Zahl" as activity1
+    state if <<choice>>
+    [*] --> output1
+    output1 --> input1
+    input1 --> output2
+    output2 --> input2
+    input2 --> if
+    if --> output2 : 2. Zahl ist gleich 0
+    if --> activity1: 2. Zahl ist ungleich 0
+    activity1 --> [*]
 ```
 

From 5c967d6e1cf4259d31187a2a14c3b7f003b9673e Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 11:34:04 +0200
Subject: [PATCH 07/33] Update arrays.md

---
 docs/documentation/arrays.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/docs/documentation/arrays.md b/docs/documentation/arrays.md
index 08c58185e1..3a9ff59b28 100644
--- a/docs/documentation/arrays.md
+++ b/docs/documentation/arrays.md
@@ -8,7 +8,10 @@ tags: [arrays]
 Wenn eine große Menge an Daten verarbeitet werden soll, kann man auf spezielle Datenstruktur-Variablen, sogenannte _Felder_ (Arrays), zurückgreifen. Die einzelnen Speicherplätze in einem Feld werden als Elemente bezeichnet, die über einen Index angesprochen 
 werden können.
 
-![image](https://user-images.githubusercontent.com/47243617/209096157-f67edf3e-3e24-46f8-a241-a1fb37c9a6d1.png)
+```mermaid
+flowchart LR
+    a[Index: 0\nWert: Hans] -.- b[Index: 1\nWert: Peter] -.- c[Index: 2\nWert: Lisa]
+``` 
 
 ## Erzeugen von Feldern
 Da es sich bei Feldern um Objekte handelt, müssen diese vor Verwendung erzeugt werden. Bei der Erzeugung muss immer die Länge des Feldes (d.h. die Anzahl der Elemente) angegeben werden. Jedes Feld verfügt über das Attribut `length`, welches die Länge des Feldes 
@@ -97,5 +100,3 @@ Das Arbeiten mit Feldern stellt einige Herausforderungen bereit:
 - Die Länge eines Feldes muss bereits bei der Initialisierung des Feldes angegeben werden und kann nicht mehr verändert werden
 - Beim Hinzufügen eines Elements in ein volles Feld müssen alle Elemente des Feldes in ein neues, größeres Feld kopiert werden
 - Beim Einfügen oder Löschen eines Elements müssen alle nachfolgenden Elemente verschoben werden
-
-![image](https://user-images.githubusercontent.com/47243617/209095940-fc615434-5ba6-4001-a356-6cd690e191f1.png)

From 84f896850ae0f2931e8800c226be19894b17f956 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 11:40:14 +0200
Subject: [PATCH 08/33] Update arrays.md

---
 docs/documentation/arrays.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/docs/documentation/arrays.md b/docs/documentation/arrays.md
index 3a9ff59b28..acb30b900f 100644
--- a/docs/documentation/arrays.md
+++ b/docs/documentation/arrays.md
@@ -9,8 +9,10 @@ Wenn eine große Menge an Daten verarbeitet werden soll, kann man auf spezielle
 werden können.
 
 ```mermaid
-flowchart LR
-    a[Index: 0\nWert: Hans] -.- b[Index: 1\nWert: Peter] -.- c[Index: 2\nWert: Lisa]
+flowchart
+    subgraph names
+        a[Index: 0\nWert: Hans] -.- b[Index: 1\nWert: Peter] -.- c[Index: 2\nWert: Lisa]
+    end
 ``` 
 
 ## Erzeugen von Feldern

From 97250b8c94c34f148c1d8658aff65190bc65d336 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 14:30:34 +0200
Subject: [PATCH 09/33] Update oo.md

---
 docs/documentation/oo.md | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/docs/documentation/oo.md b/docs/documentation/oo.md
index b297dbcbcb..7be1dd86d1 100644
--- a/docs/documentation/oo.md
+++ b/docs/documentation/oo.md
@@ -11,7 +11,12 @@ aus der realen Welt zum Konzept der Objektorientierung zusammengefasst:
 - Konkrete Ausprägungen bzw. Instanzen einer Klasse werden wiederum als _Objekte_ bezeichnet
 - Die Eigenschaften von Objekten werden als _Attribute_ das Verhalten als _Methoden_ bezeichnet
 
-![image](https://user-images.githubusercontent.com/47243617/209096416-7128eebe-e05b-42a5-a8ae-3ab898aae81b.png)
+```mermaid
+flowchart LR
+    rectangle1(Bezeichner: rectangle1\nDatentyp: Shape\nWert: 13fee20c) --> o1[hashCode: 13fee20c\nareaInCM2: 12]
+    rectangle2(Bezeichner: rectangle2\nDatentyp: Shape\nWert: 88d45a01) --> o2[hashCode: 88d45a01\nareaInCM2: 12]
+    trapezoid(Bezeichner: trapezoid\nDatentyp: Shape\nWert: 915a002f) --> o3[/hashCode: 915a002f\nareaInCM2: 12\]
+```
 
 :::note Hinweis
 Jedes Objekt ist eindeutig identifizierbar.
@@ -21,8 +26,6 @@ Jedes Objekt ist eindeutig identifizierbar.
 Ein wesentlicher Grundsatz der Objektorientierung ist, dass Attribute durch Methoden gekapselt werden. Datenkapselung bedeutet, dass Attribute nicht direkt geändert werden können, sondern nur durch den indirekten Zugriff über Methoden. Typische Methoden zum 
 Lesen und Schreiben von Attributen sind die sogenannten Getter bzw. Setter.
 
-![image](https://user-images.githubusercontent.com/47243617/209096468-16f7888c-0635-4551-8532-b29050dc22e0.png)
-
 ## Sichtbarkeit von Attributen und Methoden
 Um die Sichtbarkeit von Attributen und Methoden zu definieren, existieren verschiedene Zugriffsrechte. Die Sichtbarkeit bestimmt, von welchem Ort aus Attribute und Methoden verwendet bzw. aufgerufen werden dürfen.
 
@@ -86,7 +89,12 @@ Technisch gesehen handelt es sich bei einer Klasse um einen komplexen Datentyp.
 
 Im Gegensatz zu "normalen" Variablen werden bei Referenzvariablen nicht die eigentlichen Werte in den Variablen gespeichert, sondern die Speicheradressen der erzeugten Objekte. Die Selbstreferenz `this` verweist innerhalb einer Klasse auf das eigene Objekt.
 
-![image](https://user-images.githubusercontent.com/47243617/209096553-525afb86-d2c8-4323-874f-766f62c12a1b.png)
+```mermaid
+flowchart LR
+    rectangle1(Bezeichner: rectangle1\nDatentyp: Shape\nWert: 13fee20c) --> o1[hashCode: 13fee20c\nareaInCM2: 12]
+    rectangle2(Bezeichner: rectangle2\nDatentyp: Shape\nWert: 13fee20c) --> o1[hashCode: 13fee20c\nareaInCM2: 12]
+    trapezoid(Bezeichner: trapezoid\nDatentyp: Shape\nWert: 915a002f) --> o3[/hashCode: 915a002f\nareaInCM2: 10\]
+```
 
 :::note Hinweis
 Der Standarwert von Referenzvariablen ist `null`.

From 5228d16b34d42fdc11907cda6034bed5646c2461 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Wed, 6 Sep 2023 17:32:00 +0200
Subject: [PATCH 10/33] Update oo.md

---
 docs/documentation/oo.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/docs/documentation/oo.md b/docs/documentation/oo.md
index 7be1dd86d1..1c4ac46089 100644
--- a/docs/documentation/oo.md
+++ b/docs/documentation/oo.md
@@ -26,6 +26,20 @@ Jedes Objekt ist eindeutig identifizierbar.
 Ein wesentlicher Grundsatz der Objektorientierung ist, dass Attribute durch Methoden gekapselt werden. Datenkapselung bedeutet, dass Attribute nicht direkt geändert werden können, sondern nur durch den indirekten Zugriff über Methoden. Typische Methoden zum 
 Lesen und Schreiben von Attributen sind die sogenannten Getter bzw. Setter.
 
+```mermaid
+flowchart LR
+    write[Schreibender Zugriff] --> setter1
+    read[Lesender Zugriff] --> getter2
+    subgraph Klasse
+        attribut1[Attribut 1]
+        attribut2[Attribut 2]
+        setter1[Setter für Attribut 1] -.- attribut1
+        getter1[Getter für Attribut 1] -.- attribut1
+        setter2[Setter für Attribut 2] -.- attribut2
+        getter2[Getter für Attribut 2] -.- attribut2
+    end
+```
+
 ## Sichtbarkeit von Attributen und Methoden
 Um die Sichtbarkeit von Attributen und Methoden zu definieren, existieren verschiedene Zugriffsrechte. Die Sichtbarkeit bestimmt, von welchem Ort aus Attribute und Methoden verwendet bzw. aufgerufen werden dürfen.
 

From b87670bfd60f051cac9fb5088316c225edd57fd1 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Thu, 7 Sep 2023 11:12:54 +0200
Subject: [PATCH 11/33] Update files.md

---
 docs/documentation/java-api/files.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/java-api/files.md b/docs/documentation/java-api/files.md
index 2fa6753e0e..0d74016a17 100644
--- a/docs/documentation/java-api/files.md
+++ b/docs/documentation/java-api/files.md
@@ -37,7 +37,15 @@ Nach der letzten Verwendung sollte die Methode `void close()` der Klasse `Scanne
 Beim Zugriff auf Verzeichnisse bzw. Dateien unterscheidet man zwischen absoluten und relativen Pfadangaben. Bei absoluten Pfadangaben wird der vollständige Pfad von der Wurzel des jeweiligen Verzeichnissystems bis zum Ziel angegeben, bei relativen der Weg von 
 einem festgelegten Bezugspunkt bis zum Ziel.
 
-![image](https://user-images.githubusercontent.com/47243617/209096722-dce8f11a-851b-4535-af37-0b987929c2e3.png)
+```mermaid
+flowchart LR
+    c[c:] --> workspace
+    c --> temp[Temp]
+    workspace[workspace] --> project
+    temp --> documentA[documentA.txt]
+    project[Project] --> documents        
+    documents[documents] --> documentB[documentB.txt]
+```
 
 :::note Hinweis
 Alle Klassen im Paket `java.io` verwenden als Bezugspunkt das Arbeitsverzeichnis des Benutzers (Systemeigenschaft `user.dir`).

From 3a991cc2c44095c8919c746588fdbdd2bc84b40e Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Thu, 7 Sep 2023 11:20:21 +0200
Subject: [PATCH 12/33] Update files.md

---
 docs/documentation/java-api/files.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/java-api/files.md b/docs/documentation/java-api/files.md
index 0d74016a17..81d8cf3c23 100644
--- a/docs/documentation/java-api/files.md
+++ b/docs/documentation/java-api/files.md
@@ -39,7 +39,7 @@ einem festgelegten Bezugspunkt bis zum Ziel.
 
 ```mermaid
 flowchart LR
-    c[c:] --> workspace
+    c[C:] --> workspace
     c --> temp[Temp]
     workspace[workspace] --> project
     temp --> documentA[documentA.txt]
@@ -47,6 +47,12 @@ flowchart LR
     documents[documents] --> documentB[documentB.txt]
 ```
 
+Pfadangaben:
+- Absolute Pfadangabe für documentA.txt: `C:\Temp\documentA.txt`
+- Absolute Pfadangabe für documentB.txt: `C:\workspace\Project\documents\documentB.txt`
+- Relative Pfadangabe für documentA.txt: `documents/documentA.txt`
+- Relative Pfadangabe für documentB.txt: `../../Temp/documentA.txt`
+
 :::note Hinweis
 Alle Klassen im Paket `java.io` verwenden als Bezugspunkt das Arbeitsverzeichnis des Benutzers (Systemeigenschaft `user.dir`).
 :::

From 281eacb1494006503bdb9b7cc29ab9bc4b6e7168 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 08:40:34 +0200
Subject: [PATCH 13/33] Update class-structure.md

---
 docs/documentation/class-structure.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/documentation/class-structure.md b/docs/documentation/class-structure.md
index 06ceb463b0..682bd5914f 100644
--- a/docs/documentation/class-structure.md
+++ b/docs/documentation/class-structure.md
@@ -131,11 +131,11 @@ Entwicklungspakete ermöglichen das hierarchische Strukturieren von Klassen. Um
 
 ```mermaid
 flowchart
-    pA[packageA] --> pB[packageB]
+    pA(packageA) --> pB(packageB)
     pA --> cA[ClassA]
-    pB --> pC[packageC]
+    pB --> pC(packageC)
     pB --> cB[ClassB]
-    pB --> pD[packageD]
+    pB --> pD(packageD)
     pC --> cC[ClassC]
     pC --> cD[ClassD]
     pD --> cE[ClassE]

From 8b7af78509749d8acd458a60cde35253026e5247 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 08:41:11 +0200
Subject: [PATCH 14/33] Update programming.md

---
 docs/documentation/programming.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/documentation/programming.md b/docs/documentation/programming.md
index 1ac0aa841e..68b75264de 100644
--- a/docs/documentation/programming.md
+++ b/docs/documentation/programming.md
@@ -20,7 +20,7 @@ Ein Algorithmus ist eine Handlungsvorschrift zur Lösung eines Problems.
 Unter einem Programmierparadigma versteht man die grundlegende Herangehensweise, Probleme mit Hilfe einer Programmiersprache zu lösen:
 
 :::note Hinweis
-Auch wenn Programmiersprachen oft anhand ihrer grundlegenden Merkmale genau einem Programmierparadigma zugeordnet werden, unterstützen viele Programmiersprachen mehrerer Programmierparadigmen.
+Auch wenn Programmiersprachen oft anhand ihrer grundlegenden Merkmale genau einem Programmierparadigma zugeordnet werden, unterstützen viele Programmiersprachen mehrere Programmierparadigmen.
 :::
 
 ### Imperative Programmierung

From ecf068458b129638da1458af7c191551684d3231 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 08:44:16 +0200
Subject: [PATCH 15/33] Update data-objects.md

---
 docs/documentation/data-objects.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/data-objects.md b/docs/documentation/data-objects.md
index 247b04ac73..2833dfc4b4 100644
--- a/docs/documentation/data-objects.md
+++ b/docs/documentation/data-objects.md
@@ -124,7 +124,15 @@ public class MainClass {
 
 Die Wertigkeit von Datentypen entscheidet darüber, welche Typumwandlungen möglich sind.
 
-![image](https://user-images.githubusercontent.com/47243617/209095514-5f22cd05-584d-4091-b70f-17975eabb7eb.png)
+```mermaid
+flowchart
+    byte(byte) -.-> short(short)
+    short -.-> int(int)
+    char(char) -.-> int
+    int -.-> long(long)
+    long -.-> float(float)
+    float -.-> double(double)
+```
 
 :::note Hinweis
 Für den Datentyp `boolean` ist keine Typumwandlung möglich.

From f6562ba1ebed7cc03d23a1b476961a96858c8207 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 08:47:54 +0200
Subject: [PATCH 16/33] Update strings.md

---
 docs/documentation/strings.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/docs/documentation/strings.md b/docs/documentation/strings.md
index 917f346642..01d2c60d51 100644
--- a/docs/documentation/strings.md
+++ b/docs/documentation/strings.md
@@ -8,6 +8,17 @@ tags: []
 Ketten von beliebigen Zeichen werden durch die Klasse `String` realisiert. Diese stellt einige hilfreiche Methoden zur Verfügung, die bei der Analyse und der Verarbeitung von Zeichenketten Verwendung finden. Die Angabe einer Zeichenkette erfolgt über die 
 Anführungszeichen.
 
+```mermaid
+flowchart
+    subgraph text
+        a[Index: 0\nWert: W] -.- b[Index: 1\nWert: i]
+        b -.- c[Index: 2\nWert: n]
+        c -.- d[Index: 3\nWert: t]
+        d -.- e[Index: 4\nWert: e]
+        e -.- f[Index: 5\nWert: r]
+    end
+```
+
 ```java title="MainClass.java" showLineNumbers
 public class MainClass {
 

From ef49e646b82581a1024eec3c236d5ed5eab85994 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 09:58:26 +0200
Subject: [PATCH 17/33] Update console-applications.md

---
 docs/documentation/console-applications.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/docs/documentation/console-applications.md b/docs/documentation/console-applications.md
index 0236c9289c..ab0a1e5c93 100644
--- a/docs/documentation/console-applications.md
+++ b/docs/documentation/console-applications.md
@@ -7,6 +7,12 @@ tags: [console-applications]
 
 Konsolenanwendungen sind Programme ohne eine grafische Benutzeroberfläche d.h. die Steuerung sowie die Eingabe und Ausgabe erfolgen ausschließlich über textuelle Anweisungen.
 
+```mermaid
+flowchart
+    konsole[Konsole] -.->|System.in| klasse[Klasse]
+    klasse -.->|System.out| konsole
+```
+
 ## Konsoleneingaben
 Die Klasse `Scanner` im Paket `java.util` stellt Methoden zur Verfügung, um Eingaben von der Konsole einzulesen und in entsprechende Datentypen umzuwandeln.
 

From 8abc20b4cf5d9920780ce5b76cc528b2057d8c75 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 09:59:27 +0200
Subject: [PATCH 18/33] Update control-structures.md

---
 .../control-structures/control-structures.md   | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/docs/documentation/control-structures/control-structures.md b/docs/documentation/control-structures/control-structures.md
index 7cd50092b9..4a9d647781 100644
--- a/docs/documentation/control-structures/control-structures.md
+++ b/docs/documentation/control-structures/control-structures.md
@@ -8,21 +8,3 @@ tags: [control-structures]
 Kontrollstrukturen wie [Verzweigungen](cases.md) und [Schleifen](loops.md) sind wesentliche Bestandteile der Programmierung. Verzweigungen ermöglichen die Ausführung unterschiedlicher Anweisungsblöcke, mit Hilfe von Schleifen können Anweisungsblöcke wiederholt 
 ausgeführt werden.
 
-```mermaid
-stateDiagram-v2
-    state "Eingabe: 1. Zahl" as input1
-    state "Eingabe: 2. Zahl" as input2
-    state "Ausgabe: 1. Zahl eingeben" as output1
-    state "Ausgabe: 2. Zahl eingeben" as output2
-    state "Rückgabe: 1. Zahl : 2. Zahl" as activity1
-    state if <<choice>>
-    [*] --> output1
-    output1 --> input1
-    input1 --> output2
-    output2 --> input2
-    input2 --> if
-    if --> output2 : 2. Zahl ist gleich 0
-    if --> activity1: 2. Zahl ist ungleich 0
-    activity1 --> [*]
-```
-

From 0d8fec6d57a658ac27f1a684ad6a662a6e7ab9a7 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 12:01:08 +0200
Subject: [PATCH 19/33] Update arrays.md

---
 docs/documentation/arrays.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/arrays.md b/docs/documentation/arrays.md
index acb30b900f..cdb429796f 100644
--- a/docs/documentation/arrays.md
+++ b/docs/documentation/arrays.md
@@ -11,7 +11,10 @@ werden können.
 ```mermaid
 flowchart
     subgraph names
-        a[Index: 0\nWert: Hans] -.- b[Index: 1\nWert: Peter] -.- c[Index: 2\nWert: Lisa]
+        a[Index: 0\nWert: Hans] -.- b[Index: 1\nWert: Peter]
+        b -.- c[Index: 2\nWert: Lisa]
+        c -.- d[Index: 3\nWert: Max]
+        d -.- e[Index: 4\nWert: Heidi]
     end
 ``` 
 

From 5ef4f79f4f44868ad77cadcf4c6a181702a4f802 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 12:06:20 +0200
Subject: [PATCH 20/33] Update oo.md

---
 docs/documentation/oo.md | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/docs/documentation/oo.md b/docs/documentation/oo.md
index 1c4ac46089..4fb3a355ca 100644
--- a/docs/documentation/oo.md
+++ b/docs/documentation/oo.md
@@ -28,15 +28,17 @@ Lesen und Schreiben von Attributen sind die sogenannten Getter bzw. Setter.
 
 ```mermaid
 flowchart LR
-    write[Schreibender Zugriff] --> setter1
-    read[Lesender Zugriff] --> getter2
+    write[Schreibender Zugriff] -.-> setter1
+    write -.-> setter2
+    getter1 -.-> read[Lesender Zugriff]
+    getter2 -.-> read
     subgraph Klasse
-        attribut1[Attribut 1]
-        attribut2[Attribut 2]
-        setter1[Setter für Attribut 1] -.- attribut1
-        getter1[Getter für Attribut 1] -.- attribut1
-        setter2[Setter für Attribut 2] -.- attribut2
-        getter2[Getter für Attribut 2] -.- attribut2
+        attribut1((Attribut 1))
+        attribut2((Attribut 2))
+        setter1(Setter für Attribut 1) -.-> attribut1
+        attribut1 -.-> getter1(Getter für Attribut 1)
+        setter2(Setter für Attribut 2) -.-> attribut2
+        attribut2 -.-> getter2(Getter für Attribut 2)
     end
 ```
 

From 0e4ca08fc52babce2ce7911825eee10cd15253a6 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Tue, 12 Sep 2023 12:17:04 +0200
Subject: [PATCH 21/33] Update files.md

---
 docs/documentation/java-api/files.md | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/docs/documentation/java-api/files.md b/docs/documentation/java-api/files.md
index 81d8cf3c23..e3ea1a2bb5 100644
--- a/docs/documentation/java-api/files.md
+++ b/docs/documentation/java-api/files.md
@@ -37,22 +37,18 @@ Nach der letzten Verwendung sollte die Methode `void close()` der Klasse `Scanne
 Beim Zugriff auf Verzeichnisse bzw. Dateien unterscheidet man zwischen absoluten und relativen Pfadangaben. Bei absoluten Pfadangaben wird der vollständige Pfad von der Wurzel des jeweiligen Verzeichnissystems bis zum Ziel angegeben, bei relativen der Weg von 
 einem festgelegten Bezugspunkt bis zum Ziel.
 
+:::note Hinweis
+Alle Klassen im Paket `java.io` verwenden als Bezugspunkt das Arbeitsverzeichnis des Benutzers (Systemeigenschaft `user.dir`).
+:::
+
 ```mermaid
 flowchart LR
     c[C:] --> workspace
     c --> temp[Temp]
     workspace[workspace] --> project
-    temp --> documentA[documentA.txt]
+    temp --> documentA[/DocumentA.txt/]
     project[Project] --> documents        
-    documents[documents] --> documentB[documentB.txt]
+    documents[documents] --> documentB[/DocumentB.txt/]
 ```
 
-Pfadangaben:
-- Absolute Pfadangabe für documentA.txt: `C:\Temp\documentA.txt`
-- Absolute Pfadangabe für documentB.txt: `C:\workspace\Project\documents\documentB.txt`
-- Relative Pfadangabe für documentA.txt: `documents/documentA.txt`
-- Relative Pfadangabe für documentB.txt: `../../Temp/documentA.txt`
-
-:::note Hinweis
-Alle Klassen im Paket `java.io` verwenden als Bezugspunkt das Arbeitsverzeichnis des Benutzers (Systemeigenschaft `user.dir`).
-:::
+Die Datei `DocumentA.txt` kann entweder über den absoluten Pfad `C:\Temp\DocumentA.txt` oder über den relativen Pfad `documents/DocumentA.txt` (Bezugspunkt ist das Verzeichnis `Project`); die Datei `DocumentB.txt` über den absoluten Pfad `C:\workspace\Project\documents\documentB.txt` oder über den relativen Pfad `../../Temp/documentA.txt` angesprochen werden.

From 44e005aa4d2f613726978c49c86f1b0ea2e26727 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Thu, 14 Sep 2023 14:51:20 +0200
Subject: [PATCH 22/33] Update interfaces.md

---
 docs/documentation/interfaces.md | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/interfaces.md b/docs/documentation/interfaces.md
index 9b8a7ec303..980b2fb99c 100644
--- a/docs/documentation/interfaces.md
+++ b/docs/documentation/interfaces.md
@@ -9,7 +9,29 @@ Wird eine Klasse von mehreren Klassen abgeleitet, spricht man von Mehrfachvererb
 über mehrere mögliche Pfade von einer Basisklasse und werden dabei möglicherweise Methoden der Basisklasse unterschiedlich überschrieben, entstehen dadurch nicht eindeutige Varianten. Aufgrund der Rautenform des Klassendiagramms wird dieses Szenario also 
 _Diamantenproblem_ bezeichnet.
 
-![image](https://user-images.githubusercontent.com/47243617/209167564-63ff5ecb-e41b-4a5c-9ae4-7edf43027afe.png)
+```mermaid
+classDiagram 
+    ClassA <|-- ClassB
+    ClassA <|-- ClassC
+    ClassB <|-- ClassD
+    ClassC <|-- ClassD
+
+    class ClassA {
+        +foo() void
+    }
+
+    class ClassB {
+        +foo() void
+    }
+
+    class ClassC {
+        +foo() void
+    }
+
+    class ClassD {
+
+    }
+```
 
 Zur Lösung des Diamantenproblems werden Schnittstellen (Interfaces) verwendet. Schnittstellen sind im Prinzip abstrakte Klassen, die ausschließlich abstrakte Methoden besitzen. Durch Schnittstellen wird sichergestellt, dass Klassen bestimmte Methoden 
 bereitstellen und dass verschiedene Klassen miteinander kommunizieren können.

From c356fb33a7b8af1e2d67d2c9033b2456825b04e5 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Thu, 14 Sep 2023 14:54:42 +0200
Subject: [PATCH 23/33] Update exceptions.md

---
 docs/documentation/exceptions.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/exceptions.md b/docs/documentation/exceptions.md
index 1117659254..c8607a391c 100644
--- a/docs/documentation/exceptions.md
+++ b/docs/documentation/exceptions.md
@@ -25,7 +25,15 @@ Ausnahmen können behandelt bzw. weitergeleitet werden.
 Die Klasse `Throwable` stellt die Oberklasse aller Laufzeitfehler dar. Schwerwiegende Fehler (hauptsächlich Probleme in der JVM (Java Virtual Machine)) werden durch Unterklassen der Klasse `Error` abgebildet, geprüfte Ausnahmen durch Unterklassen der Klasse 
 `Exception` und ungeprüfte Ausnahmen durch Unterklassen der Klasse `RuntimeException`.
 
-![image](https://user-images.githubusercontent.com/47243617/209166560-5868fcf0-da45-4f87-8527-bee975da35c1.png)
+```mermaid
+classDiagram 
+    Throwable <|-- Error
+    Throwable <|-- Exception
+    Exception <|-- TimeOutException
+    Exception <|-- RunTimeException
+    RunTimeException <|-- NullPointerException
+    RunTimeException <|-- ArithmeticException
+```
 
 ### Definition von Ausnahmenklassen
 Eigene Ausnahmenklassen werden durch einfaches Ableiten von einer bestehenden Ausnahmenklasse definiert. Ausnahmenklassen sollten dabei immer von der Klasse `Exception` oder einer ihrer Unterklassen abgeleitet werden, nicht von der Klasse `Error`.

From d9b67e7d745a2b8a134bed700994cba329610366 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Thu, 14 Sep 2023 15:07:09 +0200
Subject: [PATCH 24/33] Update maps.md

---
 docs/documentation/maps.md | 32 +++++++++++++++++++++++++-------
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/docs/documentation/maps.md b/docs/documentation/maps.md
index ccf497a107..52c7e49bf3 100644
--- a/docs/documentation/maps.md
+++ b/docs/documentation/maps.md
@@ -8,7 +8,16 @@ tags: [maps]
 Unter einem Assoziativspeicher (Map) versteht man eine Menge zusammengehöriger Paare von Objekten. Das erste Objekt stellt dabei den Schlüssel (Key), das zweite Objekt den Wert (Value) dar. Jeder Schlüssel kann dabei nur einmal in einem Assoziativspeicher 
 vorhanden sein. Aufgrund dieses Aufbaus werden Assoziativspeicher auch als Wörterbücher bezeichnet.
 
-![image](https://user-images.githubusercontent.com/47243617/209135548-62e0e10e-1f7f-4fd7-99cb-1a4d9a15a9de.png)
+```mermaid
+flowchart LR
+    subgraph Noten
+        direction LR
+        hans(Hans) -.-> g1((2.3))
+        peter(Peter) -.-> g2((1.7))
+        lisa(Lisa) -.-> g3((1.8))
+        max(Max) -.-> g4((4.2))
+    end
+```
 
 Um auf die Einträge, Schlüssel und Werte eines Assoziativspeichers zugreifen können, stellt die Schnittstelle `Map` die Methoden `Set<Entry<K, V>> entrySet()`, `Set<K> keySet()` und `Collection<V> values()` zur Verfügung. 
 
@@ -45,15 +54,24 @@ gemäß den entsprechenden Dokumentationskommentaren überschrieben hat. Im Gege
 
 | Index | Schlüssel | Wert |
 | ----- | --------- | ---- |
-| 0     | Butter    | 3    |
-| 2     | Brot      | 9    |
-| 13    | Milch     | 2    |
-| 14    | Eier      | 5    |
-
+| 0     | Hans      | 2.3  |
+| 2     | Peter     | 1.7  |
+| 13    | Lisa      | 1.8  |
+| 14    | Max       | 4.2  |
 
 Die Klasse `TreeMap<K, V>` implementiert den Assoziativspeicher in Form eines Binärbaumes. Als Datenstruktur wird dabei ein balancierter Baum verwendet, d.h. spezielle Einfüge- und Löschoperationen stellen sicher, dass der Baum nicht zu einer linearen Liste 
 entartet. Da die Paare in einem Binärbaum sortiert vorliegen, ist es für den Einsatz zwingend erforderlich, dass die Klasse, die den Schlüssel bildet, die Schnittstelle `Comparable<T>` implementiert hat. Alternativ kann dem Konstruktor der Klasse `TreeMap<K, V>`
 ein Komparator für den Schlüssel mitgegeben werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209135608-ee2b5bb7-6abc-4cc0-8e6f-cf4c1ad723a2.png)
+```mermaid
+flowchart TD
+    max --> lisa
+    lisa --> hans
+    max --> peter
+
+    hans(Hans) -.-> g1((2.3))
+    peter(Peter) -.-> g2((1.7))
+    lisa(Lisa) -.-> g3((1.8))
+    max(Max) -.-> g4((4.2))
+```
 

From 9ef9f053fa1bd10d02721c3f8e4014989e6afcef Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Thu, 14 Sep 2023 15:19:42 +0200
Subject: [PATCH 25/33] Update java-stream-api.md

---
 docs/documentation/java-stream-api.md | 32 ++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/java-stream-api.md b/docs/documentation/java-stream-api.md
index ffa0397e16..4960af8623 100644
--- a/docs/documentation/java-stream-api.md
+++ b/docs/documentation/java-stream-api.md
@@ -9,7 +9,37 @@ Die Java Stream API stellt Klassen zum Erzeugen von und Arbeiten mit Strömen (S
 ermöglicht. Die Daten, die durch die Elemente des Stromes repräsentiert werden, werden dabei durch den Strom selbst nicht verändert. Die Verarbeitung der Elemente erfolgt nach dem Prinzip der Bedarfsauswertung (Lazy Evaluation). Neben endlichen Strömen stellt 
 die Java Stream API auch Methoden zum Erzeugen unendlicher Ströme bereit.
 
-![image](https://user-images.githubusercontent.com/47243617/209135855-a190fe54-8d3a-46e8-82d8-2589da9158a6.png)
+```mermaid
+flowchart TD
+    Original --> Filtern
+    Filtern --> Abbilden
+    Abbilden --> Sortieren
+
+    subgraph Original
+        hans[Hans, 18, m]
+        peter[Peter, 27, m]
+        lisa[Lisa, 43, w]
+        max[Max, 19, d]
+        heidi[Heidi, 19, w]
+        philipp[Philipp, 22, m]
+        maria[Maria, 17, w]
+    end
+    subgraph Filtern
+        peter2[Peter, 27, m]
+        heidi2[Heidi, 19, w]
+        maria2[Maria, 17, w]
+    end
+    subgraph Abbilden
+        peter3[PETER]
+        heidi3[HEIDI]
+        maria3[MARIA]
+    end
+    subgraph Sortieren
+        heidi4[HEIDI]
+        maria4[MARIA]
+        peter4[PETER]
+    end
+```
 
 :::note Hinweis
 Ströme (Paket `java.util.stream`) haben nichts mit [Datenströmen (IO-Streams)](io-streams.md) (Paket `java.io`) zu tun.

From 5e0e1d1b89229d3dda36f4d2e3bfae70b3d2400d Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Fri, 15 Sep 2023 08:46:04 +0200
Subject: [PATCH 26/33] Update class-structure.md

---
 docs/documentation/class-structure.md | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/docs/documentation/class-structure.md b/docs/documentation/class-structure.md
index 682bd5914f..732d07d63e 100644
--- a/docs/documentation/class-structure.md
+++ b/docs/documentation/class-structure.md
@@ -131,14 +131,15 @@ Entwicklungspakete ermöglichen das hierarchische Strukturieren von Klassen. Um
 
 ```mermaid
 flowchart
-    pA(packageA) --> pB(packageB)
-    pA --> cA[ClassA]
-    pB --> pC(packageC)
-    pB --> cB[ClassB]
-    pB --> pD(packageD)
-    pC --> cC[ClassC]
-    pC --> cD[ClassD]
-    pD --> cE[ClassE]
+    java(java) --> lang(lang)
+    java --> util(util)
+    java --> time(time)
+    lang --> object[Object]
+    lang --> system[System]
+    util --> arraylist[ArrayList]
+    util --> scanner[Scanner]
+    time --> localdate(LocalDate)
+    time --> localtime(LocalTime)
 ```
 
 :::note Hinweis

From e462d2618c1f6a064aaf3846cbca84727fbdf5a0 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Fri, 15 Sep 2023 08:51:48 +0200
Subject: [PATCH 27/33] Update oo.md

---
 docs/documentation/oo.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/docs/documentation/oo.md b/docs/documentation/oo.md
index 4fb3a355ca..57367e39a4 100644
--- a/docs/documentation/oo.md
+++ b/docs/documentation/oo.md
@@ -33,8 +33,10 @@ flowchart LR
     getter1 -.-> read[Lesender Zugriff]
     getter2 -.-> read
     subgraph Klasse
-        attribut1((Attribut 1))
-        attribut2((Attribut 2))
+        subgraph privater Bereich
+            attribut1((Attribut 1))
+            attribut2((Attribut 2))
+        end
         setter1(Setter für Attribut 1) -.-> attribut1
         attribut1 -.-> getter1(Getter für Attribut 1)
         setter2(Setter für Attribut 2) -.-> attribut2

From b5f31d93192b50a28b3cf57da523794de7083dc0 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Fri, 15 Sep 2023 08:56:31 +0200
Subject: [PATCH 28/33] Update abstract-and-final.md

---
 docs/documentation/abstract-and-final.md | 33 ++++++++++++++----------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/docs/documentation/abstract-and-final.md b/docs/documentation/abstract-and-final.md
index fbaa115894..3bb9d93303 100644
--- a/docs/documentation/abstract-and-final.md
+++ b/docs/documentation/abstract-and-final.md
@@ -5,24 +5,31 @@ sidebar_position: 200
 tags: [abstract-and-final]
 ---
 
-Mit Hilfe der Schlüsselwörter `abstract` und `final` kann die Verwendung von Klassen vorgegeben bzw. eingeschänkt werden.
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
 
-## Abstrakte Klassen
-Abstrakte Klassen können nicht instanziiert werden.
+Mit Hilfe der Schlüsselwörter `abstract` und `final` kann die Verwendung von Klassen vorgegeben bzw. eingeschänkt werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209166284-ad66e8a2-6a85-4cc4-afd6-a5424a0a6ad5.png)
+<Tabs>
+  <TabItem value="abstractclasses" label="abstrakte Klassen" default>
 
-## Abstrakte Methoden
-Abstrakte Methoden werden in abstrakten Klassen definiert, besitzen dort keinen Methodenrumpf und müssen in den abgeleiteten Klassen der abstrakten Klasse überschrieben werden.
+  Abstrakte Klassen können nicht instanziiert werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209166331-be93409b-0501-4c0e-b1f1-0399e93c4d15.png)
+  </TabItem>
+  <TabItem value="abstractmethods" label="abstrakte Methoden">
 
-## Finale Klassen
-Finale Klassen können nicht abgeleitet werden.
+  Abstrakte Methoden werden in abstrakten Klassen definiert, besitzen dort keinen Methodenrumpf und müssen in den abgeleiteten Klassen der abstrakten Klasse überschrieben werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209166368-f9f79258-d0e8-49c7-8de3-55697583da6a.png)
+  </TabItem>
+  <TabItem value="finalclasses" label="finale Klassen">
 
-## Finale Methoden
-Finale Methoden können nicht überschrieben werden.
+  Finale Klassen können nicht abgeleitet werden.
+  
+  </TabItem>
+  </TabItem>
+  <TabItem value="finalmethods" label="finale Methoden">
 
-![image](https://user-images.githubusercontent.com/47243617/209166415-492e73ef-c103-4859-a879-863dea21953b.png)
+  Finale Methoden können nicht überschrieben werden.
+  
+  </TabItem>
+</Tabs>

From ea49cf145540ca7ae0c96a82b2a3827b08c6cd64 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Fri, 15 Sep 2023 10:37:26 +0200
Subject: [PATCH 29/33] Update java-stream-api.md

---
 docs/documentation/java-stream-api.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/docs/documentation/java-stream-api.md b/docs/documentation/java-stream-api.md
index 4960af8623..0950a21ac7 100644
--- a/docs/documentation/java-stream-api.md
+++ b/docs/documentation/java-stream-api.md
@@ -11,11 +11,11 @@ die Java Stream API auch Methoden zum Erzeugen unendlicher Ströme bereit.
 
 ```mermaid
 flowchart TD
-    Original --> Filtern
-    Filtern --> Abbilden
-    Abbilden --> Sortieren
+    Strom1 -->|Filtern| Strom2
+    Strom2 -->|Abbilden| Strom3
+    Strom3 -->|Sortieren| Strom4
 
-    subgraph Original
+    subgraph Strom1
         hans[Hans, 18, m]
         peter[Peter, 27, m]
         lisa[Lisa, 43, w]
@@ -24,17 +24,17 @@ flowchart TD
         philipp[Philipp, 22, m]
         maria[Maria, 17, w]
     end
-    subgraph Filtern
+    subgraph Strom2
         peter2[Peter, 27, m]
         heidi2[Heidi, 19, w]
         maria2[Maria, 17, w]
     end
-    subgraph Abbilden
+    subgraph Strom3
         peter3[PETER]
         heidi3[HEIDI]
         maria3[MARIA]
     end
-    subgraph Sortieren
+    subgraph Strom4
         heidi4[HEIDI]
         maria4[MARIA]
         peter4[PETER]

From c1244ae549b84bd0f4af0fa106518d5e91a4cb59 Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Fri, 15 Sep 2023 10:40:19 +0200
Subject: [PATCH 30/33] Update tests.md

---
 docs/documentation/tests.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/tests.md b/docs/documentation/tests.md
index ffd1c449e7..8708964e46 100644
--- a/docs/documentation/tests.md
+++ b/docs/documentation/tests.md
@@ -23,7 +23,10 @@ Komponententests (Unit Tests) spielen vor allem bei der Testgetriebenen Entwickl
 - Green: Genau soviel Produktivcode schreiben, damit der Test erfolgreich durchläuft
 - Refactor: Testcode und Produktivcode aufräumen (vereinfachen und verbessern)
 
-![image](https://user-images.githubusercontent.com/47243617/209136163-fd99c88b-6864-41fd-9b13-129a964ab2c3.png)
+```mermaid
+flowchart LR
+    Red --> Green --> Refactor --> Red
+```
 
 :::note Hinweis
 Da durch die vorangestellten Tests eine kontinuierliche Designverbesserung stattfindet, wird die Testgetriebene Entwicklung zu den Designstrategien gezählt.

From f74b5a70899d9b8169733d407d9e10dc5c0da31e Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Fri, 15 Sep 2023 10:49:15 +0200
Subject: [PATCH 31/33] Update tests.md

---
 docs/documentation/tests.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/docs/documentation/tests.md b/docs/documentation/tests.md
index 8708964e46..09d0c8af45 100644
--- a/docs/documentation/tests.md
+++ b/docs/documentation/tests.md
@@ -15,8 +15,6 @@ Man unterscheidet bei Softwaretests zwischen verschiedenen Testarten, die in der
 - Integrationstests: Testen mehrerer, voneinander abhängiger Komponenten
 - Komponententests: Testen einzelner, abgeschlossener Softwarebausteine
 
-![image](https://user-images.githubusercontent.com/47243617/209136099-fb19c504-1394-4781-87d6-20811bc274f3.png)
-
 ## Testgetriebe Entwicklung (Test Driven Development)
 Komponententests (Unit Tests) spielen vor allem bei der Testgetriebenen Entwicklung (Test Driven Development) eine große Rolle. Hierbei werden Anwendungen Schritt für Schritt (also inkrementell) um neue Funktionen erweitert (Red-Green-Refactor-Methode):
 - Red: Einen Test schreiben, der zunächst fehlschlägt

From 104c1830a998f3eb61b4082816eeeb88f4dbbe0f Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Fri, 15 Sep 2023 10:57:03 +0200
Subject: [PATCH 32/33] Update io-streams.md

---
 docs/documentation/io-streams.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/io-streams.md b/docs/documentation/io-streams.md
index 0757bb7593..eed6e19022 100644
--- a/docs/documentation/io-streams.md
+++ b/docs/documentation/io-streams.md
@@ -9,7 +9,15 @@ Datenströme (IO-Streams) sind unidirektionale Pipelines, die Schnittstellen ein
 Datenstrom kann dabei immer nur in eine Richtung verwendet werden (also entweder zur Ein- oder Ausgabe). Neben den Standard-Datenströmen zur Ein- und Ausgabe existieren verschiedene Klassen zum Schreiben und Lesen zeichenorientierter Daten, zum 
 Schreiben und Lesen byteorientierter Daten und zum Schreiben und Lesen serialisierter Objekte. Das Arbeiten mit Datenstrom-Klassen kann dabei aufwändig über "normale" try-catch-Anweisungen oder mit Hilfe von try-with-resources-Anweisungen realisiert werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209137344-814691e9-90c6-4ccf-95fa-5b50d55942aa.png)
+```mermaid
+flowchart LR
+    subgraph Datenstrom
+        direction LR
+        data1((4.2)) ~~~ data2((2.3)) ~~~ data3((1.6)) ~~~ data4((3.7))
+    end
+    write[Schreiben] -.-> Datenstrom
+    Datenstrom -.-> read[Lesen]
+```
 
 ## Standard-Datenströme zur Ein- und Ausgabe
 Java stellt Standard-Datenströme für die Eingabe (`System.in`), die Ausgabe (`System.out`), sowie die Fehlerausgabe (`System.err`) zur Verfügung.

From 68f10dbe45c009baa879ba943248b4b1c543febb Mon Sep 17 00:00:00 2001
From: appenmaier <47243617+appenmaier@users.noreply.github.com>
Date: Fri, 15 Sep 2023 11:21:29 +0200
Subject: [PATCH 33/33] Update programming.md

---
 docs/documentation/programming.md | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/docs/documentation/programming.md b/docs/documentation/programming.md
index 68b75264de..3ad76944e8 100644
--- a/docs/documentation/programming.md
+++ b/docs/documentation/programming.md
@@ -26,11 +26,33 @@ Auch wenn Programmiersprachen oft anhand ihrer grundlegenden Merkmale genau eine
 ### Imperative Programmierung
 Bei der imperativen Programmierung bestehen Programme aus verzweigten und sich wiederholenden Folgen von Anweisungen, die den Programmablauf steuern.
 
-![image](https://user-images.githubusercontent.com/47243617/209141943-9e9c985d-3c48-4ad5-8766-753f21f923ec.png)
+```mermaid
+stateDiagram-v2
+    state "Ausgabe: Zahl größer Null eingeben" as activity1
+    state "Eingabe: Zahl" as activity2
+    state "Ausgabe: Zahl ist nicht größer Null" as activity3
+    state "Ausgabe: Zahl ist größer Null" as activity4
+    state if <<choice>>
+        
+    [*] --> activity1
+    activity1--> activity2
+    activity2 --> if
+    if --> activity3 : Zahl kleiner gleich Null
+    if --> activity4 : Zahl größer Null     
+    activity3 --> activity1
+    activity4 --> [*]
+```
 
 ### Deklarative Programmierung
 Die deklarative Programmierung stellt einen Gegenentwurf zur imperativen Programmierung dar, bei der nicht das "Wie", sondern das "Was" im Vordergrund steht.
 
+```sql
+SELECT Name, Age
+  FROM Person
+  WHERE City = 'Berlin'
+  ORDER BY Name
+```
+
 ### Objektorientierte Programmierung
 Die ojektorientierte Programmierung baut auf der imperativen Programmierung auf, setzt den Fokus aber auf abstrakte Datentypen und die Verbindung von Daten und Routinen.