richtig

Programmierung2/.classpath

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-22">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

Programmierung2/.gitignore

@@ -0,0 +1 @@
+/bin/

Programmierung2/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Programmierung2</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Programmierung2/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

Programmierung2/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,14 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=22
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=22
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=22

Programmierung2/src/Algorithmus/Algorithmus.java

@@ -0,0 +1,126 @@
+package Algorithmus;
+
+public class Algorithmus {
+	
+	public static void main(String[] args) {
+
+		int[] arr = { 4,34,2,6,8,12,21};
+		 int[] sortedArray =insertionSort(arr) ;
+	        
+	        for (int i : sortedArray)
+	            System.out.print(i + " ");
+		
+		
+	}
+	
+	public static int[] mergeSort(int[] arr) {
+		/*
+		 * Big-O: O(n log n)
+		 */
+		return arr;
+	}
+	
+	public static int[] insertionSort(int[] arr) {
+		/*
+		 * Big-O: O(n²)
+		 * 						 indexes: 0 1  2 3 4 5  6	
+		 * Beispiel array = int[] arr = { 4,34,2,6,8,10,21};
+		 */
+		
+	    for (int i = 1; i < arr.length; i++) {
+	    	// speicher den Wert an i Index nehmen an dass i = 2;
+	    	// also z.b: Key = 2;
+	        int key = arr[i]; 
+	        // speicher das vorhägie Index
+	        int j = i - 1; 
+	        /*
+	         * Also die While Loop Konzept ist:
+	         * - betrachtet wird die 2 an Index 2
+	         * - j = 1 also >= 0
+	         * - arr[i] ist in dem Fall = 34
+	         * - ist die 34 > 2, weil key = 2;
+	         * - ja 
+	         */
+	        while (j >= 0 && arr[j] > key) {
+	        	//also ersetzen 34 druch die 2
+	        	// aber die 2 wurde erst in var key abgespeichert
+	            arr[j + 1] = arr[j]; 
+	            // index j -1 
+	            j = j - 1;
+	        }
+	        // hier ersetzen wir die 34 durch die 2
+	        arr[j + 1] = key;
+	    }
+
+	    return arr; // Rückgabe des sortierten Arrays
+	}
+
+	
+	public static int[] selectionSort(int[] arr) {
+		
+		/*		
+		 * Big-O: O(n²)				 
+		 * 						 indexes: 0 1  2 3 4 5  6	
+		 * Beispiel array = int[] arr = { 4,34,2,6,8,10,21};
+		 * 
+		 */
+		//Äueßere Schleife beginnt bei Index(0) bis zu index (6)
+		// Beispiel wert
+		for (int i = 0; i < arr.length - 1; i++) { // i = index (4)
+			int minIndex = i;// minIndex = index (4)
+			
+			// überprüft ob die 4 < andere Element im array
+			// es soll ab i + 1 überprüft werden
+			for (int j = i + 1; j < arr.length; j++) {
+				//ja, die 2  <  4
+				if (arr[j] < arr[minIndex]) {
+					// also minIndex = index (2) also gleich 2
+					minIndex = j; 
+				}
+			}
+			// falls minIndex anderes Index bekommen hat?
+			if (minIndex != i) {
+				//speichere erst die 4 hier
+				int temp = arr[i];
+				// ersetzte die 2 durch die 4
+				arr[i] = arr[minIndex];
+				//ersetze die 4  durch die 2
+				arr[minIndex] = temp;
+			}
+		}
+
+		return arr; // Rückgabe des sortierten Arrays
+	}
+	
+	public static int[] bubbleSort(int[] arr) {
+		// Big-O: O(n²)
+		for (int i = 0; i < arr.length; i++)
+			for(int j = 0; j < arr.length; j++) 
+				if (arr[i] < arr[j]) {
+					int temp = arr[i];
+					arr[i] = arr[j];
+					arr[j] = temp;
+				}
+		return arr;
+	}
+
+	public static int binarySearch(int[] arr, int value) {
+	    int erst = 0; // Initialisierung des Startindexes auf den ersten Index des Arrays
+	    int last = arr.length - 1; // Initialisierung des Endindexes auf den letzten Index des Arrays
+
+	    while (erst <= last) { // Schleife läuft, solange der Startindex kleiner oder gleich dem Endindex ist
+	        int mittel = (erst + last) / 2; // Berechnung des mittleren Indexes durch Addition von Start und Ende, dann Division durch 2
+
+	        if (arr[mittel] == value)  // Überprüfung, ob der Wert im Array an der mittleren Position dem gesuchten Wert entspricht
+	            return mittel; // Wenn ja, wird der mittlere Index als Ergebnis zurückgegeben
+	        else if (arr[mittel] < value) // Überprüfung, ob der Wert im Array an der mittleren Position kleiner als der gesuchte Wert ist
+	            erst = mittel + 1; // Wenn ja, wird der Startindex auf die Position nach der Mitte gesetzt
+
+	        else // Wenn der Wert im Array an der mittleren Position größer als der gesuchte Wert ist
+	            last = mittel - 1; // Setzt den Endindex auf die Position vor der Mitte
+	    }
+	    return -1; // Wenn der Wert nicht gefunden wird, wird -1 zurückgegeben
+	}
+
+
+}

Programmierung2/src/Algorithmus/Array.java

@@ -0,0 +1,54 @@
+package Algorithmus;
+public class Array {
+
+	public static void main(String[] args) {
+		// Erstellt ein Array für 5 Elemente vom Typ int
+		int[] array = new int[5];
+		
+		 // Erstellt und initialisiert das Array mit Werten
+		int[] array2 = {1, 2, 3, 4, 5};
+		
+		// Zugriff auf das erste Element
+		int firstElement = array[0]; 
+		
+		// Zugriff auf das letzte Element (bei einem Array der Größe 5)
+		int lastElement = array[4]; 
+		
+		// Setzt das dritte Element des Arrays auf 10
+		array2[2] = 10;
+		
+		//for schleife mit einem Array
+		for(int i = 0; i < array.length; i++) 
+		    System.out.println(array[i]);
+		
+		//foreach Schleife
+		for(int element : array) 
+		    System.out.println(element);
+		
+
+		// Erstellt ein 3x3-Array (Matrix
+		int[][] array_21d = new int[3][3]; 
+		
+		//Initialisieren eines 2D-Arrays:
+		int[][] array_2d = {
+			    {1, 2, 3},
+			    {4, 5, 6},
+			    {7, 8, 9}
+			};
+		
+		
+		// Greift auf das Element in der zweiten Zeile und dritten Spalte zu
+		int element = array_2d[1][2]; 
+
+		
+		//Array mit Objekten, hier sollte eine Klass mit Name Person erstellt werden
+		/*
+		 * Person[] persons = new Person[2]; // Erstellt ein Array für 2 Person-Objekte
+		   persons[0] = new Person("Alice", 30);
+		   persons[1] = new Person("Bob", 25);
+		   System.out.println(persons[0].name); // Ausgabe: Alice
+		 */
+
+	}
+
+}

Programmierung2/src/Algorithmus/Logischen_Operatoren.java

@@ -0,0 +1,52 @@
+package Algorithmus;
+
+public class Logischen_Operatoren {
+
+	public static void main(String[] args) {
+		
+		/* Bitweises UND (&):
+		 * - Funktion: Der & Operator prüft beide Operanden und gibt true zurück, wenn beide Operanden true sind.
+		 * - Merkmal: Beide Bedingungen (a und b) werden immer ausgewertet, unabhängig davon, ob die erste Bedingung false ergibt.
+		 * - Das Prinzip gilt auch für die anderen Logischen_Operatoren
+		 */
+		
+		//Beispiel:
+		boolean x = true;
+		boolean y = false;
+		// Z ist false, weil y false ist, aber y wird dennoch ausgewertet.
+		boolean z = x & y; 
+		
+		//Praktischer Einsatz:
+		int a = 5;
+		int b = 0;
+		
+		//Beide Bedingungen werden überprüft, b wird erhöht, auch wenn a false ist!
+		if ( a > 5 & (b++ < 10))
+			System.out.println(a);
+
+		System.out.println(b);// b = 1
+		
+		
+
+
+		
+		/* Logisches UND (&&): 
+		 * - Funktion: Der && Operator prüft ebenfalls beide Operanden und gibt true zurück, wenn beide true sind.
+		 * - Merkmal: Wenn der erste Operand false ist, wird der zweite Operand nicht mehr ausgewertet. Dies spart Rechenzeit und kann in bestimmten Fällen Fehler vermeiden.
+		 */
+		
+		//Praktischer Einsatz:
+		int a2 = 5;
+		int b2 = 0;
+
+		// Beide Bedingungen werden überprüft, b wird nicht erhöht, da a false ist!
+		if (a2 > 5 && (b2++ < 10))
+			System.out.println(a2);
+
+		System.out.println(b2);// b = 0
+				
+		
+		
+		
+	}
+}

Programmierung2/src/BankSystemGUI/BankController.java

@@ -0,0 +1,50 @@
+package BankSystemGUI;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+public class BankController {
+	private File file;
+	BankController(){
+		file = new File("C:\\Users\\obaya\\git\\Programmierung2\\Programmierung2\\src\\BankSystemGUI\\Kunde.txt");
+		if (!file.exists()) {
+				try {
+					if (file.createNewFile()) // createNewFile() gibt boolean zurück,ob der File ergolgreich erstellt wurde
+												// oder nicht
+						System.out.println("Datei erstellt: " + file.getName()); // der File muss im Pfad nicht existieren,
+																					// damit es erstellt wurde
+				} catch (IOException d) {
+					d.printStackTrace();
+				}
+			}
+		}
+	
+	public BankSystem addKunde(String name,String vorname,String password,String email) {
+		BankSystem b1 = new BankSystem(name,vorname,password,email);
+		saveKunde(b1);
+		return b1;
+	}
+	
+	
+	
+	public void saveKunde(BankSystem b1) {
+		 try (PrintWriter write = new PrintWriter(new FileWriter(file))) {
+			 	write.println("ID: " + b1.getId());
+			 	write.println("Vorname: " + b1.getVorname());
+	            write.println("Nachname: " + b1.getName());
+	            write.println("Password: " + b1.getPassword());
+	            write.println("Email: " + b1.getEmail());
+	            write.println("kontoStand " + b1.getKontoStand());
+	            write.println(); // Leere Zeile zwischen Einträgen
+	        	write.flush();
+				write.close();
+				System.out.println(b1.toString());
+	        } catch (IOException e) {
+	            e.printStackTrace();
+		
+	        }
+	}
+}
+

Programmierung2/src/BankSystemGUI/BankSystem.java

@@ -0,0 +1,93 @@
+package BankSystemGUI;
+
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JFrame;
+import javax.swing.JTextField;
+// Recourses  Klasse (Model)
+public class BankSystem   {
+	private String name;
+	private String vorname;
+	private String password;
+	private String email;
+	private double kontoStand;
+	private int Id;
+    private static int IDCounter = 0;
+
+	BankSystem(){}
+	BankSystem(String name,String vorname,String password,String email){
+	this.name = name;
+	this.vorname = vorname;
+	this.password = password;
+	this.email = email;
+	this.kontoStand = 0;
+	this.Id = ++IDCounter;
+	
+	}
+	
+	public double einzahlung(double wert) {
+		
+		return	this.kontoStand += wert;
+	}
+	
+	
+	
+	
+	public int loadIDCounter() {
+		return Id; 
+	}
+	
+	public String getEmail() {
+		return email;
+	}
+
+	public void setEmail(String email) {
+		this.email = email;
+	}
+	
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getVorname() {
+		return vorname;
+	}
+
+	public void setVorname(String vorname) {
+		this.vorname = vorname;
+	}
+	
+	public String getPassword() {
+		return password;
+	}
+
+	public void setPassword(String password) {
+		this.password = password;
+	}
+	
+	
+	
+	public double getKontoStand() {
+		return kontoStand;
+	}
+
+
+	public int getId() {
+		return Id;
+	}
+
+
+	@Override
+	public String toString() {
+		return "BankSystem [name=" + name + ", vorname=" + vorname + ", password=" + password + ", kontoStand="
+				+ kontoStand + ", Id=" + Id + "]";
+	}
+	
+}

Programmierung2/src/BankSystemGUI/BankSystemTest.java

@@ -0,0 +1,14 @@
+package BankSystemGUI;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;
+
+public class BankSystemTest {
+	
+    @Test
+    public void testEinzahlung() {
+    	BankSystem test = new BankSystem();
+        double x = test.einzahlung(100);
+        assertEquals(100, x, 0.001);  // Hier wird überprüft, ob der Kontostand 100.0 ist
+    }
+}

Programmierung2/src/BankSystemGUI/Hauptfenster.java

@@ -0,0 +1,57 @@
+package BankSystemGUI;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+import javax.swing.JLabel;
+
+public class Hauptfenster extends BankSystem {
+	private Window fenster;
+	private Scanner scan;
+	
+	Hauptfenster() throws FileNotFoundException{
+		File fr = new File("C:\\Users\\obaya\\git\\Programmierung2\\Programmierung2\\src\\BankSystemGUI\\Kunde.txt");
+		scan = new Scanner(fr);
+		String vorname = null;
+		String name = null;
+		double kontoStand = 0.0;
+		while (scan.hasNextLine()) {
+             String line = scan.nextLine();
+              // Prüfen, ob die Zeile den "Vorname" enthält
+              if (line.startsWith("Vorname:")) 
+                  vorname = line.split(":")[1].trim();  // Den Namen extrahieren
+              
+              if (line.startsWith("Nachname: ")) 
+            	  name = line.split(":")[1].trim(); 
+              
+              if (line.startsWith("kontoStand ")) {
+            	  String value = line.split(" ")[1].trim();
+            	  kontoStand = Double.parseDouble(value);
+            	  break;  // Wir haben den Namen gefunden, also beenden wir die Schleife
+              }
+            	
+            	
+              
+		}
+	   
+		fenster = new Window();
+		fenster.setTitle("Haupseite");
+		
+		JLabel willkommennachricht = new JLabel("Willkommen "  + vorname + " " + name);
+		willkommennachricht.setBounds(10, 10, 200, 40);
+		
+		
+		JLabel konotstand = new JLabel("Deine Aktuelle Kontostand: " + kontoStand);
+		konotstand.setBounds(10,50 ,200 ,40 );
+		
+		
+		fenster.add(konotstand);
+		fenster.add(willkommennachricht);
+	}
+	
+	public static void main(String[] args) throws FileNotFoundException {
+		Hauptfenster test = new Hauptfenster();
+	}
+
+}

Programmierung2/src/BankSystemGUI/Kunde.txt

@@ -0,0 +1,7 @@
+ID: 1
+Vorname: obai
+Nachname: albek
+Password: 12345
+Email: obay@gmail.com
+kontoStand 0.0
+

Programmierung2/src/BankSystemGUI/LogIn.java

