replace doc diagrams with mermaid

docs/documentation/abstract-and-final.md

@@ -5,24 +5,117 @@ sidebar_position: 200
 tags: [abstract-and-final]
 ---
 
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
 Mit Hilfe der Schlüsselwörter `abstract` und `final` kann die Verwendung von Klassen vorgegeben bzw. eingeschänkt werden.
 
 ## Abstrakte Klassen
 Abstrakte Klassen können nicht instanziiert werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209166284-ad66e8a2-6a85-4cc4-afd6-a5424a0a6ad5.png)
+<Tabs>
+  <TabItem value="abstractClass" label="Abstrakte Klasse" default>
+
+  ```java title="Person.java" showLineNumbers
+  public abstract class Person { }
+  ```
+
+  </TabItem>
+  <TabItem value="mainClass" label="Startklasse" default>
+
+  ```java title="MainClass.java" showLineNumbers
+  public class MainClass {
+
+    public static void main(String[] args) {
+      Person person = new Person(); // Kompilierungsfehler
+    }
+
+  }
+  ```
+
+  </TabItem>
+</Tabs>
 
 ## 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 Methoden werden in abstrakten Klassen definiert, besitzen dort keinen Methodenrumpf und müssen in den abgeleiteten Klassen der abstrakten Klasse
+überschrieben werden.
+
+<Tabs>
+  <TabItem value="abstractClassWithAbstractMethod" label="Abstrakte Klasse mit abstrakter Methode">
+
+  ```java title="Person.java" showLineNumbers
+  public abstract class Person {
+
+    public abstract print();
+
+  }
+  ```
+
+  </TabItem>
+  <TabItem value="mainClass" label="Startklasse">
 
-![image](https://user-images.githubusercontent.com/47243617/209166331-be93409b-0501-4c0e-b1f1-0399e93c4d15.png)
+  ```java title="Student.java" showLineNumbers
+  public class Student extends Person {
+
+    public print() { }
+
+  }
+  ```
+
+  </TabItem>
+</Tabs>
 
 ## Finale Klassen
 Finale Klassen können nicht abgeleitet werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209166368-f9f79258-d0e8-49c7-8de3-55697583da6a.png)
+<Tabs>
+  <TabItem value="finalClass" label="Finale Klasse">
+
+  ```java title="Person.java" showLineNumbers
+  public final class Person { }
+  ```
+
+  </TabItem>
+  <TabItem value="subClass" label="Unterklasse">
+
+  ```java title="Student.java" showLineNumbers
+  public class Student extends Person { } // Kompilierungsfehler
+  ```
+
+  </TabItem>
+</Tabs>
 
 ## Finale Methoden
 Finale Methoden können nicht überschrieben werden.
 
-![image](https://user-images.githubusercontent.com/47243617/209166415-492e73ef-c103-4859-a879-863dea21953b.png)
+<Tabs>
+  <TabItem value="classWithFinalMethod" label="Oberklasse mit finaler Methode">
+
+  ```java title="Person.java" showLineNumbers
+  public class Person {
+
+    private String name;
+
+    public Person(String name) {
+      this.name = name;
+    }
+    public final name() {
+      return name;
+    }
+
+  }
+  ```
+
+  </TabItem>
+  <TabItem value="subClass" label="Unterklasse">
+
+  ```java title="Student.java" showLineNumbers
+  public class Student extends Person {
+
+    public name() { } // Kompilierungsfehler
+
+  }
+  ```
+
+  </TabItem>
+</Tabs>

docs/documentation/array-lists.md

@@ -0,0 +1,33 @@
+---
+title: Feldbasierte Listen (ArrayLists)
+description: ''
+sidebar_position: 120
+tags: []
+---
+
+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
+
+Um das Arbeiten mit Feldern zu erleichtern, stellt die Java API die Klasse `ArrayList<E>` zur Verfügung. Diese stellt eine veränderbare Liste dynamischer Größe auf Basis eines Feldes dar und bietet hilfreiche Methoden zum Hinzufügen, Ändern, Löschen und Lesen von Listelementen.
+
+```java title="MainClass.java" showLineNumbers
+public class MainClass {
+
+  public static void main(String[] args) {
+    List<String> list = new ArrayList<>();
+    list.add("Hans");
+    list.add("Peter");
+    list.add("Lisa");
+
+    System.out.println(list.size());
+    System.out.println(list.get(0));
+    list.set(0, "Max");
+    list.add("Heidi");
+    list.remove(0);
+  }
+
+}
+```

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 
@@ -52,7 +60,7 @@ public class MainClass {
 Der Index beginnt bei Java bei 0.
 :::
 
-## Der Parameter `String[] args`
+## Der Parameter _String[] args_
 Der Parameter `String[] args` der main-Methode ermöglicht es dem Anwender, der ausführbaren Klasse beim Aufruf Informationen mitzugeben.
 
 ```java title="MainClass.java" showLineNumbers
@@ -91,11 +99,3 @@ public class MainClass {
 :::note Hinweis
 Technisch gesehen handelt es sich bei einer variablen Argumentliste um ein Feld.
 :::
-
-## Herausforderungen beim Arbeiten mit Feldern
-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)

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.

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.
 

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)
-

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.

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