jappuccini · appenmaier · Sep 4, 2023 · Sep 6, 2023 · Sep 6, 2023 · Sep 6, 2023
diff --git 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>
diff --git a/docs/documentation/arrays.md b/docs/documentation/arrays.md
@@ -8,7 +8,15 @@ 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
+    subgraph names
+        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
+``` 
 
 ## 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 +105,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)
diff --git a/docs/documentation/class-structure.md b/docs/documentation/class-structure.md
@@ -129,7 +129,18 @@ 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
+    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
 Die Klassen des Entwicklungspaketes `java.lang` müssen nicht importiert werden.

diff --git 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.
 

diff --git a/docs/documentation/control-structures/control-structures.md b/docs/documentation/control-structures/control-structures.md
@@ -8,5 +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.
 
-![image](https://user-images.githubusercontent.com/47243617/209095715-801a859e-a9d1-4478-94c6-e51596c9da4e.png)
-
diff --git 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.
@@ -119,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.

diff --git 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`.

diff --git 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.

diff --git 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.

diff --git a/docs/documentation/java-api/files.md b/docs/documentation/java-api/files.md
@@ -37,8 +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.
 
-![image](https://user-images.githubusercontent.com/47243617/209096722-dce8f11a-851b-4535-af37-0b987929c2e3.png)
-
 :::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/]
+    project[Project] --> documents        
+    documents[documents] --> documentB[/DocumentB.txt/]
+```
+
+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.
diff --git 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
+    Strom1 -->|Filtern| Strom2
+    Strom2 -->|Abbilden| Strom3
+    Strom3 -->|Sortieren| Strom4
+
+    subgraph Strom1
+        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 Strom2
+        peter2[Peter, 27, m]
+        heidi2[Heidi, 19, w]
+        maria2[Maria, 17, w]
+    end
+    subgraph Strom3
+        peter3[PETER]
+        heidi3[HEIDI]
+        maria3[MARIA]
+    end
+    subgraph Strom4
+        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.

diff --git 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))
+```
 
diff --git 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,7 +26,23 @@ 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)
+```mermaid
+flowchart LR
+    write[Schreibender Zugriff] -.-> setter1
+    write -.-> setter2
+    getter1 -.-> read[Lesender Zugriff]
+    getter2 -.-> read
+    subgraph Klasse
+        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
+        attribut2 -.-> getter2(Getter für Attribut 2)
+    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.
@@ -86,7 +107,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`.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -8,5 +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.

		![image](https://user-images.githubusercontent.com/47243617/209095715-801a859e-a9d1-4478-94c6-e51596c9da4e.png)