@@ -0,0 +1,125 @@
+package BankSystemGUI;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+
+public class LogIn extends JFrame implements ActionListener {
+	private JButton submit;
+	private File file;
+	private PrintWriter write;
+	private JTextField eingabeVorname;
+	private JTextField eingabenNachname;
+	private JTextField eingabenPassword;
+	private JTextField eingabeEmail;
+	private BankController controller;
+	private Window fenster;
+	
+	LogIn() {
+		controller = new BankController();
+		fenster = new Window();
+		fenster.setTitle("log in Seite");
+
+		JLabel überschrift = new JLabel("loggen Sie sich ein: ");
+		überschrift.setBounds(10, 2, 120, 40);
+
+		JLabel vorname = new JLabel("Vorname: ");
+		vorname.setBounds(10, 50, 60, 10);
+		eingabeVorname = new JTextField();
+		eingabeVorname.setBounds(80, 50, 100, 20);
+
+		// setBounds(int x, int y, int width, int height)
+		JLabel nachname = new JLabel("nachname: ");
+		nachname.setBounds(10, 90, 100, 20);
+
+		eingabenNachname = new JTextField();
+		eingabenNachname.setBounds(80, 90, 100, 20);
+
+		JLabel password = new JLabel("password: ");
+		password.setBounds(10, 130, 100, 20);
+
+		eingabenPassword = new JTextField();
+		eingabenPassword.setBounds(80, 130, 100, 20);
+
+		JLabel email = new JLabel("Email: ");
+		email.setBounds(10, 170, 100, 20);
+
+		eingabeEmail = new JTextField();
+		eingabeEmail.setBounds(80, 170, 100, 20);
+
+		submit = new JButton("Submit");
+		submit.setBounds(10, 210, 100, 20);
+
+		submit.addActionListener(new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				try {
+					logUser();
+				} catch (IOException e1) {
+					// TODO Auto-generated catch block
+					e1.printStackTrace();
+				}
+			}
+		});
+
+		fenster.add(überschrift);
+		fenster.add(vorname);
+		fenster.add(eingabeVorname);
+		fenster.add(nachname);
+		fenster.add(eingabenNachname);
+		fenster.add(password);
+		fenster.add(eingabenPassword);
+		fenster.add(email);
+		fenster.add(eingabeEmail);
+		fenster.add(submit);
+
+	}
+
+	public void logUser() throws IOException {
+		if (eingabeVorname.getText().isEmpty() || eingabenNachname.getText().isEmpty()
+				|| eingabenPassword.getText().isEmpty() || eingabeEmail.getText().isEmpty())
+			JOptionPane.showMessageDialog(null, "Alle Felder sind erforderlich", "Fehler", JOptionPane.ERROR_MESSAGE);
+		else {
+			String vorname = eingabeVorname.getText();
+			String nachname = eingabenNachname.getText();
+			String password = eingabenPassword.getText();
+			String email = eingabeEmail.getText();
+			
+			BankSystem kunde = controller.addKunde(nachname, vorname, password, email);
+			//JOptionPane.showMessageDialog(null, "Erfolgreich eingeloggt!", "Info", JOptionPane.INFORMATION_MESSAGE);
+			fenster.dispose();
+		}
+		
+	}
+	
+	
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+	
+	public static void main(String[] args) {
+		
+		
+	}
+
+}
+
+	
+

Programmierung2/src/BankSystemGUI/Test.java

@@ -0,0 +1,18 @@
+package BankSystemGUI;
+
+import java.util.ArrayList;
+
+public class Test {
+
+	public static void main(String[] args) {
+		
+       BankSystem b1 = new BankSystem("obai","albek","12345","obay@gmail.com");
+       System.out.println(b1.toString());
+       b1.einzahlung(100);
+       System.out.println(b1.getKontoStand());
+       System.out.println(b1.toString());
+//        
+
+	}
+
+}

Programmierung2/src/BankSystemGUI/Window.java

@@ -0,0 +1,22 @@
+package BankSystemGUI;
+
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+
+import javax.swing.JFrame;
+
+public class Window extends JFrame {
+
+		public JFrame window;
+		
+		Window(){
+			
+			setSize(700, 700);
+			setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+			setLayout(null);
+			setVisible(true);
+
+		}
+	
+
+}

Programmierung2/src/BinaryTree/BinaryBaumList.java

@@ -0,0 +1,453 @@
+package BinaryTree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class BinaryBaumList {
+	Node root;
+
+	// -----------------------------------------------------------------
+	private int findTreeHeightRekursiv(Node temp) {
+		if (temp == null)
+			return -1;
+
+		int left_subTree = findTreeHeightRekursiv(temp.left);
+		int right_subTree = findTreeHeightRekursiv(temp.right);
+
+		if (left_subTree > right_subTree)
+			return 1 + left_subTree;
+
+		return 1 + right_subTree;
+	}
+
+	public int getHeight() {
+		return findTreeHeightRekursiv(root);
+	}
+
+	// -----------------------------------------------------------------
+	private void additerativ(int value) {
+		// erzeuge eine neue knote
+		Node newNode = new Node();
+		// setze in knote einen Wert
+		newNode.value = value;
+		// ersetze left Knote auf Null
+		newNode.left = null;
+		// ersetze rechte Knote auf Null
+		newNode.right = null;
+
+		// wenn meine Liste leer ist
+		if (root == null) {
+			this.root = newNode;
+			return;
+		}
+		// Wenn sie nicht leer!
+
+		// temp root, um einfacher zu suchen
+		Node temp = root;
+		// da mein Temp bis null Knote läuft,
+		// speichere ich seinen vorhängieren Wert
+		Node merker = temp;
+		while (temp != null) {
+			// speichere temp vorhängieren Wert
+			merker = temp;
+			// wenn soll ich die linke Seite betrachten
+			if (value < temp.value)
+				temp = temp.left;
+
+			// wenn nein soll ich die rechte Seite betrachten
+			else
+				temp = temp.right;
+		}
+		// so wenn ich ganz unten bin, soll ich sehen, ob ich die Knote rechts oder
+		// linke einsetzen soll
+		// Wenn ja, Knote auf der Linke Seite einsetzen
+		if (value < merker.value)
+			merker.left = newNode;
+		// Wenn nein, Knote auf der rechte Seite einsetzen
+		else
+			merker.right = newNode;
+	}
+
+	private void addRekursiv(Node temp, int value) {
+
+		// erzeuge eine neue knote
+		Node newNode = new Node();
+		// setze in knote einen Wert
+		newNode.value = value;
+		// ersetze left Knote auf Null
+		newNode.left = null;
+		// ersetze rechte Knote auf Null
+		newNode.right = null;
+		// falls die Liste leer ist!
+		if (temp == null) {
+			root = newNode;
+			System.out.println("Die Root: " + root.value);
+			return;
+		}
+		// Wenn ja die Linke Seite betrachten
+		if (value < temp.value) {
+			// Wenn mein temp die die Knote null erreicht
+			if (temp.left == null) {
+				// erstze die Knote
+				temp.left = newNode;
+				System.out.println("Linke Knote: " + temp.left.value);
+			}
+			// wenn mein Temp die Knote null nicht erreicht hat
+			else {
+				// laufe weiter
+				addRekursiv(temp.left, value);
+			}
+
+		}
+		// wenn die Value größer als die Root
+		// also die rechte Seite betrachten
+		else {
+			if (temp.right == null) {
+				// erstze die Knote
+				temp.right = newNode;
+				System.out.println("Rechte Knote: " + temp.right.value);
+
+			} else {
+				// laufe Weiter
+				addRekursiv(temp.right, value);
+			}
+		}
+	}
+
+	public void addElement(int value) {
+		// additerativ(value);
+		addRekursiv(root, value);
+
+	}
+
+	// -----------------------------------------------------------------
+	private int findMinRekursiv(Node temp) {
+
+		if (temp.left == null)
+			return temp.value;
+
+		return findMinRekursiv(temp.left);
+	}
+
+	private int findMinIterativ(Node temp) {
+
+		while (temp.left != null)
+			temp = temp.left;
+
+		return temp.value;
+	}
+
+	public int findMin() {
+		return findMinRekursiv(root);
+		// return findMinIterativ(root);
+	}
+	// -----------------------------------------------------------------
+
+	// -----------------------------------------------------------------
+	private int findMaxRekursiv(Node temp) {
+		// // Wenn es kein rechtes Kind gibt, ist dies das Maximum
+		if (temp.right == null)
+			return temp.value;
+
+		// Rekursiv weiter nach rechts gehen
+		return findMaxRekursiv(temp.right);
+	}
+
+	private int findMaxIterativ(Node temp) {
+		while (temp.right != null)
+			temp = temp.right;
+
+		return temp.value;
+	}
+
+	public int findMax() {
+		// Es gibt keine Elemente
+		if (root == null)
+			return -1;
+
+		// Wenn ja, dann hat root den Max Wert
+		if (root.right == null)
+			return root.value;
+
+		// return findMaxRekursiv(root);
+		return findMaxIterativ(root);
+	}
+
+	// -----------------------------------------------------------------
+	private void printPreorder(Node temp) {// [root][left][right]
+		if (temp == null)
+			return;
+		System.out.print(temp.value + " ");
+		printPreorder(temp.left);
+		printPreorder(temp.right);
+	}
+
+	private void printInorder(Node temp) {// [left][root][right]
+		if (temp == null) {
+			return;
+		}
+		printInorder(temp.left);
+		System.out.print(temp.value + " ");
+		printInorder(temp.right);
+
+	}
+
+	private void printPostoder(Node temp) {// [left][right][root]
+		if (temp == null)
+			return;
+
+		printPreorder(temp.left);
+		printPreorder(temp.right);
+		System.out.print(temp.value + " ");
+	}
+
+	private void BreadthFirst() {
+		// Erstelle eine Queue (Warteschlange) vom Typ LinkedList, um die Knoten für die
+		// Level-Order Traversal zu speichern.
+		Queue<Node> q1 = new LinkedList<>();
+
+		// Füge den Wurzelknoten des Baums in die Warteschlange ein.
+		// Dies ist der Startpunkt für die Breadth-First Traversal.
+		q1.add(root);
+
+		// Solange die Warteschlange nicht leer ist, gibt es noch Knoten zu besuchen.
+		while (!q1.isEmpty()) {
+			// Schau dir das erste Element in der Warteschlange an, ohne es zu entfernen.
+			// Dies gibt dir den aktuellen Knoten, den du verarbeiten willst.
+			Node temp = q1.peek();
+
+			// Entferne das Element (den Knoten), das gerade verarbeitet wird, aus der
+			// Warteschlange.
+			// Dies verschiebt die Warteschlange und macht den nächsten Knoten zum
+			// "Front"-Element.
+			q1.remove();
+
+			// Gib den Wert des aktuellen Knotens aus, den du gerade bearbeitest.
+			// Dies ist der eigentliche Schritt, bei dem du die Traversal-Ergebnisse
+			// ausgibst.
+			System.out.print(temp.value + " ");
+
+			// Wenn der linke Kindknoten existiert, füge ihn zur Warteschlange hinzu.
+			// Dies stellt sicher, dass der linke Kindknoten später in der richtigen
+			// Reihenfolge bearbeitet wird.
+			if (temp.left != null)
+				q1.add(temp.left);
+
+			// Wenn der rechte Kindknoten existiert, füge ihn ebenfalls zur Warteschlange
+			// hinzu.
+			// Dies stellt sicher, dass der rechte Kindknoten nach dem linken Kindknoten
+			// bearbeitet wird.
+			if (temp.right != null)
+				q1.add(temp.right);
+		}
+	}
+
+	public void printDepth() {
+		// printPreorder(root);
+		// printInorder(root);
+		BreadthFirst();
+	}
+	// -----------------------------------------------------------------
+	
+	/*
+	 * Löschen von Knoten: 
+	 * - wenn eine Knote gelöscht werden soll, sollen erst 4 wichtige Eigenschaften betrachtet werden: 
+	 * 		1. ob die Knote überhaupt igrendwo im Baum liegt (suchen)
+	 * 		2. ob die Knote ein Blatt (leaf Node) ist,das heißt die Knote hat weder rechte Knote noch linke Knote 
+	 * 		3. ob die Knote nur ein einziges Kind hat 
+	 * 		4. ob die Knote zwei Kinder hat
+	 * 			4.1 hier entscheidt man, was er nehmen möchte:
+	 * 				. Inorder-Vorgänger: Suche nach dem größten Knoten im linken Teilbaum
+	 * 				. Inorder-Nachfolger: Suche nach dem kleinsten Knoten im rechten Teilbaum.
+	 * 
+	 */
+
+	// 1. Suchen
+	private boolean searchNummberIterativ(int value) {
+		if (root == null)
+			return false;
+		
+		Node temp = root;
+		while (temp.value != value) {
+			if (value < temp.value && temp.left != null)
+				temp = temp.left;
+
+			else if (value >= temp.value && temp.right != null)
+				temp = temp.right;
+
+			else
+				break;
+		}
+		if (temp.value == value)
+			return true;
+
+		return false;
+
+	}
+	
+	private boolean searchNummberRekursiv(Node temp , int value) {
+		if (temp == null)
+			return false;
+		
+		if (temp.value == value)
+			return true;
+		
+		else if(value < temp.value)
+			return	searchNummberRekursiv(temp.left , value);
+		
+		else
+			return searchNummberRekursiv(temp.right , value);
+			
+	}
+	
+	public void searchNummber(int value) {
+		
+		if(searchNummberRekursiv(root,value))
+			System.out.println("Ist gefunden: " + value);
+		else
+			System.out.println("Ist nicht gefunden!");
+	}
+  
+	
+	//2. löschen als leaf Node
+	private void removeleafNode(int value) {
+		if (!searchNummberIterativ(value)) {
+			System.out.println("Die zahl befindet sich nicht im Baum!");
+			return;
+		}
+		Node temp = root;
+		Node merker = null;
+		while( temp.value != value) {
+			merker = temp;
+			if (value < temp.value)
+				temp = temp.left;
+			
+			else if (value >= temp.value)
+				temp = temp.right;
+		}
+		if (temp.value < merker.value)
+			merker.left = null;
+		
+		else
+			merker.right = null;
+	}
+	
+	//3. lösche eine Knote mit einem einzigen Kind
+	private void removeWithOneChild(int value) {
+		if (!searchNummberIterativ(value)) {
+			System.out.println("Die zahl befindet sich nicht im Baum!");
+			return;
+		}
+		Node temp = root;
+		Node merker = null;
+		while( temp.value != value) {
+			merker = temp;
+			if (value < temp.value)
+				temp = temp.left;
+			
+			else if (value >= temp.value)
+				temp = temp.right;
+		}
+		
+		if (temp.left != null)
+			merker.left = temp.left;
+		else
+			merker.right = temp.right;
+		
+	}
+	
+	//4. lösche eine Knote mit zwei Kindern
+	private void removeWithTwoChildern(int value) {
+		if (!searchNummberIterativ(value)) {
+			System.out.println("Die zahl befindet sich nicht im Baum!");
+			return;
+		}
+		Node temp = root;
+		Node merker = null;
+		while( temp.value != value) {
+			if (value < temp.value)
+				temp = temp.left;
+			
+			else if (value >= temp.value)
+				temp = temp.right;
+			
+			merker = temp;
+		}
+		temp = temp.left;
+		Node merker2 = temp;
+		while(temp.right != null) {
+			merker2 = temp;
+			temp = temp.right;
+		}
+		merker.value = temp.value;
+		merker2.right = null;
+	}
+	
+	//2,3,4 Cases
+	private void removWithAllCases(int value) {
+		if (!searchNummberIterativ(value)) {
+			System.out.println("Die zahl befindet sich nicht im Baum!");
+			return;
+		}
+
+		Node temp = root;
+		Node merker = null;
+		while (temp.value != value) {
+			merker = temp;
+			if (value < temp.value)
+				temp = temp.left;
+
+			else if (value >= temp.value)
+				temp = temp.right;
+
+		}
+
+		// Die knote ist ein Blatt (leaf Node)
+		if (temp.left == null && temp.right == null) {
+			if (merker == null)
+				root =null;
+			else if (merker.left == temp)
+				merker.left = null;
+			else
+				merker.right = null;
+		}
+		
+		// Die Knote hat genau ein Kind entweder links oder rechts
+		if (temp.left == null || temp.right == null) {
+			if (temp.left != null && temp.right == null)
+				merker.left = temp.left;
+
+			else
+				merker.right = temp.right;
+
+			return;
+		}
+
+		// Die Knote hat zwei Kinder
+		else {
+			merker = temp;
+			// weg(1): nach links gehen und ganz nach unten rechts gehen
+			temp = temp.left;
+			Node merker2 = temp;
+			while (temp.right != null) {
+				merker2 = temp;
+				temp = temp.right;
+			}
+			merker.value = temp.value;
+			merker2.right = null;
+		}
+		
+		
+		
+		
+
+	}
+	public void removNode(int value) {
+		// removeleafNode(value); 
+		//removeWithOneChild(value);
+		//removeWithTwoChildern(value);
+		 removWithAllCases(value);
+	}
+	
+}

