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.
-
+
+
-## 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.
-
+
+
-## 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.
-
+
+
-## Finale Methoden
-Finale Methoden können nicht überschrieben werden.
+ Finale Klassen können nicht abgeleitet werden.
+
+
+
+
-
+ Finale Methoden können nicht überschrieben werden.
+
+
+
diff --git a/docs/documentation/arrays.md b/docs/documentation/arrays.md
index 08c58185e1..cdb429796f 100644
--- 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.
-
+```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
-
-
diff --git a/docs/documentation/class-structure.md b/docs/documentation/class-structure.md
index 973f1d1a90..732d07d63e 100644
--- 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.
-
+```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
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.
diff --git a/docs/documentation/control-structures/control-structures.md b/docs/documentation/control-structures/control-structures.md
index fc36418418..4a9d647781 100644
--- 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.
-
-
diff --git a/docs/documentation/data-objects.md b/docs/documentation/data-objects.md
index 0cb360c112..2833dfc4b4 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.
-
+```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.
-
+```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
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`.
-
+```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
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.
-
+```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
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.
-
+```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
index 2fa6753e0e..e3ea1a2bb5 100644
--- 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.
-
-
:::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
index ffa0397e16..0950a21ac7 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.
-
+```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
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.
-
+```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> entrySet()`, `Set keySet()` und `Collection 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` 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` implementiert hat. Alternativ kann dem Konstruktor der Klasse `TreeMap`
ein Komparator für den Schlüssel mitgegeben werden.
-
+```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
index b297dbcbcb..57367e39a4 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
-
+```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.
-
+```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.
-
+```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`.
diff --git a/docs/documentation/programming.md b/docs/documentation/programming.md
index 17484edca0..3ad76944e8 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.
-
+```mermaid
+flowchart LR
+ Analyse --> Entwurf --> Umsetzung --> Auslieferung --> Wartung --> Analyse
+```
:::note Hinweis
Ein Algorithmus ist eine Handlungsvorschrift zur Lösung eines Problems.
@@ -17,17 +20,39 @@ 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
Bei der imperativen Programmierung bestehen Programme aus verzweigten und sich wiederholenden Folgen von Anweisungen, die den Programmablauf steuern.
-
+```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 <>
+
+ [*] --> 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.
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 {
diff --git a/docs/documentation/tests.md b/docs/documentation/tests.md
index ffd1c449e7..09d0c8af45 100644
--- a/docs/documentation/tests.md
+++ b/docs/documentation/tests.md
@@ -15,15 +15,16 @@ Man unterscheidet bei Softwaretests zwischen verschiedenen Testarten, die in der
- Integrationstests: Testen mehrerer, voneinander abhängiger Komponenten
- Komponententests: Testen einzelner, abgeschlossener Softwarebausteine
-
-
## 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
- Green: Genau soviel Produktivcode schreiben, damit der Test erfolgreich durchläuft
- Refactor: Testcode und Produktivcode aufräumen (vereinfachen und verbessern)
-
+```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.
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
-
+```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 <>
+ [*] --> output1
+ output1 --> input1
+ input1 --> output2
+ output2 --> input2
+ input2 --> if
+ if --> output2 : 2. Zahl ist gleich 0
+ if --> activity1: 2. Zahl ist ungleich 0
+ activity1 --> [*]
+```