Programmierung2/src/BinaryTree/JuintTeste.java

@@ -0,0 +1,23 @@
+package BinaryTree;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+class JuintTeste {
+
+	@Test
+	void test() {
+		BinaryBaumList b1 = new BinaryBaumList();
+		b1.addElement(15);
+		b1.addElement(6);
+		b1.addElement(3);
+		b1.addElement(9);
+		b1.addElement(8);
+		b1.addElement(20);
+		b1.addElement(25);
+		
+	}
+
+}

Programmierung2/src/BinaryTree/Node.java

@@ -0,0 +1,8 @@
+package BinaryTree;
+
+public class Node  {
+	int value;
+	Node left;
+	Node right;
+	
+}

Programmierung2/src/BinaryTree/Test.java

@@ -0,0 +1,39 @@
+package BinaryTree;
+
+public class Test {
+
+	public static void main(String[] args) {
+		BinaryBaumList b1 = new BinaryBaumList();
+		b1.addElement(50);
+		b1.addElement(30);
+		b1.addElement(70);
+		b1.addElement(20);
+		b1.addElement(40);
+		b1.addElement(60);
+		b1.addElement(80);
+		b1.addElement(15);
+		b1.addElement(22);
+		b1.addElement(35);
+		b1.addElement(45);
+		b1.addElement(21);
+		b1.addElement(25);
+
+
+	
+		
+		System.out.print("[");
+		b1.printDepth();
+		System.out.print("]");
+		System.out.println();
+		b1.removNode(30);
+		System.out.print("[");
+		b1.printDepth();
+		System.out.print("]");
+
+	}
+	
+
+	
+	
+
+}

Programmierung2/src/Collection/Collections.java

@@ -0,0 +1,10 @@
+package Collection;
+public class Collections {
+
+	/* Collections: eine Sammlung von Werten, die vom gleichen Datentyp sein können oder auch nicht.
+	 * 1. Array:
+	 * 	- ist änderbar, hat fixed Size und indexed 
+	 * 
+	 */
+
+}

Programmierung2/src/Collection/Lists.java

@@ -0,0 +1,46 @@
+package Collection;
+
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Stack;
+import java.util.Vector;
+
+public class Lists {
+	/*
+	 * - Duplikate von Elementen ist zulassen 
+	 * - die Methoden alle KlassenLists sind ähnlich zueinander
+	 * - Stack Prinzip : LIFO (Last In, First Out)
+	 * - indexded Lists
+	 */
+
+	public static void main(String[] args) {
+		// Die vier Lists sind dynamischen Lists
+		ArrayList<String> arrayList = new  ArrayList<>();
+		
+		LinkedList<String> linkedList = new LinkedList<>();
+		
+		List<String> vector = new Vector<>();
+		// stack erbt von Vector
+		Stack<String> stack = new Stack<>();
+		
+		arrayList.add("arrayList");
+		linkedList.add("LinkedList");
+		vector.add("Vektor");
+		stack.add("Stack");
+		System.out.println(arrayList);
+		System.out.println(linkedList);
+		System.out.println(vector);
+		System.out.println(stack);
+		stack.push("pushed String");
+		System.out.println(stack);
+		stack.pop();
+		System.out.println(stack);
+		// gibt das oberste Element zurück
+		stack.peek();
+		System.out.println(stack);
+		
+	} 
+
+}

Programmierung2/src/Collection/Queueslist.java

@@ -0,0 +1,71 @@
+package Collection;
+
+
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Deque;
+import java.util.ArrayDeque;
+
+public class Queueslist {
+	/*
+	 * - Queue Prinzip: FIFO (First In, First Out)
+	 * - dynamische nicht indexed lists
+	 * 
+	 */
+
+	public static void main(String[] args) {
+		Queue<String> queue = new LinkedList<>();
+		
+		//füge ein Element am Ende hinzu
+		queue.add("1");
+		System.out.println(queue);
+		// füge ein Element am Ende hinzu
+		queue.add("2");
+		System.out.println(queue);
+		
+		// füge ein Element am Ende hinzu, gibt false zurück, wenn die Queue full ist
+		queue.offer("3");
+		System.out.println(queue);
+		
+		
+		
+		//Entfernt das erste Element in der Queue und gibt es zurück.
+		queue.remove();
+		//Entfernt das erste Element in der Queue und gibt es zurück. Gibt null zurück, wenn die Queue leer ist, 
+		queue.poll();
+		
+		
+		/* Spezielle Queue-Typen:
+		 * 
+		 * 1. PriorityQueue: ordnet ihre Elemente in einer natürlichen Ordnung oder nach einem angegebenen Comparator.
+		 */
+		
+		 PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
+		 priorityQueue.add(10);
+	     priorityQueue.add(20);
+	     priorityQueue.add(7);
+
+	     System.out.println(priorityQueue.poll()); // Ausgabe: 7 (niedrigster Wert zuerst)
+	     System.out.println(priorityQueue.poll()); // Ausgabe: 10 zweite niedrigster Wert
+		
+		
+		
+		/*
+		* Spezielle Queue-Typen:
+		* 
+		* 1. Deque (Double-Ended Queue): erlaubt das Hinzufügen und Entfernen von Elementen an beiden Enden der Queue.
+		*/
+	     
+	     Deque<String> deque = new ArrayDeque<>();
+
+		deque.addFirst("First");
+		deque.addLast("Last");
+		deque.addFirst("New First");
+
+		System.out.println(deque.removeFirst()); // New First
+		System.out.println(deque.removeLast()); // Last
+		
+	}
+
+}

Programmierung2/src/Collection/Setlists.java

@@ -0,0 +1,60 @@
+package Collection;
+
+
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class Setlists {
+	/* - nicht indexed lists
+	 * - erlaubt keine doppelten Elemente
+	 * - HashSet, LinkedHashSet und TreeSet 
+	 * 
+	 */
+	public static void main(String[] args) {
+		
+		/*
+		 * 1. HashSet:
+		 * 	- Verwendet eine HashMap intern, um die Elemente zu speichern
+		 *  - Bietet konstante Zeit für die grundlegenden Operationen (add, remove, contains), solange die Hash-Funktion effizient ist.
+		 *  - Die Reihenfolge der Elemente ist nicht garantiert.
+		 */
+		Set<String> hashSet = new HashSet<>();
+		hashSet.add("Apple");
+		hashSet.add("Banana");
+		hashSet.add("Apple"); // wird ignoriert, da "Apple" bereits existiert
+		
+		System.out.println(hashSet); // Ausgabe: Apple,Banana
+		
+		
+		/*
+		 * 2. LinkedHashSet:
+		 * - Verwendet eine verknüpfte Liste (LinkedList) zusammen mit einer HashMap, um die Elemente zu speichern.
+		 */
+		
+		Set<String> linkedHashSet = new LinkedHashSet<>();
+		linkedHashSet.add("Apple");
+		linkedHashSet.add("Banana");
+		linkedHashSet.add("Apple");
+		System.out.println(linkedHashSet);// wird ignoriert, da "Apple" bereits existiert
+		
+		
+		/*
+		 * 3. TreeSet:
+		 * - Verwendet eine selbstbalancierende Baumstruktur (Red-Black Tree), um die Elemente zu speichern.
+		 * - Elemente werden in natürlicher Ordnung (oder durch einen Comparator, falls angegeben) sortiert gespeichert.
+		 */
+		
+		Set<String> treeSet = new TreeSet<>();
+		treeSet.add("Banana");
+		treeSet.add("Apple");
+		treeSet.add("Apple");
+		
+		// die zweite Apple wird ignorieret und die Reihnfolge wird automatisch sortiert
+		System.out.println(treeSet);
+
+		
+	}
+
+}

Programmierung2/src/FassadenKlasse/Fassadenklasse.java

@@ -0,0 +1,68 @@
+package FassadenKlasse;
+/*In Allgemein: Also zu verstehe ist, das Fassade-Muster hilft dabei
+ 	 * , die Komplexität eines Systems zu verbergen und es für den Benutzer einfacher zu machen
+ 	 * , mit dem System zu interagieren.
+ 	 */
+
+	// Subsystem-Klasse für Speicherverwaltung
+	class Speicher {
+	    public void initialisiereSpeicher() {
+	        System.out.println("Speicher wird initialisiert...");
+	    }
+	}
+
+	// Subsystem-Klasse für Prozessorverwaltung
+	class Prozessor {
+	    public void initialisiereProzessor() {
+	        System.out.println("Prozessor wird initialisiert...");
+	    }
+	}
+
+	// Subsystem-Klasse für Eingabegeräteverwaltung
+	class Eingabegeräte {
+	    public void initialisiereEingabegeräte() {
+	        System.out.println("Eingabegeräte werden initialisiert...");
+	    }
+	}
+
+	// Subsystem-Klasse für Netzwerkverwaltung
+	class Netzwerk {
+	    public void initialisiereNetzwerk() {
+	        System.out.println("Netzwerk wird initialisiert...");
+	    }
+	}
+
+	// Fassade-Klasse, die eine einfache Schnittstelle bereitstellt
+	class ComputersystemFassade {
+	    private Speicher speicher;
+	    private Prozessor prozessor;
+	    private Eingabegeräte eingabegeräte;
+	    private Netzwerk netzwerk;
+
+	    public ComputersystemFassade() {
+	        this.speicher = new Speicher();
+	        this.prozessor = new Prozessor();
+	        this.eingabegeräte = new Eingabegeräte();
+	        this.netzwerk = new Netzwerk();
+	    }
+
+	    // Die Fassade-Methode, die das System startet
+	    public void systemStarten() {
+	        System.out.println("Systemstart wird vorbereitet...");
+	        speicher.initialisiereSpeicher();
+	        prozessor.initialisiereProzessor();
+	        eingabegeräte.initialisiereEingabegeräte();
+	        netzwerk.initialisiereNetzwerk();
+	        System.out.println("System erfolgreich gestartet!");
+	    }
+	}
+
+	// Client-Code, der die Fassade verwendet
+	public class Fassadenklasse {
+	    public static void main(String[] args) {
+	        // Der Client verwendet die Fassade, um das System zu starten
+	        ComputersystemFassade fassade = new ComputersystemFassade();
+	        fassade.systemStarten();
+	    }
+	}
+

Programmierung2/src/GUIAnwendungen/BewegePanle.java

@@ -0,0 +1,58 @@
+package GUIAnwendungen;
+
+import java.awt.Color;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.Timer;
+
+public class BewegePanle extends JPanel {
+	 private int yPosition = 0; // Startposition des Panels oben
+	    private final int speed = 1; // Geschwindigkeit der Bewegung
+	    private final int panelWidth = 100;
+	    private final int panelHeight = 100;
+
+	    public BewegePanle() {
+	        // Setze die Hintergrundfarbe des Panels
+	        setBackground(Color.red);
+
+	        // Timer initialisieren und starten
+	        			//(int delay, ActionListener listener)
+	        Timer timer = new Timer(10, new ActionListener() {
+	            @Override
+	            public void actionPerformed(ActionEvent e) {
+	                // Aktualisiere die y-Position
+	                yPosition += speed;
+
+	                // Wenn das Panel unten angekommen ist, starte wieder von oben
+	                if (yPosition > 750 - panelHeight) {
+	                    yPosition = 0; // Zurück an den oberen Rand
+	                }
+
+	                // Erzwinge das Neuzeichnen des Panels
+	                setBounds(0, yPosition, panelWidth, panelHeight);
+	            }
+	        });
+
+	        timer.start(); // Timer starten
+	    }
+
+	    public static void main(String[] args) {
+	        // Erstelle das Hauptfenster
+	        JFrame frame = new JFrame();
+	        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+	        frame.setSize(750, 750);
+	        frame.setLayout(null); // Deaktiviere das Layout-Management
+
+	        // Erstelle eine Instanz von Jpanel und füge sie dem Fenster hinzu
+	        BewegePanle panel = new BewegePanle();
+	        panel.setBounds(0, 0, 100, 100); // Initiale Position und Größe
+	        frame.add(panel);
+
+	        // Mache das Fenster sichtbar
+	        frame.setVisible(true);
+	    }
+	}
+

Programmierung2/src/GUIAnwendungen/Borderlayout.java

@@ -0,0 +1,82 @@
+package GUIAnwendungen;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+public class Borderlayout {
+	/*
+	 *  steuert die Positionierung von Komponenten in einem Container
+	 *  Z.B: 
+	 *  NORTH (oben)
+		SOUTH (unten)
+		EAST (rechts)
+		WEST (links)
+		CENTER (Mitte)
+		
+	 */
+
+	public static void main(String[] args) {
+		
+	    // Erstelle ein Fenster (JFrame-Objekt)
+	    JFrame frame = new JFrame();
+			
+	    // Setzt das Layout des Rahmens auf BorderLayout mit einem Abstand von 10 Pixeln zwischen den Komponenten
+	    frame.setLayout(new BorderLayout(10,10));
+			
+	    // Legt die Größe des Fensters fest (Breite: 750 Pixel, Höhe: 750 Pixel)
+	    frame.setSize(750, 750);
+			
+	    // Stellt sicher, dass das Programm beendet wird, wenn das Fenster geschlossen wird
+	    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+			
+	    // Setzt den Titel des Fensters
+	    frame.setTitle("Mein erstes Fenster");
+			
+	    // Macht das Fenster sichtbar
+	    frame.setVisible(true);
+			
+	    // Erstelle fünf JPanel-Objekte, die als Container für andere Komponenten dienen können
+	    JPanel panel1 = new JPanel();
+	    JPanel panel2 = new JPanel();
+	    JPanel panel3 = new JPanel();
+	    JPanel panel4 = new JPanel();
+	    JPanel panel5 = new JPanel();
+			
+	    // Setzt den Hintergrund von panel1 auf Rot
+	    panel1.setBackground(Color.red);
+	    // Setzt den Hintergrund von panel2 auf Grün
+	    panel2.setBackground(Color.green);
+	    // Setzt den Hintergrund von panel3 auf Gelb
+	    panel3.setBackground(Color.yellow);
+	    // Setzt den Hintergrund von panel4 auf Magenta
+	    panel4.setBackground(Color.magenta);
+	    // Setzt den Hintergrund von panel5 auf Blau
+	    panel5.setBackground(Color.blue);
+			
+	    // Legt die bevorzugte Größe von panel1 fest (100x100 Pixel)
+	    panel1.setPreferredSize(new Dimension(100,100));
+	    // Legt die bevorzugte Größe von panel2 fest (100x100 Pixel)
+	    panel2.setPreferredSize(new Dimension(100,100));
+	    // Legt die bevorzugte Größe von panel3 fest (100x100 Pixel)
+	    panel3.setPreferredSize(new Dimension(100,100));
+	    // Legt die bevorzugte Größe von panel4 fest (100x100 Pixel)
+	    panel4.setPreferredSize(new Dimension(100,100));
+	    // Legt die bevorzugte Größe von panel5 fest (100x100 Pixel)
+	    panel5.setPreferredSize(new Dimension(100,100));
+			
+	    // Fügt panel1 im Bereich NORTH des BorderLayouts hinzu
+	    frame.add(panel1, BorderLayout.NORTH);
+	    // Fügt panel2 im Bereich WEST des BorderLayouts hinzu
+	    frame.add(panel2, BorderLayout.WEST);
+	    // Fügt panel3 im Bereich EAST des BorderLayouts hinzu
+	    frame.add(panel3, BorderLayout.EAST);
+	    // Fügt panel4 im Bereich SOUTH des BorderLayouts hinzu
+	    frame.add(panel4, BorderLayout.SOUTH);
+	    // Fügt panel5 im Bereich CENTER des BorderLayouts hinzu
+	    frame.add(panel5, BorderLayout.CENTER);
+			
+	}
+
+}

Programmierung2/src/GUIAnwendungen/Flowlayout.java

@@ -0,0 +1,64 @@
+package GUIAnwendungen;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+public class Flowlayout {
+	
+	/*
+	 * - Ordent die Komponenten innerhalb eines Containers in einer einzigen Zeile
+	 * - Ausrichtung: Die Komponenten können linksbündig (LEFT), zentriert (CENTER), oder rechtsbündig (RIGHT) ausgerichtet werden.
+	 * - hier wird auch angezeigt, wie man button auf Panel paltziert
+	 * Hinweis: FlowLayout bietet keine Möglichkeit, eine einzelne Komponente manuell zu platzieren.
+	 */
+
+	public static void main(String[] args) {
+
+		// Erstelle ein JFrame-Fenster
+		JFrame fenster = new JFrame();
+
+		// Beendet das Programm beim Schließen des Fensters
+		fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Legt die Größe des Fensters auf 500x500 Pixel fest
+		fenster.setSize(500, 500);
+
+		// Setzt das Layout des Fensters auf FlowLayout mit zentrierter Ausrichtung und
+		// Abständen von 10 Pixeln
+		fenster.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10));
+
+		// Erstelle ein JPanel mit vordefinierter Größe 250x250 Pixel und hellgrauem
+		// Hintergrund
+		JPanel panel1 = new JPanel();
+		panel1.setPreferredSize(new Dimension(250, 250));
+		panel1.setBackground(Color.lightGray);
+
+		// Setzt das Layout von panel1 ebenfalls auf FlowLayout
+		panel1.setLayout(new FlowLayout());
+
+		// Füge dem Panel 9 Buttons hinzu, die in einer Zeile oder mehreren Zeilen
+		// angeordnet werden
+		panel1.add(new JButton("1"));
+		panel1.add(new JButton("2"));
+		panel1.add(new JButton("3"));
+		panel1.add(new JButton("4"));
+		panel1.add(new JButton("5"));
+		panel1.add(new JButton("6"));
+		panel1.add(new JButton("7"));
+		panel1.add(new JButton("8"));
+		panel1.add(new JButton("9"));
+
+		// Füge das Panel dem JFrame hinzu
+		fenster.add(panel1);
+
+		// Macht das Fenster sichtbar
+		fenster.setVisible(true);
+	}
+
+
+}

Programmierung2/src/GUIAnwendungen/GridBagLayoutExample.java

@@ -0,0 +1,31 @@
+package GUIAnwendungen;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+public class GridBagLayoutExample {
+	/*- manuell positionien von Elementen
+	 * - in viel flexibleres Layout-Manager, bei dem du die Position, 
+	 * 	 Größe und Ausdehnung (über mehrere Zeilen/Spalten) der einzelnen Komponenten präzise steuern kannst.
+	 * - Du kannst einzelne Komponenten unterschiedlich groß machen, sie über mehrere Zellen spannen und Abstände festlegen.
+	 */
+    public static void main(String[] args) {
+        JFrame frame = new JFrame("GridBagLayout Example");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setLayout(null);
+        JButton button1 = new JButton("Button1");
+        frame.add(button1);
+        
+        button1.setBounds(0, 0, 120, 30);
+        frame.setSize(800, 800);
+        frame.setVisible(true);
+    }
+}

Programmierung2/src/GUIAnwendungen/Gridlayout.java

@@ -0,0 +1,42 @@
+package GUIAnwendungen;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+public class Gridlayout {
+
+	public static void main(String[] args) {
+
+		// Erstelle ein JFrame-Fenster
+		JFrame fenster = new JFrame();
+
+		// Beendet das Programm beim Schließen des Fensters
+		fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Legt die Größe des Fensters auf 500x500 Pixel fest
+		fenster.setSize(500, 500);
+		fenster.setLayout(new GridLayout(4,3,10,4));
+		
+		fenster.add(new JButton("1"));
+		fenster.add(new JButton("2"));
+		fenster.add(new JButton("3"));
+		fenster.add(new JButton("4"));
+		fenster.add(new JButton("5"));
+		fenster.add(new JButton("6"));
+		fenster.add(new JButton("7"));
+		fenster.add(new JButton("8"));
+		fenster.add(new JButton("9"));
+		
+		fenster.setVisible(true);
+
+		
+	}
+
+}

Programmierung2/src/GUIAnwendungen/Jframe.java

@@ -0,0 +1,40 @@
+package GUIAnwendungen;
+
+import java.awt.Color;
+
+import javax.swing.JFrame;
+
+public class Jframe {
+	
+	/*
+	 * - mit der Klasse(JFrame) erzeugen wir ein Fenster
+	 */
+	
+	public static void main(String[] args) {
+		
+		// Erstelle ein Fenster
+		JFrame frame = new JFrame();
+		
+		//setVisible(boolean): gibt an, ob mein Fenster sichtbar ist oder nicht
+		frame.setVisible(true);
+		
+		//setSize(width, height)
+		frame.setSize(420, 500);
+		
+		// setzte einen Überschrift für mein Fenster
+		frame.setTitle("Mein erstes Fenster");
+		
+		// Schließe das Fenster richtig zu
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		
+		// Mein Fenster kann ab jetzt nicht mehr vergößert oder verkleinert werden
+		frame.setResizable(false);
+		
+		//gib das Fenster eine Farbe
+			frame.getContentPane().setBackground(Color.green);
+		//oder rgb Farbe
+			frame.getContentPane().setBackground(new Color(0,0,100));
+		
+	}
+
+}

Programmierung2/src/GUIAnwendungen/Jpanel.java

@@ -0,0 +1,42 @@
+package GUIAnwendungen;
+
+import java.awt.Color;
+import java.awt.Font;
+
+import javax.swing.BorderFactory;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.border.Border;
+
+// mit Jpanel kann man alle grafischen Bauelemente einsetzen
+public class Jpanel {
+
+	public static void main(String[] args) {
+		JPanel panel = new JPanel();
+		panel.setBackground(Color.red);
+		// setze eine Grafisches Bauelement (int x, int y, int width, int height)
+		panel.setBounds(100, 100, 10, 10);
+
+		
+		JFrame frame = new JFrame();
+		
+		//stellt sicher, dass keine automatische Positionierung und Größenanpassung erhalten
+		frame.setLayout(null);
+		
+		// setSize(width, height)
+		frame.setSize(750, 750);
+
+		// setzte einen Überschrift für mein Fenster
+		frame.setTitle("Mein erstes Fenster");
+		
+		//setVisible(boolean): gibt an, ob mein Fenster sichtbar ist oder nicht
+		frame.setVisible(true);
+		
+		frame.add(panel);
+		
+
+	}
+
+}

Programmierung2/src/GUIAnwendungen/KeyBindingsExample.java

@@ -0,0 +1,31 @@
+package GUIAnwendungen;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+
+public class KeyBindingsExample extends JFrame {
+    public KeyBindingsExample() {
+        setTitle("KeyBindings Beispiel");
+        setSize(300, 200);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+        // Panel erstellen
+        JPanel panel = new JPanel();
+        add(panel);
+
+        // KeyBinding hinzufügen: 'A' Taste
+        panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("A"), "keyA");
+        panel.getActionMap().put("keyA", new AbstractAction() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                System.out.println("Taste 'A' wurde gedrückt (KeyBindings).");
+            }
+        });
+
+        setVisible(true);
+    }
+
+    public static void main(String[] args) {
+        new KeyBindingsExample();
+    }
+}

Programmierung2/src/GUIAnwendungen/Labels.java

@@ -0,0 +1,83 @@
+package GUIAnwendungen;
+
+import java.awt.Color;
+import java.awt.Font;
+
+import javax.swing.BorderFactory;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.border.Border;
+
+/*
+ * JLabel =  ist ein GUI Anzeiger für hinzufügen von Texten und Bildern
+ */
+
+public class Labels {
+
+	public static void main(String[] args) {
+		// Erstelle eine Label
+		JLabel label = new JLabel(); 
+		
+		// Erstelle einen Border für das Fenster
+		Border b1 = BorderFactory.createLineBorder(Color.GREEN,5);
+		
+		// füge den Text auf dem Fenster hinzu
+		label.setText("Hall Welt");
+		
+		/*
+		 * - Mit diesen zwei Methode positioniere ich den Text auf dem Bild 
+		 * 		1. setHorizontalTextPosition(JLabel.CENTER); set Text LEFT,CENTER,RIGHT auf dem Bild
+		 * 		2. label.setVerticalTextPosition(JLabel.TOP);set Text TOP,CENTER, DOWN auf dem Bild
+		 * - man kann auch integer Werte eingeben
+		 */
+		label.setHorizontalTextPosition(JLabel.CENTER); // Horozional
+		label.setVerticalTextPosition(JLabel.TOP); // vertikal
+		
+		// gib für den Schrifft eine Farbe aus der Klasse Color ein
+			// entweder: 
+			label.setForeground(Color.GREEN);
+			// oder:
+			label.setForeground(new Color(0,0,100));
+		
+		//gib Schriftart aus der Klasse Font ein
+		label.setFont(new Font("MV Boli",Font.PLAIN,20));
+		
+		// verschiebe den Text nach beliebg Position 
+		label.setIconTextGap(20);
+		
+		// setze eine Farbe für Background 
+		label.setBackground(Color.black);
+		label.setOpaque(true);
+		
+		//zeige den Border auf dem Fenster
+		label.setBorder(b1);
+		
+		
+		//füge ein Bild hinzu
+		ImageIcon image = new ImageIcon("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\GUIAnwendungen\\Test.jpg");
+		label.setIcon(image);
+		
+		
+		// Erstelle ein Fenster
+		JFrame frame = new JFrame();
+		// setSize(width, height)
+		frame.setSize(500, 500);
+
+		// setzte einen Überschrift für mein Fenster
+		frame.setTitle("Mein erstes Fenster");
+		
+		//setVisible(boolean): gibt an, ob mein Fenster sichtbar ist oder nicht
+		frame.setVisible(true);
+		
+		// zeige den Text auf dem Fenster 
+		frame.add(label);
+		
+		
+		
+		
+		
+	
+	}
+
+}

Programmierung2/src/GUIAnwendungen/ShowMessage.java

@@ -0,0 +1,63 @@
+package GUIAnwendungen;
+
+import javax.swing.JFrame;
+import javax.swing.JOptionPane;
+
+public class ShowMessage {
+	
+	/*
+	 * - erstellt einfache Dialogfenster (Pop-up-Fenster)
+	 * - können verwendet werden, um Nachrichten anzuzeigen, Eingaben vom Benutzer zu erfassen oder den Benutzer vor bestimmten Aktionen zu warnen.
+	 * - durch null kann man viele sachen ersetzen:
+	 * 		. Fenster
+	 * 		. Jpanel
+	 * 		.  public MeinFenster() {
+        	super("Mein Fenster");
+        	JOptionPane.showMessageDialog(this, "Beispiel.", "Titel", JOptionPane.WARNING_MESSAGE);
+    		
+    		. etc...
+    }	
+	 */
+
+	    public static void main(String[] args) {
+	        // Erstelle ein JFrame-Fenster mit dem Titel "Mein Fenster"
+	        JFrame fenster = new JFrame("Mein Fenster");
+
+	        // Zeige eine Fehlermeldung in einem Dialog an, zentriert relativ zu 'fenster'
+	        JOptionPane.showMessageDialog(fenster, "Beispiel.", "title", JOptionPane.ERROR_MESSAGE);
+
+	        // Zeige eine Informationsmeldung in einem Dialog an, zentriert auf dem Bildschirm
+	        JOptionPane.showMessageDialog(null, "Beispiel..", "title", JOptionPane.INFORMATION_MESSAGE);
+
+	        // Zeige eine Frage in einem Dialog an, zentriert auf dem Bildschirm
+	        JOptionPane.showMessageDialog(null, "Beispiel.", "title", JOptionPane.QUESTION_MESSAGE);
+
+	        // Zeige eine Warnung in einem Dialog an, zentriert auf dem Bildschirm
+	        JOptionPane.showMessageDialog(null, "Beispiel.", "title", JOptionPane.WARNING_MESSAGE);
+
+	        /*
+	         * Zeige einen Bestätigungsdialog an, um den Benutzer zu fragen,
+	         * ob er fortfahren möchte (Ja/Nein/Abbrechen).
+	         * Antwort wird in 'antwort' gespeichert.
+	         */
+	        int antwort = JOptionPane.showConfirmDialog(null, "Möchten Sie fortfahren?");
+	        if (antwort == JOptionPane.YES_OPTION) {
+	            // Benutzer hat 'Ja' gewählt
+	            System.out.println("Benutzer hat 'Ja' gewählt.");
+	        } else if (antwort == JOptionPane.NO_OPTION) {
+	            // Benutzer hat 'Nein' gewählt
+	            System.out.println("Benutzer hat 'Nein' gewählt.");
+	        } else if (antwort == JOptionPane.CANCEL_OPTION) {
+	            // Benutzer hat 'Abbrechen' gewählt
+	            System.out.println("Benutzer hat 'Cancel' gewählt.");
+	        }
+
+	        // Zeige einen Eingabedialog an, um den Benutzer nach seinem Namen zu fragen
+	        String eingabe = JOptionPane.showInputDialog("Geben Sie Ihren Namen ein:");
+	        // Gib den eingegebenen Namen in der Konsole aus
+	        System.out.println("Benutzername: " + eingabe);
+	    }
+	}
+
+
+

Programmierung2/src/GUIAnwendungen/TextEingaben.java

@@ -0,0 +1,58 @@
+package GUIAnwendungen;
+
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JTextField;
+
+/*Beschreibung das Problem:
+ * Instanzvariablen sollten verwendet werden, wenn du sicherstellen möchtest, dass Variablen wie JButton und JTextField in der gesamten Klasse (und in actionPerformed) sichtbar sind.
+	Der Konstruktor der Klasse wird verwendet, um die GUI-Komponenten zu initialisieren und das Fenster aufzubauen.
+	Die main-Methode ist static und dient dazu, die Anwendung zu starten, indem sie eine Instanz der Klasse erstellt.
+	Anonyme innere Klassen sind eine praktische Möglichkeit, wenn du einfache Event-Handling-Logik direkt in der main-Methode implementieren möchtest, ohne eine zusätzliche Klasse oder Instanzmethoden zu erstellen.
+ * 
+ */
+
+public class TextEingaben extends JFrame implements ActionListener {
+    // Instanzvariablen
+    private JTextField textField;
+    private JButton button1;
+
+    // Konstruktor
+    public TextEingaben() {
+        // Initialisiere das Textfeld und den Button
+        textField = new JTextField();
+        textField.setPreferredSize(new Dimension(240, 40));
+
+        button1 = new JButton("Submit");
+        button1.setPreferredSize(new Dimension(240, 40));
+        button1.addActionListener(this); // `this` verweist auf das aktuelle Objekt der Klasse
+
+        // Setze das Layout und füge die Komponenten hinzu
+        setLayout(new FlowLayout());
+        add(textField);
+        add(button1);
+
+        // Konfiguriere das JFrame
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setSize(500, 500);
+        setVisible(true);
+    }
+
+    // Die Methode wird aufgerufen, wenn der Button gedrückt wird
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        if (e.getSource() == button1) {
+            System.out.println("Hallo " + textField.getText());
+        }
+    }
+
+    public static void main(String[] args) {
+        // Erstelle eine Instanz der Klasse, wodurch der Konstruktor aufgerufen wird
+        new TextEingaben();
+    }
+}
+

Programmierung2/src/GUIAnwendungen/jbutton.java

@@ -0,0 +1,95 @@
+package GUIAnwendungen;
+import java.awt.Color;
+import java.awt.Font;
+
+import javax.swing.BorderFactory;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.border.Border;
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+/*
+ * - ActionListener ist ein (marker)Interface Klasse,
+ *   die nur eine abstrakte Methode hat, die mit drücken auf Button reagiert
+ * 
+ * Also Das Kochrezept: 
+ * 1. Button erstellen: JButton button = new JButton("Text");
+ * 2. ActionListener implementieren: Implementiere ActionListener, um die Funktionalität zu definieren.
+ * 3. ActionListener zum Button hinzufügen:
+ * 		3.1 button.addActionListener(new ActionListener() { ... });
+ * 		3.2 oder mit separater Methode: button.addActionListener(e -> deineMethode());
+ */
+public class jbutton implements ActionListener  {
+
+	public static void main(String[] args) {
+		//1. 
+		JButton button = new JButton();
+					   // x   y  width height
+		button.setBounds(100,100,200,  50);
+		button.setText("Click me");
+		button.addActionListener(null);
+
+		 // 2. Hinzufügen des ActionListeners zum Button
+		JLabel label = new JLabel();
+		
+		/*
+		 * Position und Größe des Labels eingeben warum?
+		 * weil ich frame.setLayout(null); aktiviert habe
+		 */
+        label.setBounds(150, 50, 100, 50); 
+        /*
+         * new ActionListener() ist nicht das Erzeugen einer Instanz des Interfaces selbst, 
+         * sondern das Erstellen einer Instanz einer anonymen Klasse, die das ActionListener-Interface implementiert.
+         */
+        button.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                // Dies ist die Aktion, die ausgeführt wird, wenn der Button geklickt wird
+            	clicked(label);
+            }
+        });
+        
+        
+       
+		
+		// Erstelle ein Fenster
+		JFrame frame = new JFrame();
+		
+		//stellt sicher, dass keine automatische Positionierung und Größenanpassung erhalten
+		frame.setLayout(null);
+		
+		// setSize(width, height)
+		frame.setSize(750, 750);
+
+		// setzte einen Überschrift für mein Fenster
+		frame.setTitle("Mein erstes Fenster");
+		
+		//setVisible(boolean): gibt an, ob mein Fenster sichtbar ist oder nicht
+		frame.setVisible(true);
+		frame.add(label);
+		frame.add(button);
+		// andere Möglichkeit, button auf Fenster zu zeigen
+		// frame.add(new JButton("name"))
+		
+		
+	}
+	
+	
+	public static void clicked(JLabel label) {
+		label.setText("Hall Welt");
+	}
+
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		// TODO Auto-generated method stub
+		
+	}
+	
+	
+}

Programmierung2/src/JunitTest/Einführung.java

@@ -0,0 +1,16 @@
+package JunitTest;
+
+public class Einführung {
+	/*White-Box && Black-Box was ist das?
+	 * - Black-Box-Test: Du prüfst nur die Eingaben und Ausgaben, ohne den Code zu sehen oder zu verstehen. Es geht nur darum, ob die Software das Richtige tut.
+	 * - White-Box-Test: Du schaust dir den Code genau an und prüfst, ob jede Zeile und jedes Detail korrekt funktioniert. Hier verstehst du den Code und testest ihn gezielt.
+	 */
+	public static void main(String[] args) {
+
+	}
+	
+	public int add(int a, int b) {
+		return a+b;
+	}
+
+}

Programmierung2/src/JunitTest/EinführungTest.java

@@ -0,0 +1,14 @@
+package JunitTest;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class EinführungTest {
+
+    @Test
+    public void testAdd() {
+        Einführung e1 = new Einführung();
+        assertEquals(4, e1.add(2, 2));
+    }
+}

Programmierung2/src/Linked_List/ElementList.java

@@ -0,0 +1,82 @@
+package Linked_List;
+
+public class ElementList {
+	Node head;
+	
+	// ADD Methoden
+	public void addAtIndex(int value, int index) {
+		// Erstelle eine neue Knote
+		Node newNode = new Node();
+		// setze drin einen Wert
+		newNode.value = value;
+		// falls meine Liste leer ist!
+		if (head == null) {
+			head = newNode;
+			return;
+		}
+		
+		if (index == 0) {
+			newNode.next = head;
+			head = newNode;
+			return;
+		}
+		
+		Node temp = head;
+		for (int i = 0; i < index - 1 && temp.next != null ; i++) 
+			temp = temp.next;
+		
+		newNode.next = temp.next;
+		temp.next = newNode;
+	}
+	public void addLast(int value) {
+		// Erstelle eine neue Knote
+		Node newNode = new Node();
+		// setze drin einen Wert
+		newNode.value = value;
+		// falls meine Liste leer ist!
+		if (head == null) {
+			head = newNode;
+			return;
+		}
+		// falls nicht!
+		Node temp = head;
+		while (temp.next != null)
+			temp = temp.next;
+
+		temp.next = newNode;	
+	}
+	public void addFirst(int value) {
+		// Erstelle eine neue Knote
+		Node newNode = new Node();
+		// setze drin einen Wert
+		newNode.value = value;
+		
+		if (head == null)
+			head = newNode;
+		
+		/*
+		 * newNode.next = null, aber ist jetzt nicht mehr null,
+		 * weil es jetzt gleich head;
+		 */
+		newNode.next = head;
+		head = newNode;
+			
+	}
+	//---------------------------------------------------
+	
+	
+	public void printList() {
+		if (head == null)
+			return;
+		
+		Node temp =head;
+		System.out.print("[");
+		while(temp != null) {
+			System.out.print(temp.value + " ");
+			temp = temp.next;
+		}
+		System.out.print("]");
+			
+	}
+
+}

Programmierung2/src/Linked_List/Node.java

@@ -0,0 +1,6 @@
+package Linked_List;
+
+public class Node {
+	int value;
+	Node next;
+}

Programmierung2/src/Linked_List/Test.java

@@ -0,0 +1,15 @@
+package Linked_List;
+
+public class Test {
+
+	public static void main(String[] args) {
+		ElementList e1 = new ElementList();
+		e1.addLast(1);
+		e1.addLast(2);
+		e1.addLast(3);
+		e1.addLast(5);
+		e1.addAtIndex(10,2);	
+		e1.printList();
+	}
+
+}

Programmierung2/src/MVC_Desighn/Person_Daten.java

@@ -0,0 +1,91 @@
+package MVC_Desighn;
+
+// Modell, oder domain
+public class Person_Daten {
+	private String name;
+	private int alter;
+	
+	public Person_Daten(String name, int alter) {
+		this.name = name;
+		setAlter(alter);
+	}
+	
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public int getAlter() {
+		return alter;
+	}
+	public void setAlter(int alter) {
+		if (alter > 18)
+			this.alter = alter;
+		else
+			System.out.println("Sie sind sehr jung");
+	}
+	
+	
+	@Override
+	public String toString() {
+		return "Person_Daten [name=" + name + ", alter=" + alter + "]";
+	}
+
+	public static void main(String[] args) {
+		
+		Person_Daten p1 = new Person_Daten("obai" , 22);
+		GUI_DatenView v1 = new GUI_DatenView();
+		
+		Controller_DatenPerson c1 = new Controller_DatenPerson(p1,v1);
+		
+		c1.updateView();
+		c1.setPersonName("omar");
+		c1.updateView();
+
+	}
+}
+
+
+
+//View oder GUI
+class GUI_DatenView {
+	
+	public void printDatenPerson(String name, int alter) {
+		System.out.println("GUI_DatenView [name=" + name + ", alter=" + alter + "]");
+	}
+
+}
+
+// Controller
+class Controller_DatenPerson{
+	Person_Daten modell;
+	GUI_DatenView view;
+	
+	public Controller_DatenPerson(Person_Daten modell, GUI_DatenView view) {
+		this.modell = modell;
+		this.view = view;
+	}
+	
+	public String getPersonName() {
+		return this.modell.getName();
+	}
+	
+	public void setPersonName(String name) {
+		modell.setName(name);
+	}
+	
+	public int getPersonAlter() {
+		return this.modell.getAlter();
+	}
+
+	public void updateView() {
+		
+		view.printDatenPerson(modell.getName(),modell.getAlter());
+	}
+	
+}
+
+
+
+

Programmierung2/src/MVC_Desighn/Person_GUI.java

@@ -0,0 +1,156 @@
+package MVC_Desighn;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JTextField;
+
+// modell
+class Person {
+    private String name;
+    private int age;
+
+    // Konstruktor
+    public Person(String name, int age) throws IllegalArgumentException {
+        this.setName(name);
+        this.setAge(age);
+    }
+
+    // Getter für Name
+    public String getName() {
+        return name;
+    }
+
+    // Setter für Name
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    // Getter für Alter
+    public int getAge() {
+        return age;
+    }
+
+    // Setter für Alter
+    public void setAge(int age) throws IllegalArgumentException {
+        if (age <= 18) {
+            throw new IllegalArgumentException("Das Alter muss größer als 18 sein.");
+        }
+        this.age = age;
+    }
+    
+    
+}
+
+//view
+public class Person_GUI {
+	private JFrame frame;
+	private JTextField nameTextField;
+	private JButton updateButton;
+	private JLabel nameLabel;
+	private JLabel ageLabel;
+
+	public Person_GUI() {
+        // Setup des Frames
+        frame = new JFrame("Person Details");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setSize(300, 200);
+        frame.setLayout(null);
+
+        // Name Label
+        nameLabel = new JLabel("Name:");
+        nameLabel.setBounds(10, 20, 80, 25);
+        frame.add(nameLabel);
+
+        // Age Label
+        ageLabel = new JLabel("Alter:");
+        ageLabel.setBounds(10, 50, 80, 25);
+        frame.add(ageLabel);
+
+        // Name Textfeld
+        nameTextField = new JTextField(20);
+        nameTextField.setBounds(100, 20, 165, 25);
+        frame.add(nameTextField);
+
+        // Update Button
+        updateButton = new JButton("Name ändern");
+        updateButton.setBounds(100, 80, 165, 25);
+        frame.add(updateButton);
+
+        // Frame sichtbar machen
+        frame.setVisible(true);
+    }
+
+	public String getNameInput() {
+		return nameTextField.getText();
+	}
+
+	public void setPersonDetails(String name, int age) {
+		nameLabel.setText("Name: " + name);
+		ageLabel.setText("Alter: " + age);
+	}
+
+	public void addUpdateButtonListener(ActionListener listener) {
+		updateButton.addActionListener(listener);
+	}
+	
+	public static void main(String[] args) {
+        
+        // Erstellen des Modells
+        Person model = new Person("Max Mustermann", 20);
+
+        // Erstellen der Ansicht
+        Person_GUI view = new MVC_Desighn.Person_GUI();
+
+        // Erstellen des Controllers
+        PersonController controller = new PersonController(model, view);
+
+  
+}
+}
+
+class PersonController {
+	private Person model;
+	private Person_GUI view;
+
+	public PersonController(Person model, Person_GUI view) {
+		this.model = model;
+		this.view = view;
+
+		// Initialisieren der View mit den aktuellen Modelldaten
+		this.view.setPersonDetails(model.getName(), model.getAge());
+
+		// Hinzufügen eines ActionListeners zum Button
+		this.view.addUpdateButtonListener(new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				String newName = view.getNameInput();
+				setPersonName(newName);
+				updateView();
+			}
+		});
+	}
+
+	public void setPersonName(String name) {
+		model.setName(name);
+	}
+
+	public String getPersonName() {
+		return model.getName();
+	}
+
+	public void setPersonAge(int age) {
+		model.setAge(age);
+	}
+
+	public int getPersonAge() {
+		return model.getAge();
+	}
+
+	public void updateView() {
+		view.setPersonDetails(model.getName(), model.getAge());
+	}
+}

Programmierung2/src/Teste/kopieArray.java

@@ -0,0 +1,22 @@
+package Teste;
+
+public class kopieArray {
+
+	public static void main(String[] args) {
+		/*
+		 * das ein falsches Verfahren, um ein Array in einem anderen Array
+		 * zu koopieren, in dem Fall kopieArray ist ein RefrenzVariable, die auf das selbe Array zeigt
+		 * also wir haben nur ein Array und auf diese Array zeigen zwei RefrenzVariable 
+		 */
+		int[] orgArray = {1,2,3,4,5};
+		int[] kopieArray = orgArray;
+		
+		/*
+		 * 	Richtige Kopie von Array
+		 */
+		int[] richtigeKopieArray = new int[orgArray.length];
+		for (int i = 0; i <orgArray.length; i++)
+			richtigeKopieArray[i] = orgArray[i];
+
+	}
+}

Programmierung2/src/module-info.java

@@ -0,0 +1,11 @@
+/**
+ * 
+ */
+/**
+ * 
+ */
+module Programmierung2 {
+	requires java.desktop;
+	requires org.junit.jupiter.api;
+	requires junit;
+}

Programmierung2/src/oop/Abstraction/Abstraction.java

@@ -0,0 +1,45 @@
+package oop.Abstraction;
+
+ public abstract class Abstraction {
+	
+	/*Was ist abstraction:Das Verbergen der internen Implementierung der (Methode, Funktion) 
+	 * und das Zeigen nur der Funktionalität für die Benutzer.
+	 * 
+	 * 
+	 * wie errecihen wir die Abstraktion?
+	 * 
+	 *  1. Abstract Class => not fully Abstraction 
+	 *  2. Interface => fully Abstraction 
+	 *  
+	 * -----------------------------------------
+	 * 
+	 * Die abstrakte Klasse:
+	 * 
+	 * Deklaration als abstract: Eine abstrakte Klasse muss mit dem Schlüsselwort abstract deklariert werden
+	 * abstrakte Klassen in Java müssen vererbt werden, damit ihre abstrakten Methoden implementiert werden können
+	 * Da abstrakte Klassen nicht instanziiert werden können (man kann also keine Objekte direkt von ihnen erstellen)
+	 * Die Abstrakte klasse kann eine Abstrakte methode haben aber soll nicht 
+	 * Die Abstrakte klasse können final methods haben
+	 * Die Abstrakte klasse können constructors und static methods haben
+	 * Setter und getter sind gültig	
+	 * 
+	 * - Die Unterklasse:
+	 * 		die nicht abstrakte Unterklassen muss alle abstrakte methoden implementieren!
+	 * 		die abstrakte Unterklassen muss nicht  alle abstrakte methoden implementieren! 
+	 *----------------------------------------
+	 *
+	 *Die abstrakte Methode:
+	 *warum Abstrakte Methods? damit jede Unterklasse diese Methoden implementiert
+	 *wenn wir eine abstrakte Methode erzeugen, soll ihre Klasse auch Abstrakt sein.
+	 *Abstrakte Methoden können von der abstrakten Klasse nicht implemntiert werden.
+	 *Abstrakte Methoden können nur von Unterklassen mit @Override implementiert werden.
+	 *Abstrakte Methoden können ohne und mit Rückabe wert sein.
+	 *Statiche und private Methodes können nicht abstrakt sein warum?
+	 *weil satatic und private gehören nur der Klasse
+	 */
+	
+	  protected abstract void fahre();
+	  public abstract int count();
+
+
+}

Programmierung2/src/oop/Abstraction/Auto.java

@@ -0,0 +1,25 @@
+package oop.Abstraction;
+
+public abstract class Auto {
+	
+	double  höhe;
+	double gewicht;
+	int anzahlDerRäder;
+	
+	
+	
+	public Auto(double höhe, double gewicht, int anzahlDerRäder) {
+		this.höhe = höhe;
+		this.gewicht = gewicht;
+		this.anzahlDerRäder = anzahlDerRäder;
+	}
+
+	abstract void autopilot(); //  automatischen Fahren 
+	
+	abstract void streamingService();
+	
+	abstract void parkingSensors();
+	
+
+
+}

Programmierung2/src/oop/Abstraction/Auto2.java

@@ -0,0 +1,19 @@
+package oop.Abstraction;
+
+
+public class Auto2 {
+	
+	  class Test{
+		
+		
+	}
+	  @FunctionalInterface
+	  public  interface Test2{
+		   int berechne(int a, int b);
+		  
+	  }
+	
+	
+	
+	
+}

Programmierung2/src/oop/Abstraction/Hatchback.java

@@ -0,0 +1,29 @@
+package oop.Abstraction;
+
+public class Hatchback extends Auto {
+
+	
+	public Hatchback(double höhe, double gewicht, int anzahlDerRäder) {
+		super(höhe, gewicht, anzahlDerRäder);
+	}
+
+	@Override
+	void autopilot() {
+		System.out.println(" Hatchback : autopilot");
+	}
+
+	@Override
+	void streamingService() {
+		System.out.println("Hatchback :  streamingService");
+		
+	}
+
+	@Override
+	void parkingSensors() {
+		System.out.println(" Hatchback :  parkingSensors");
+		
+	}
+	
+
+
+}

Programmierung2/src/oop/Abstraction/MarkerInterface.java

@@ -0,0 +1,6 @@
+package oop.Abstraction;
+
+public class MarkerInterface {
+    // Keine Methoden oder Konstanten
+
+}

Programmierung2/src/oop/Abstraction/NestedInterface.java

@@ -0,0 +1,14 @@
+package oop.Abstraction;
+
+public interface NestedInterface {
+	void test();
+	
+	interface InnerInterface  {
+		default void test2() {
+			
+			System.out.print("Innerinterface");
+		}
+		
+	}
+
+}

Programmierung2/src/oop/Abstraction/SUV.java

@@ -0,0 +1,29 @@
+package oop.Abstraction;
+
+public class SUV extends Auto {
+	
+	
+	
+	public SUV(double höhe, double gewicht, int anzahlDerRäder) {
+		super(höhe, gewicht, anzahlDerRäder);
+	}
+
+	@Override
+	void autopilot() {
+		System.out.println(" SUV :  autopilot");
+	}
+
+	@Override
+	void streamingService() {
+		System.out.println(" SUV : streamingService");
+		
+	}
+
+	@Override
+	void parkingSensors() {
+		System.out.println("SUV :  parkingSensors");
+		
+	}
+	
+
+}

Programmierung2/src/oop/Abstraction/Test.java

@@ -0,0 +1,12 @@
+package oop.Abstraction;
+
+public class Test {
+
+	public static void main(String[] args) {
+		
+		// Auto SUV1 = new Auto(); Verboten da die Auto Klasse Abstrakt ist!
+		// Auto SUV1 = new SUV(); das ist gültig
+		
+	}
+
+}

Programmierung2/src/oop/AnonymousInnerClass/AnonymousInnerClass.java

@@ -0,0 +1,27 @@
+package oop.AnonymousInnerClass;
+
+public class AnonymousInnerClass {
+	/*
+	 * - ist ohne Name definiert und werden direkt in der Instanziierung (manin Methode) erstellt.
+	 * - Verwendung: Sie werden verwendet,um Schnittstellen oder abstrakte Klassen zu implementieren 
+	 *   und deren Methoden zu überschreiben, ohne eine separate, benannte Klasse zu erstellen.
+	 * - kann entweder extends klasse oder implements interface aber (nicht beids gleichzeitig)
+	 * - ist für methoden und Konstruktoren
+	 * - Anonymous Inner Class können kein Konstruktoren haben, weil sie ohne Name sind!
+	 * - Anonymous kann mehreren Methoden überschreiben
+	 * - können über definiert werden, wo Klasseninstanzen benötigt werden
+	 * - die Methoden und die Variablen innerhalb der Anonymous sind nur innerhalb Anonymous sichtbar
+	 * 	 oder ich muss z.b anstatt (Konstruktor test  = new Konstruktor()) => var test  = new Konstruktor()
+	 *   das  ermöglicht mir die methoden und die Variable die in Anonymous in außen zu verweden
+	 * - anonyme innere Klassen können verschachtelt werden also in anonyme ein anonyme
+	 * - können keine statischen Variablen oder Methoden haben, das sie keinen Name haben
+	 * - Private Elemente sind erlaubt aber sind nur innerhalb der anonyme innere Klassen sichtbar
+	 *   
+	 *  Warum benötigen wir sowas?
+	 *  für Einmalige Verwendung: Sie sind ideal für einmalige Implementierungen, 
+	 *  wie z.B. Event-Handler, Callbacks oder Threads.
+	 *  
+	 *  
+	 */
+
+}

Programmierung2/src/oop/AnonymousInnerClass/Interface.java

@@ -0,0 +1,40 @@
+package oop.AnonymousInnerClass;
+
+public class Interface {
+	
+	public interface Showable{
+		
+		void print();
+	}
+	
+	// methode übernimmt ein Interface
+	static void display(Showable s) {
+		
+		s.print();
+	}
+	
+	public static void main (String[] args) {
+		// Anonymous Inner Class mit methode
+		display(new Showable() {
+			
+			@Override
+			public void print() {
+				System.out.print("von der Methode");
+			}
+		});
+				
+				
+		
+		// Anonymous Inner Class mit interface
+		Showable showable = new Showable() {
+			
+			@Override
+			public void print() {
+				
+				System.out.println("Hallo welt");
+			}
+		};
+		
+		showable.print();
+	}
+}

Programmierung2/src/oop/AnonymousInnerClass/Konstruktor.java

@@ -0,0 +1,83 @@
+package oop.AnonymousInnerClass;
+
+public class Konstruktor {
+	
+	public Konstruktor() {
+		System.out.println("das ist Konstruktor");
+	}
+	
+	// Methode enthält Anonymous Inner Class
+	public static void main() {
+		new Konstruktor() {
+			
+			public static void print() {
+				System.out.println("main methode");
+			}
+			
+			int x = 5;
+			@Override
+			public void testMethod() {
+				
+				System.out.println("main methode");
+			
+			}
+			
+			
+		};
+	}
+	
+	public void testMethod() {
+		
+		System.out.println("Das ist in der klasse");
+	}
+	
+	
+	 int x = 2;
+	
+	public static void main(String[] str) {
+		
+		// Konstruktor wird aufgerufen und aussgegeben
+		Konstruktor test  = new Konstruktor() {
+			
+			public void print() {
+				System.out.println("extra methode");
+				//x = 3; Änderung ist verboten
+			}
+			
+			int x = 5;
+			@Override
+			public void testMethod() {
+				
+				System.out.println("Das ist in der main" + x);
+				print();// innere Methode
+			}
+			
+			
+		};
+		
+		test.testMethod();
+		
+		// Konstruktor wird aufgerufen und aussgegeben
+				var test2  = new Konstruktor() {
+					
+					public static void print() {
+						System.out.println("extra methode");
+					}
+					
+					int x = 5;
+					@Override
+					public void testMethod() {
+						
+						System.out.println("Das ist in der main" + x);
+					
+					}
+					
+					
+				};
+				// aufruf der innere methode
+				//test2.print();
+				test2.main();
+		
+	}
+
+}

Programmierung2/src/oop/AnonymousInnerClass/RewardClass.java

@@ -0,0 +1,10 @@
+package oop.AnonymousInnerClass;
+
+public class RewardClass {
+	public void rewardMethode() {
+		
+		System.out.println("Deine Belohnung ist 10€.");
+	}
+	
+
+}

Programmierung2/src/oop/AnonymousInnerClass/Test.java

@@ -0,0 +1,35 @@
+package oop.AnonymousInnerClass;
+
+public class Test {
+	
+	public static void main(String[] args) {
+		
+		RewardClass mietarebiter1 = new RewardClass();
+		RewardClass mietarebiter2 = new RewardClass();
+		RewardClass mietarebiter3 = new RewardClass()
+		//  Anonymous Inner Class 
+		{	
+			
+			@Override
+			public void rewardMethode() {
+				
+				System.out.println("Deine Belohnung ist 20€.");
+			}
+		};
+		
+		mietarebiter1.rewardMethode();//Belohnung ist 10€
+		mietarebiter2.rewardMethode();//Belohnung ist 10€
+		
+		mietarebiter3.rewardMethode();//Belohnung ist 20€
+		
+		/* wenn ich für den dritten mietarebiter3 20€ statt 10€ geben möchte!
+		 * dann habe ich 2 möglichkeiten
+		 * 
+		 * 1. erben: ich kann eine Klasse erstellen die meine (RewardClass) erbt 
+		 *           und ihre Methode mit 20€ überschreibt!
+		 *           
+		 * 2.Anonymous Inner Class 
+		 */
+	}
+
+}

Programmierung2/src/oop/Aufgaben/BankKonto.java

@@ -0,0 +1,65 @@
+package oop.Aufgaben;
+
+public class BankKonto {
+	
+	private String name;
+	private double amount;
+	private int kontoNummer;
+	private static int counter = 1;
+	
+	public BankKonto() {
+		
+		
+	}
+	
+	
+	
+	public BankKonto( String name,double amount) {
+		this.kontoNummer = counter;
+		this.name = name;
+		this.amount = amount;
+		counter++;
+		bounus();
+		willkommen(this.name);
+		}
+	
+	
+	public static void willkommen(String n) {
+	
+		BankKonto b1 = new BankKonto();
+		b1.name = n;
+		System.out.println("Willkommen: " + b1.name);
+	}
+	
+	
+	public double bounus() {
+		
+		
+		return this.amount += 5;
+	}
+	
+	public void einzahlung(double wert) {
+		
+		this.amount += wert;
+		
+	}
+	
+	public void auszahlung(double wert) {
+		
+		if (wert <= this.amount)
+			this.amount -= wert;
+		else
+			System.out.println("Das Geld reicht nicht aus!");
+	}
+	
+	public void checkKonto() {
+		
+		System.out.println("Ihre Stand ist: " + this.amount);
+	}
+	
+	public String toString() {
+		
+		return "Kontoname = " + this.name + " nummer = " + kontoNummer + " Satand = " + this.amount; 
+	}
+
+}

Programmierung2/src/oop/Aufgaben/Kreis.java

@@ -0,0 +1,59 @@
+package oop.Aufgaben;
+
+public class Kreis {
+	
+	 private double radius;
+	 private String color;
+	
+	
+	 // Konstruktor mit zwei Parametern
+	    public Kreis(double radius, String color) {
+	        this.radius = radius;
+	        this.color = color;
+	    }
+
+	    // Konstruktor mit einem Parameter (radius), Standardfarbe wird zugewiesen
+	    public Kreis(double radius) {
+	    	this.radius = radius; // Standardfarbe ist "weiß"
+	    }
+	 
+	 
+	public void setRadius(double radius) {
+		
+		this.radius =radius ;//this (unterscheidet zwishcne Parameter und Attribute)
+	}
+	
+	public double getRadius() {
+		
+		return radius;
+	}
+	
+	public void setColor(String color) {
+		
+		this.color = color; // this (unterscheidet zwishcne Parameter und Attribute)
+	}
+	
+	public String getColor() {
+		
+		return color;
+	}
+	
+	
+	public double getFlaeche() {
+		
+		return radius * radius * Math.PI;
+	}
+	
+	public double getUmfang() {
+		
+		return 2 * radius * Math.PI;
+		
+	}
+	
+	public String toString() {
+		
+		return "Kreis:" + getFlaeche()  + " " + getUmfang() ;
+	}
+	
+
+}

Programmierung2/src/oop/Aufgaben/Mitarbeiter.java

@@ -0,0 +1,38 @@
+package oop.Aufgaben;
+
+public class Mitarbeiter {
+	
+	
+	private static int id = 0;
+	protected int idMitarbeiter; 
+	protected String name;
+	
+	
+	public Mitarbeiter() {
+	
+	}
+	
+	public Mitarbeiter(String name) {
+		this.idMitarbeiter = ++id;
+		this.name = name;
+		
+	}
+	
+	public void setName(String name) {
+		
+		 this.name = name;
+	}
+	
+	public String getName() {
+		
+		return this.name;
+	}
+	
+	
+	public String toString() {
+		
+		return "ID: " + id + " Name: " + this.name;
+	}
+	
+
+}

Programmierung2/src/oop/Aufgaben/Personalverwaltung.java

@@ -0,0 +1,32 @@
+package oop.Aufgaben;
+
+import java.util.ArrayList;
+
+public class Personalverwaltung {
+	
+	ArrayList<Mitarbeiter> mitarbeiterliste = new ArrayList<Mitarbeiter>();
+
+	
+	
+	public void add(Mitarbeiter mitarbeiter) {
+		
+		mitarbeiterliste.add(mitarbeiter);
+	}
+	
+	
+	public void remove(Mitarbeiter mitarbeiter) {
+		
+		mitarbeiterliste.remove(mitarbeiter);
+	}
+	
+	
+	
+
+	public void listMitarbeiter(){
+		
+		 for (Mitarbeiter mitarbeiter : mitarbeiterliste) {
+	            System.out.println(mitarbeiter);
+	        }
+	}
+
+}

Programmierung2/src/oop/Einführung/Einführung.java

@@ -0,0 +1,31 @@
+package oop.Einführung;
+
+public class Einführung {
+	
+	String name;
+	int maxSpeed;
+	double price;
+	int model;
+	
+	
+	void setName(String n) {
+		 name = n;
+	}
+	
+	String getName() {
+		
+		return name;
+	}
+	
+	void setModel(int mod) {
+		if (mod >= 2016)
+			model = mod;
+		else
+			System.out.println("Nei geht nicht!");
+	}
+	
+	int getModel() {
+		
+		return model;
+	}
+}

Programmierung2/src/oop/Enumeration/EnumMethods.java

@@ -0,0 +1,65 @@
+package oop.Enumeration;
+import java.util.EnumSet;
+
+public enum EnumMethods {
+	MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG;
+	
+	
+	
+	public static void main(String[] args) {
+		// gibt mir die Index meiner Konstante zurück
+		System.out.println(EnumMethods.DIENSTAG.ordinal());
+		
+		//vergleicht zwei enum-Konstanten basierend auf ihrer Reihenfolge
+		System.out.println(EnumMethods.DIENSTAG.compareTo(EnumMethods.DONNERSTAG));
+		
+		// gibt true oder false zurück 
+		System.out.println(EnumMethods.DIENSTAG.toString() == "DIENSTAG");
+		
+		// gibt true oder false zurück 
+		System.out.println(EnumMethods.DIENSTAG.name() == "DIENSTAG");
+		
+		// gibt der Name der Kosntant zurück
+		System.out.println(EnumMethods.valueOf("DONNERSTAG"));
+		
+		// gibt mir alle Konstante zurück
+		for (EnumMethods test: EnumMethods.values()) {
+			System.out.print(test + " ");
+			if (test == EnumMethods.DIENSTAG)
+				System.out.print(EnumMethods.values() + " ");
+		}
+		System.out.println(EnumMethods.values()[0] + "Einzelene Konstant");
+		
+		System.out.println();
+		
+		/*
+		 * Enumset::
+		 */
+		
+		// gibt alle Werte die enums aus
+		EnumSet<EnumMethods> days = EnumSet.allOf(EnumMethods.class);
+		System.out.println(days);
+		
+		// gibt nur Werte ,die ich eingebe
+		EnumSet<EnumMethods> day = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.FREITAG);
+		System.out.println(day);
+		
+		// gibt nur einmal Diesntag aus!
+		EnumSet<EnumMethods> day1 = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.DIENSTAG);
+		System.out.println(day);
+		
+		// gibt mir von Konstante to Kosntnate zurück!
+		EnumSet<EnumMethods> range = EnumSet.range(EnumMethods.DIENSTAG, EnumMethods.FREITAG);
+		System.out.println(range);
+		
+		
+		EnumSet<EnumMethods> noneOf = EnumSet.noneOf(EnumMethods.class);
+		noneOf.add(DIENSTAG);
+		noneOf.addAll(noneOf);
+		noneOf.remove(DIENSTAG);
+		noneOf.removeAll(noneOf);
+		System.out.println(noneOf);
+	
+	}
+
+}

Programmierung2/src/oop/Enumeration/Enumeration.java

@@ -0,0 +1,23 @@
+package oop.Enumeration;
+
+public class Enumeration  {
+	
+	/*Enum was ist?
+	 * - repräsentiert eine Gruppe von Konstanten
+	 *   ,die public, static und final sind und die immer großegeschrieben werden sollen
+	 * - Deklariert mit dem Schlüsselwort enum z.b(public enum klassenname)
+	 * - Jede Konstante wird durch Kommas getrennt und am Ende optional mit einem Semikolon abgeschlossen.
+	 * - kann als Datentyp verwendet werden
+	 * - Kann in switch-Anweisungen verwendet werden.
+	 * - kann Felder, Konstruktoren (ohne public) und Methoden enthalten.
+	 * - Konstruktoren sind immer privat oder paketprivat (d.h. sie können nicht public sein)
+	 *   ,die Dienen zur Initialisierung der Felder.
+	 * - Enums können abstrakte Methoden enthalten, aber es sollen alle Kosntanten sie implementieren (siehe Wochentage class).
+	 * - Enums können Interfaces implementieren.
+	 * - Enums können eigene Methoden und Überschreibungen von toString(), equals(), hashCode(), etc. enthalten.
+	 * - Enums können keine anderen Klassen erweitern und auch nicht von anderen Klassen erben
+	 * - Enums können interface implementieren
+	 * 
+	 */
+
+}

Programmierung2/src/oop/Enumeration/Numbers.java

@@ -0,0 +1,28 @@
+package oop.Enumeration;
+
+public  enum Numbers{
+	
+	ONE,TWO,THREE; // Semikolon ist optional
+	
+	/*
+	 * ONE TOW THREE sind Objekte in die unten stehenden Klassen
+	 * Konstante ONE wir präsentiert durch:
+	 * Class Numbers{
+	 * 		public static final Numbers ONE = new Numbers();
+	 * }
+	 * 
+	 * und TWO auch so..
+	 * Class Numbers{
+	 * 		public static final Numbers TWO = new Numbers();
+	 * }
+	 * und THREE auch so..
+	 * 
+	 */
+	
+	
+	public void print() {
+		
+		System.out.println("dasd");
+	}
+
+}

Programmierung2/src/oop/Enumeration/Order.java

@@ -0,0 +1,37 @@
+package oop.Enumeration;
+
+public class Order {
+	
+	public enum OrderStatus{
+		
+		PENDING,
+		PREPARING,
+		COMPLETED,
+		DELIVERING,
+		CANCELED;
+	}
+	
+	
+	
+	// Attribute mit enum Objekt
+	private OrderStatus status;
+	
+	public boolean check() {
+		
+		if (getStatus() == status.COMPLETED)
+			return true;
+		
+		return false;
+	}
+
+	public OrderStatus getStatus() {
+		return status;
+	}
+
+	public void setStatus(OrderStatus status) {
+		this.status = status;
+	}
+	
+	
+
+}

Programmierung2/src/oop/Enumeration/OrderTest.java

@@ -0,0 +1,17 @@
+package oop.Enumeration;
+
+public class OrderTest {
+
+	public static void main(String[] args) {
+		//ordinal globale methode gibt mir die Index meiner enum Konstanten
+		System.out.println(Order.OrderStatus.CANCELED.ordinal());
+		
+		Order order1 = new Order();
+		order1.setStatus(Order.OrderStatus.DELIVERING);
+		System.out.println(order1.check());
+		// z.b für Tracking der bestellung 
+		System.out.print(order1.getStatus());
+		
+	}
+
+}

Programmierung2/src/oop/Enumeration/Test.java

@@ -0,0 +1,35 @@
+package oop.Enumeration;
+
+public class Test {
+
+	public static void main(String[] args) {
+		// Numbers val1 = new Numbers(); verboten da enum Konstruktoren private ist	
+										// und ONE automatisch static ist 
+		   Numbers val1 = Numbers.ONE; // TWO ist ein Objekt
+		   
+		   switch (val1) {
+		   
+		   case ONE: System.out.println("1");
+		   break;
+		   
+		   case TWO: System.out.println("2");
+		   break;
+		   
+		   case THREE: System.out.println("3");
+		   break;
+		   }
+		   
+		  val1.print();
+		  
+		  System.out.println(Wochentage.MONTAG.getStatus());
+		  Wochentage.MONTAG.testmethode();
+		  System.out.println(Wochentage.DIENSTAG.getStatus());
+		  Wochentage.DIENSTAG.testmethode();
+		  
+		  
+		 
+			
+			
+	}
+
+}

Programmierung2/src/oop/Enumeration/Wochentage.java

@@ -0,0 +1,41 @@
+package oop.Enumeration;
+
+public enum Wochentage {// erbt von abstract class (enum)
+	// wenn eine Konstante einen Konstruktor hat, dann sollen Alle Konstaten sollen einen Konstruktor haben 
+	 /*
+	  * 	MONTAG("Arbeitstag"), 
+	  *  	DIENSTAG("Arbeitstag");
+	  */
+	
+	// Alle Konstanten sollen die abstrakte Methoden implementieren
+	MONTAG ("Konstruktor: Montag") {
+		@Override
+		public void testmethode() {
+			System.out.println("Montag");
+		}
+		
+	},
+	DIENSTAG ("Konstruktor: Diesnstag"){
+		@Override
+		public void testmethode() {
+			System.out.println("Diesnstag");
+		}
+	};
+	String status;
+	
+	Wochentage(String status){
+		this.status = status;
+	}
+
+	public String getStatus() {
+		return status;
+	}
+
+	public void setStatus(String status) {
+		this.status = status;
+	}
+	
+	public abstract void testmethode();
+	
+	
+}

Programmierung2/src/oop/ExceptionHandling/CheckedException.java

@@ -0,0 +1,78 @@
+package oop.ExceptionHandling;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class CheckedException {
+
+	public static void main(String[] args) {
+		readFile("D:\\Test.txt");
+
+	}
+	
+	static void readFile(String filePath) {
+		FileReader reader = null;
+		// hier der Compiler zeigt mir eine Error und zwingt micht eine try-catch Block zu erstellen
+		try {
+			reader = new FileReader(filePath);// resource
+			System.out.println("File Inhalt: ");
+			
+			int r = 0;
+			while((r = reader.read()) != -1) {
+				System.out.print((char) r);
+			}
+		}catch(FileNotFoundException e) {
+			
+			System.out.println(e);
+			
+		}catch(IOException e) {
+			System.out.println(e);
+		}finally {
+			try {
+				reader.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	
+	// try() mit resources, hier benötigt man finally block nicht
+	static void readFile2(String filePath) {
+		try (FileReader reader = new FileReader(filePath);) {
+			System.out.println("File Inhalt: ");
+			
+			int r = 0;
+			while((r = reader.read()) != -1) {
+				System.out.print((char) r);
+			}
+		}catch(FileNotFoundException e) {
+			
+			System.out.println(e);
+			
+		}catch(IOException e) {
+			System.out.println(e);
+		}
+	}
+	
+	
+	
+	// try() mit mehrere resources, hier benötigt man auch finally block nicht
+		static void readFile3(String filePath) {
+			try (FileReader reader = new FileReader(filePath); FileReader reader2 = new FileReader(filePath)) {
+				System.out.println("File Inhalt: ");
+				
+				int r = 0;
+				while((r = reader.read()) != -1) {
+					System.out.print((char) r);
+				}
+			}catch(FileNotFoundException e) {
+				
+				System.out.println(e);
+				
+			}catch(IOException e) {
+				System.out.println(e);
+			}
+		}
+
+}

Programmierung2/src/oop/ExceptionHandling/ExceptionHandling.java

@@ -0,0 +1,102 @@
+package oop.ExceptionHandling;
+
+public class ExceptionHandling {
+	
+	/*Was ist das?
+	 * - Hauptidee ist, dass falls der Programmer oder der User einen Fehler gemacht hat, läuft das Programm trotzdem weiter!
+	 * - An exception ist ein unerwünschtes oder unerwartetes Ereignis
+	 *   ,das während der Ausführung eines Programms zur Laufzeit auftritt.
+	 * 
+	 * - wenn man nicht weiß, was der Fehler ist, kann man dan die Basis Klasse aufrufen (Exception)
+	 * 	 aber das wird langsamer als wenn ich den Fehler direkt schreibe
+	 * 
+	 * - unterstützt keine Methoden und Klasse
+	 * - kann nicht als Parameter innerhalb einer Methode verwendet werden
+	 * - kann aber innerhalb ale arten von Methoden geschrieben werden
+	 * 
+	 * was sid die checked und unchecked Exceptions?
+	 *  - checked: Compiler zwingt mich  ein try-catch Block zu erstellen und Sie erben von der Klasse Exception, aber nicht von RuntimeException.
+	 *  			wie z.b(IOException, SQLException, FileNotFoundException)
+	 *  - unchecked: Compiler zwingt mich nicht try-catch Block zu erstllen und  Sie erben nur von RuntimeException.
+	 *  			 wie z.b (ullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException)
+	 *  
+	 * welche Arten haben wir?
+	 * 1. NullPointerException: Zugriff auf null-Referenz.
+	 * 2. ArrayIndexOutOfBoundsException: Ungültiger Array-Indexzugriff.
+	 * 3. ClassCastException: Ungültige Typumwandlung
+	 * 4. ArithmeticException: Fehler in arithmetischer Operation (z.B. Division durch null).
+	 * 5. NumberFormatException: Fehlerhafte Zahlumwandlung.
+	 * 6. IOException: Eingabe-/Ausgabefehler.
+	 * 7. FileNotFoundException: Datei nicht gefunden.
+	 * 8. SQLException: Fehler in der Datenbankoperation.
+	 * 9. IllegalArgumentException: Ungültiges Argument übergeben.
+	 * etc...
+	 */
+	
+	
+	/*
+	 * Try-catch block: 
+	 * 
+	 * try{
+	 * 	- m try-Block wird der Code geschrieben, 
+	 * 	  der möglicherweise einen Fehler verursachen könnte.
+	 * 
+	 * }catch(Exception e){
+	 * - Was passieren soll, wenn ein Fehler auftritt?
+	 * - Exception:ist die Basisklasse für alle Ausnahmen, die das Programm möglicherweise behandeln sollte. 
+	 * 				wie z.b(IOException),SQLException,NullPointerException sind unterklasse von Exception
+	 * - e: ist ist ein belibeger Name eines Objektes 
+	 * 
+	 * - man kann try in ein try erzeugen
+	 * }
+	 */
+	public static void main(String[] args) {
+		
+		//Try-catch block beispiel
+		try {
+			int[] arr = new int[] {1,2,3};
+			System.out.println(arr[4]);
+		}catch(Exception e) {
+			//entweder
+			System.out.println("das ist ungültig");
+			//oder
+			System.out.println(e);
+			//oder
+			System.out.println(e + "das ist ungültig");
+		}
+		// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
+		System.out.println("1");
+		
+		
+		//Try-catch block mit NullPointerException (ist eine klasse) beispiel
+		//also Objekt ist leer!
+		try {
+			int[] arr = null;
+			System.out.println(arr[4]);
+		}catch(Exception e) {
+			
+			System.out.println(e.toString());
+		}
+		// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
+		System.out.println("1");
+		
+		
+		//Try-catch block mit NumberForamtEception (ist eine klasse) beispiel
+		try {
+			System.out.println("haöö");// die wird ausgegeben
+			int val = Integer.parseInt("String23");
+			System.out.println(val);
+			System.out.println("haöö");// die wird nicht ausgegeben
+		}catch(Exception e) {
+					
+			System.out.println(e.toString());
+		}
+		// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
+		System.out.println("1");
+				
+	
+		
+	}
+	
+
+}

Programmierung2/src/oop/ExceptionHandling/Finally.java

@@ -0,0 +1,58 @@
+package oop.ExceptionHandling;
+
+public class Finally {
+
+	public static void main(String[] args) {
+		/*
+		 * Wenn ein Programmfehler auftaucht, springe in catch Block gib den Fehler aus und laufe nicht weiter
+		 * und am Ende gib finally Block aus!
+		 */
+		try {
+			int arr[] = new int[5];
+			arr[7] = 5;
+			
+		}catch(Exception e) {
+			
+			System.out.println(e);
+			return;
+		
+		}finally {
+			System.out.println("finally");
+		}
+		
+		
+		/*
+		 * wegen System.exit in catch wird finally Block nicht ausgegenen
+		 */
+		try {
+			int arr[] = new int[5];
+			arr[7] = 5;
+			
+		}catch(Exception e) {
+			
+			System.out.println(e);
+			System.exit(0);
+		
+		}finally {
+			System.out.println("finally");
+		}
+		//System.out.println(getNumber(3));
+		
+		
+	}
+	
+	// hier wir die 3 ausgegben, weil finally soll ausgegeben werden
+	public static int getNumber(int x) {
+		
+		try {
+			if (x == 3)
+				return 1;
+			
+		}catch (Exception e){
+			return 2;
+			
+		}finally {
+			return 3;
+		}
+	}
+}

Programmierung2/src/oop/ExceptionHandling/MultiCatchBlocks.java

@@ -0,0 +1,16 @@
+package oop.ExceptionHandling;
+
+public class MultiCatchBlocks {
+	
+	public static void main(String[] args) {
+		try {
+			int arr[] = new int[5];
+			arr[10] = 7/0;
+		}
+		catch(ArrayIndexOutOfBoundsException|java.lang.ArithmeticException  ex) {
+			System.out.println(ex);
+		}
+	}
+	
+
+}

Programmierung2/src/oop/ExceptionHandling/Throwkeyword.java

@@ -0,0 +1,44 @@
+package oop.ExceptionHandling;
+
+public class Throwkeyword {
+	
+	public static void main(String[] args) {
+		// hier try und catch sind optional
+		try {
+			number(-1);
+		}catch (Exception e){
+			System.out.println("die Zahl ist negativ");
+		}
+		
+		/*
+		 *  in diesem try verfachen hier, wird das Block finally 
+		 *  erst ausgeführt, before das Block catch mit throw
+		 */
+		try {
+			int x = 5/0;
+			
+		}catch(Exception e) {
+			throw new ArithmeticException("neu throw");
+			
+		}finally{
+			System.out.println("finally Block");
+		}
+		
+		
+		
+	}
+	
+	//throws Exception ist hier optional
+	static void number(int number) throws Exception {
+		
+		if (number <= 0) {
+			//throw new ArithmeticException();Oder
+			//throw new ArithmeticException("das geht nicht");oder
+			ArithmeticException message = new ArithmeticException("die Zahl geht nicht");
+			throw message;
+		}
+			
+		else
+			System.out.println("Die Zahl ist richtig");
+	}
+}

Programmierung2/src/oop/ExceptionHandling/ThrowsKeyword.java

@@ -0,0 +1,39 @@
+package oop.ExceptionHandling;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class ThrowsKeyword {
+	/*
+	 * - Wenn der Programmiere weiß, wie er mit den Fehlern umgehen kann.
+	 * - zwingt jeder, der solche Methoden implementiert, throws zu behandeln
+	 */
+		public static void main(String[] args) {
+			/*
+			 *  da ich in readFile Methode throws verwendet habe
+			 *  ,soll ich hier z.b try catch erzeugen
+			 */
+			try {
+				readFile("D:\\Test.txt");
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+	
+		}
+	
+		public static void readFile(String File) throws FileNotFoundException, IOException{
+			FileReader reader = new FileReader(File);// resource
+			System.out.println("File Inhalt: ");
+			
+			int r = 0;
+			while((r = reader.read()) != -1) {
+				System.out.print((char) r);
+		}
+		
+	}
+}

Programmierung2/src/oop/ExceptionHandling/UnCheckedException.java

@@ -0,0 +1,23 @@
+package oop.ExceptionHandling;
+
+public class UnCheckedException {
+	
+	public static void main(String[] args) {
+		/*
+		 * - Solche Errors kann man nicht mit try und Catch behandeln also sie sind  keine gute Praxis
+		 * - try und catch werden den Error nicht lösen
+		 */
+		try {
+			f();
+		}catch (Error e) {
+			System.out.println(e);//java.lang.StackOverflowError
+		}
+		
+	}
+	
+	// Die Methode ruft sich bis unendlich
+	static void f() {
+		System.out.println("f()");
+		f();
+	}
+}

Programmierung2/src/oop/FileHandling/ByteKlassen/Fileinputstream.java

@@ -0,0 +1,57 @@
+package oop.FileHandling.ByteKlassen;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+//also ich habe daten auf meinm File und ich will diese Datein lesen oder importieren
+// man kann heir mit Text bearbeiten aber es ist nicht dafür richtig alternative Möglichkeit (die abstrakte klasse reader und Writer)
+public class Fileinputstream {
+	
+	/*read() Methode:
+	 * - fis.read liest aus dem File nur ein Byte aus und gibt ein Integer zurück
+	 * - z.b a liest als (97) lösung als (char) casting
+	 * - wenn die Methode keinen Byte lesen kann, gibt -1 zurück
+	 * 
+	 *read(byte [] b) Method: 
+	 *	- die übernimmt array vom type byte
+	 */
+
+	public static  void main(String[] args) throws IOException {
+		 FileInputStream fis = null;
+		 fis = new FileInputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
+		 	{
+			 // das ist falsch, weil ich die Aufruf der Methode ist falsch
+			 while (fis.read() != -1)
+				System.out.print((char)fis.read());			 
+		 }
+		
+		 
+		 //richtig!!
+		 int data;
+		 while((data = fis.read()) != -1)// wenn kein mehr chars gibt, ist -1
+			 System.out.print((char)data);
+		 
+		 {
+			 // read() übernimmt ein byte array
+			 byte[] b = new byte[3]; // byte array
+			 fis.read(b);// methode übernimmt byte array
+			 String s = new String(b);//mit diesem Konstruktor gebe ich alle Inhalt aus ohne Loop
+			 System.out.println(s);
+		 }
+		
+		 
+		 
+		 {
+			// read() übernimmt ein byte array mit dynamischen size für array
+			File f = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
+			FileInputStream f2 = new FileInputStream(f);
+			byte[] b = new byte[(int) f.length()]; //Methode gibt long zurück size soll aber int sein
+			fis.read(b);// methode übernimmt byte array
+			String s = new String(b);//mit diesem Konstruktor gebe ich alle Inhalte aus (ohne Loop)
+			System.out.println(s);
+		 }
+		 
+		 
+		
+	}
+}

Programmierung2/src/oop/FileHandling/ByteKlassen/Filoutputstream.java

@@ -0,0 +1,33 @@
+package oop.FileHandling.ByteKlassen;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+//also ich habe datein in meine Programm und ich will diese Datein zu meinem File schicken also (schreiben)
+//man kann heir mit Text bearbeiten aber es ist nicht dafür richtig alternative Möglichkeit (die abstrakte klasse reader und Writer)
+
+public class Filoutputstream  {
+	
+	/*write() methode: 
+	 * - die übernimmt nur (integer) zahlen
+	 * - kann Strings mit Hilfe von byte array aufnehmen
+	 *   z.b fSchreiben.write("ABF".getBytes());
+	 * - fSchreiben.write("arabische sprache".getBytes()("UTF-8")); um andere Sprachen aufzunehmen 
+	 * - fSchreiben.flush(); stellt sicher, dass die Datein richtig geschrieben werden
+	 * 
+	 */
+	public static void main(String[] args) throws IOException {
+		// hier wenn er den File (Test2) nicht findet, erzeugt er File mit dem Name Test2 automatisch
+		FileOutputStream fSchreiben = new FileOutputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test2");
+		//fSchreiben.write(10);
+		fSchreiben.write("ä".getBytes());
+		fSchreiben.flush();
+		
+		//lesen der Datei
+		FileInputStream fLesen = new FileInputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test2");
+		System.out.println((char)fLesen.read());
+	}
+	
+
+}

Programmierung2/src/oop/FileHandling/ByteKlassen/LeseEinBild.java

@@ -0,0 +1,33 @@
+package oop.FileHandling.ByteKlassen;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+public class LeseEinBild {
+
+	public static void main(String[] args) throws IOException {
+		//gibt mit die gesamte size vom byte meine Bildes
+		File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling");
+		
+		FileInputStream fin = new FileInputStream(file);
+		byte b[] = new byte[(int) file.length()];
+		fin.read(b);
+		
+		//Optional loop
+		for (int i = 0; i < b.length; i++)
+			System.out.print(b[i]);
+	
+		
+		/*
+		 * - erstellt mir eine neues Bild mit dem Name (neues Bild)
+		 * - dieses Verfahren kann mit allen Arten von Byts verwendet werden
+		 */
+		FileOutputStream fos = new FileOutputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\neues Bild.png");
+		fos.write(b);
+		fos.flush();
+		fos.close();
+		
+		
+	}
+
+}

Programmierung2/src/oop/FileHandling/ByteKlassen/Test

@@ -0,0 +1 @@
+abc

Programmierung2/src/oop/FileHandling/ByteKlassen/Test2

@@ -0,0 +1 @@
+ä

Programmierung2/src/oop/FileHandling/FileHandling.java

@@ -0,0 +1,39 @@
+package oop.FileHandling;
+
+public class FileHandling {
+	/*
+	 * - bezieht sich auf das Arbeiten mit Dateien und Verzeichnissen, einschließlich Erstellen, Lesen, 
+	 *   Schreiben, Bearbeiten und Löschen.
+	 * - die Kommunikation zwischen File und Programm  heißt (stream)
+	 * - Programm liest (Read) aus dem File (Input stream)
+	 * - Programm schreibt (Write) oder (speichert) auf dem File (output Stream)
+	 * - Es gibt ein eingine Stream für Lesen
+	 * - Es gibt ein eingine Stream für schreiben
+	 * - man kann das easy in Konstruktor als parameter und methode als parameter machen oder drin 
+	 * 
+	 * - FileInputStream und FileOutPutStream sind für File Texte nicht geeignet, 
+	 * 	 alternativ möglichkeit die abstrakte Klassen Reader und Writer 
+	 * - Hinweis: Die abstrakte Klasse Reader liest Zeichen für Zeichen und ruft die Methode read() jedes Mal auf, wenn ein neues Zeichen gelesen wird.
+	 * 		Wenn wir z.B. 10 Zeichen lesen möchten, wird die Methode read() 10 Mal aufgerufen.
+ 	 * 		
+ 	 * 		Alternative Möglichkeit: Die Klasse BufferedReader kann verwendet werden, um ganze Zeilen oder größere Blöcke von Zeichen auf einmal zu lesen,
+ 	 * 		was effizienter sein kann, da sie den Lesevorgang puffert und somit weniger oft auf die zugrunde liegende Datenquelle zugreift.
+ 	 * - printWriter ist für alle Datentyps  gut geeinigt (kann nur schreiben auf dem File)
+ 	 * - Scanner ist für alle Datentyps gut geeinigt (kann nur lesen auf dem File)
+ 	 * - flush() soll aufgerufen werden
+ 	 * - BufferReader ist besser als Scanner
+ 	 * 
+ 	 * Objekte einer Klasse können auch auf dem File gelesen und geschriben werden:
+ 	 * 
+ 	 * - Serialization: ist eine (marker) lerre interface Klasse, die implemntiert werden soll
+ 	 * 					, wenn wir das Objekt auf einem File schreiben möchten
+ 	 * 
+ 	 * 1. Serialization (Objekt schreiben): Ist ein Mechanismus zur Umwandlung eines Objekts in einen Byte-Stream,
+ 	 * 					  der dann in einer Datei gespeichert werden kann. Dies wird durch die Klasse ObjectOutputStream ermöglicht.
+ 	 * 
+ 	 * 2. Deserialization (Objekt lesen): Ist ein Mechanismus zur Umwandlung eines Byte-Streams zurück in ein Objekt.
+ 	 * 										 Dies wird durch die Klasse ObjectInputStream ermöglicht.
+ 	 */			
+	
+
+}

Programmierung2/src/oop/FileHandling/FileKlasse.java

@@ -0,0 +1,64 @@
+package oop.FileHandling;
+import java.io.File;
+import java.io.IOException;
+// Hauptfunktion verwaltet Files 
+public class FileKlasse {
+	
+	/*Was macht diese Kalsse?
+	 * - abstrakte Darstellungen von Dateipfaden und Verzeichnissen zu bieten und verschiedene Operationen darauf zu ermöglichen
+	 * - sie befindet sich im Paket java.io
+	 * - stellt keine Methode zum direkten Lesen oder Schreiben von Daten bereit.
+	 * - Stattdessen bietet sie Funktionen zur Dateiverwaltung.
+	 */
+	public static void main(String[] args) {
+		 File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
+		 
+		 if (file.exists()) {
+			 	System.out.println("Datei existiert: " + file.getName());
+	            System.out.println("Pfad: " + file.getPath());
+	            System.out.println("Absoluter Pfad: " + file.getAbsolutePath());
+	            System.out.println("Schreibbar: " + file.canWrite());//ob der ich in der File schreiben kann
+	            System.out.println("Lesbar: " + file.canRead()); //ob der ich in File lesen kann
+	            System.out.println("Größe: " + file.length() + " Bytes");
+	            System.out.println("kann ausführen = " + file.canExecute()); //kann ich diesen Fiel bearbeiten (ja/nein)
+
+		 }
+		 // test3 File existiert nicht im Pfad also wird einen neuen Pfeil erstellt
+		 File file2 = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test3");
+		 // try catch sollen erzuegt werden
+		 try {
+             if (file.createNewFile())  // createNewFile() gibt boolean zurück,ob der File ergolgreich erstellt wurde oder nicht
+                 System.out.println("Datei erstellt: " + file.getName()); // der File muss im Pfad nicht existieren, damit es erstellt wurde
+             else 
+                 System.out.println("Fehler beim Erstellen der Datei.");
+             
+         } catch (IOException e) {
+             e.printStackTrace();
+         }
+		 
+		 // erstelle ein Verzeichnes 
+		 File folder = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\TestFolder");
+		  if (!folder.exists()) {
+	            if (folder.mkdir())
+	                System.out.println("Verzeichnis erstellt: " + folder.getName());
+	            else 
+	                System.out.println("Fehler beim Erstellen des Verzeichnisses.");
+	        }
+		  
+		  
+		  // gibt die Inhalt eines Folders zurück
+	        File dir2 = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\TestFolder");
+
+	        // Auflisten der Inhalte des Verzeichnisses mit Hilfe eines String arrays 
+	        String[] fileList = dir2.list();
+	        if (fileList != null) {
+	            System.out.println("Inhalte des Verzeichnisses:");
+	            for (String fileName : fileList) 
+	                System.out.println(fileName);
+	            
+	        } else 
+	            System.out.println("Das Verzeichnis ist leer oder konnte nicht aufgelistet werden.");
+	        
+    }
+		 		 
+}