Update

Programmierung2/src/Algorithmus/Allgemeine_Übungen.java

@@ -1,55 +1,61 @@
-package Algorithmus;
-
-import java.util.Arrays;
-import java.util.stream.Stream;
-
-public class Allgemeine_Übungen {
-
-	public static void main(String[] args) {
-//		int [] nums = {3, 4, -7, 3, 1, 3, 1, -4, -2, -2};
-//		subarraysWith0Sum(nums);
-		String str = "Hallo dies ist ein Test";
-		String[] worte = str.split(" "); 
-		
-		Stream<String> stream = Arrays.stream(worte);
-		stream
-		.map(String::toUpperCase)
-		.filter(w -> w.startsWith("H") )
-		.forEach(System.out::println);
-		
-		
-//		grossmacher("");
-	}
-	
-	public static void grossmacher(String str) {
-		
-		System.out.println("Ergebnis: " + str.toUpperCase() + "\nZeichen: " + str.length());
-		
-	}
-
-	public static void subarraysWith0Sum(int[] arr) {
-		int sum = 0;
-
-		for (int i = 0; i < arr.length; i++) {
-			sum = 0;
-			for (int j = i; j < arr.length; j++) {
-				sum += arr[j];
-				if (sum == 0)
-					System.out.println("subarray: " + arr[i] + " .... " + arr[j]);
-
-			}
-		}
-	}
-
-	public static void findApair(int[] arr, int target) {
-
-		for (int i = 0; i < arr.length - 1; i++)
-			for (int j = i + 1; j < arr.length - 1; j++)
-				if (arr[i] + arr[j] == target) {
-					System.out.println("Pair found (" + arr[i] + " ," + arr[j] + ")");
-					break;
-				}
-
-	}
-
-}
+package Algorithmus;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+public class Allgemeine_Übungen {
+
+	public static void main(String[] args) {
+//		int [] nums = {3, 4, -7, 3, 1, 3, 1, -4, -2, -2};
+//		subarraysWith0Sum(nums);
+		String str = "Hallo dies ist ein Test";
+		String[] worte = str.split(" "); 
+		
+		Stream<String> stream = Arrays.stream(worte);
+		stream
+		.map(String::toUpperCase)
+		.filter(w -> w.startsWith("H") )
+		.forEach(System.out::println);
+		
+		String eins = "1";
+		int zahl = Integer.parseInt(eins);
+		// zahl = (int) eins; compieler Fehler
+		
+		
+		System.out.println(zahl);
+		
+//		grossmacher("");
+	}
+	
+	public static void grossmacher(String str) {
+		
+		System.out.println("Ergebnis: " + str.toUpperCase() + "\nZeichen: " + str.length());
+		
+	}
+
+	public static void subarraysWith0Sum(int[] arr) {
+		int sum = 0;
+
+		for (int i = 0; i < arr.length; i++) {
+			sum = 0;
+			for (int j = i; j < arr.length; j++) {
+				sum += arr[j];
+				if (sum == 0)
+					System.out.println("subarray: " + arr[i] + " .... " + arr[j]);
+
+			}
+		}
+	}
+
+	public static void findApair(int[] arr, int target) {
+
+		for (int i = 0; i < arr.length - 1; i++)
+			for (int j = i + 1; j < arr.length - 1; j++)
+				if (arr[i] + arr[j] == target) {
+					System.out.println("Pair found (" + arr[i] + " ," + arr[j] + ")");
+					break;
+				}
+
+	}
+
+}

Programmierung2/src/Algorithmus/BitweisesOperatoren/AND.java

@@ -1,54 +1,53 @@
-package Algorithmus.BitweisesOperatoren;
-
-public class AND {
-	public static void main(String[] args) {
-		/*
-		 * Bitweises UND (&): - Funktion: Der & Operator prüft beide Operanden bitweise
-		 * 	und gibt true zurück, wenn beide Operanden true sind (bei logischen Ausdrücken).
-		 * 
-		 * - Merkmal: Beide Bedingungen (x und y) werden immer ausgewertet, unabhängig
-		 * 		davon, ob die erste Bedingung false ergibt.
-		 * 
-		 * - Hinweis: Der & Operator kann auch bitweise verwendet werden, um die Bits
-		 * 		zweier Ganzzahlen zu vergleichen.
-		 */
-
-		// 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 die Bedingung a
-		// > 5 false ist.
-		if ((b++ < 10) & a > 5)
-			System.out.println(a);
-
-		System.out.println(b); // b = 1
-
-		/*
-		 * Logisches UND (&&): - Funktion: Der && Operator prüft beide Operanden und
-		 * gibt true zurück, wenn beide true sind (bei logischen Ausdrücken).
-		 * 
-		 * - 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 (z. B. Division durch 0).
-		 */
-
-		// Praktischer Einsatz:
-		int a2 = 5;
-		int b2 = 0;
-
-		// Die zweite Bedingung wird nicht überprüft, weil a2 > 5 false ist. b2 wird
-		// daher nicht erhöht.
-		if (a2 > 5 && (b2++ < 10))
-			System.out.println(a2);
-
-		System.out.println(b2); // b = 0
-
-	}
-}
+package Algorithmus.BitweisesOperatoren;
+
+public class AND {
+	public static void main(String[] args) {
+		/*
+		 * Bitweises UND (&): - Funktion: Der & Operator prüft beide Operanden bitweise
+		 * 	und gibt true zurück, wenn beide Operanden true sind (bei logischen Ausdrücken).
+		 * 
+		 * - Merkmal: Beide Bedingungen (x und y) werden immer ausgewertet, unabhängig
+		 * 		davon, ob die erste Bedingung false ergibt.
+		 * 
+		 * - Hinweis: Der & Operator kann auch bitweise verwendet werden, um die Bits
+		 * 		zweier Ganzzahlen zu vergleichen.
+		 */
+
+		// 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 die Bedingung a > 5 false ist.
+		if ((b++ < 10) & a > 5)
+			System.out.println(a);
+
+		System.out.println(b); // b = 1
+
+		/*
+		 * Logisches UND (&&): - Funktion: Der && Operator prüft beide Operanden und
+		 * gibt true zurück, wenn beide true sind (bei logischen Ausdrücken).
+		 * 
+		 * - 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 (z. B. Division durch 0).
+		 */
+
+		// Praktischer Einsatz:
+		int a2 = 5;
+		int b2 = 0;
+
+		// Die zweite Bedingung wird nicht überprüft, weil a2 > 5 false ist. b2 wird
+		// daher nicht erhöht.
+		if (a2 > 5 && (b2++ < 10))
+			System.out.println(a2);
+
+		System.out.println(b2); // b = 0
+
+	}
+}

Programmierung2/src/Algorithmus/BitweisesOperatoren/NOT.java

@@ -1,45 +1,45 @@
-package Algorithmus.BitweisesOperatoren;
-
-public class NOT {
-	
-	public static void main(String[] args) {
-		/*
-		 * Bitweises NOT (~):
-		 * - Funktion: Der ~ Operator invertiert alle Bits einer Ganzzahl (bitweises NOT).
-		 * 
-		 * - Beispiel: Für eine Ganzzahl invertiert ~ jedes Bit. Bei einer positiven Zahl
-		 *   wird sie negativ (im Zweierkomplement), und bei einer negativen Zahl wird sie positiv.
-		 * 
-		 * - Hinweis: Bitweises NOT kann nur auf Ganzzahlen angewendet werden, nicht auf logische Werte (booleans).
-		 */
-
-		// Beispiel:
-		int x = 5;   // Binär: 00000000 00000000 00000000 00000101
-		int result = ~x;   // Binär: 11111111 11111111 11111111 11111010 (Das ist -6 im Zweierkomplement)
-
-		System.out.println(result); // Ausgabe: -6
-
-
-		/*
-		 * Logisches NOT (!):
-		 * - Funktion: Der ! Operator invertiert den logischen Wert eines Ausdrucks. 
-		 *   Wenn der Operand true ist, wird er false, und umgekehrt.
-		 * 
-		 * - Hinweis: Logisches NOT wird nur auf boolesche Werte angewendet (true/false).
-		 */
-
-		// Beispiel:
-		boolean y = true;
-		// Logisches NOT invertiert y, also wird !y false
-		boolean result2 = !y;
-
-		System.out.println(result2); // Ausgabe: false
-
-		// Praktischer Einsatz:
-		int a = 5;
-
-		// Die Bedingung a > 10 ist false, aber durch das logische NOT (!) wird sie true
-		if (!(a > 10))
-		    System.out.println("a ist nicht größer als 10");
-	}
-}
+package Algorithmus.BitweisesOperatoren;
+
+public class NOT {
+	
+	public static void main(String[] args) {
+		/*
+		 * Bitweises NOT (~):
+		 * - Funktion: Der ~ Operator invertiert alle Bits einer Ganzzahl (bitweises NOT).
+		 * 
+		 * - Beispiel: Für eine Ganzzahl invertiert ~ jedes Bit. Bei einer positiven Zahl
+		 *   wird sie negativ (im Zweierkomplement), und bei einer negativen Zahl wird sie positiv.
+		 * 
+		 * - Hinweis: Bitweises NOT kann nur auf Ganzzahlen angewendet werden, nicht auf logische Werte (booleans).
+		 */
+
+		// Beispiel:
+		int x = 5;   // Binär: 00000000 00000000 00000000 00000101
+		int result = ~x;   // Binär: 11111111 11111111 11111111 11111010 (Das ist -6 im Zweierkomplement)
+
+		System.out.println(result); // Ausgabe: -6
+
+
+		/*
+		 * Logisches NOT (!):
+		 * - Funktion: Der ! Operator invertiert den logischen Wert eines Ausdrucks. 
+		 *   Wenn der Operand true ist, wird er false, und umgekehrt.
+		 * 
+		 * - Hinweis: Logisches NOT wird nur auf boolesche Werte angewendet (true/false).
+		 */
+
+		// Beispiel:
+		boolean y = true;
+		// Logisches NOT invertiert y, also wird !y false
+		boolean result2 = !y;
+
+		System.out.println(result2); // Ausgabe: false
+
+		// Praktischer Einsatz:
+		int a = 5;
+
+		// Die Bedingung a > 10 ist false, aber durch das logische NOT (!) wird sie true
+		if (!(a > 10))
+		    System.out.println("a ist nicht größer als 10");
+	}
+}

Programmierung2/src/Algorithmus/MehrfachsVerebung.java

@@ -0,0 +1,12 @@
+package Algorithmus;
+
+public class MehrfachsVerebung {
+
+	public static void main(String[] args) {
+		
+		
+	}
+
+
+}
+

Programmierung2/src/Algorithmus/VariadischeFunktionen.java

@@ -1,17 +1,17 @@
-package Algorithmus;
-
-public class VariadischeFunktionen {
-
-	public static int sum(int... numbers) {
-		int result = 0;
-		for (int number : numbers) 
-			result += number;
-		
-		return result;
-	}
-
-	public static void main(String[] args) {
-		System.out.println(sum(1, 2, 3));
-	}
-
-}
+package Algorithmus;
+
+public class VariadischeFunktionen {
+
+	public static int sum(Integer... numbers) {
+		int result = 0;
+		for (int number : numbers) 
+			result += number;
+		
+		return result;
+	}
+
+	public static void main(String[] args) {
+		System.out.println(sum(1, 2, 3));
+	}
+
+}

Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Main.java

@@ -0,0 +1,89 @@
+package DesignPatterns.strukturellen_Entwurfsmustern.Composite;
+
+import java.util.*;
+
+// Gemeinsames Interface für alle Formen (Shape)
+interface Shape {
+    // Methode, um die Form zu zeichnen, implementiert von allen Formen
+    public void draw(String fillColor);
+}
+
+// Konkrete Implementierung der Shape-Schnittstelle: Dreieck
+class Triangle implements Shape {
+    @Override
+    public void draw(String fillColor) {
+        // Zeichne ein Dreieck mit der angegebenen Farbe
+        System.out.println("Zeichne Dreieck mit der Farbe " + fillColor);
+    }
+}
+
+// Konkrete Implementierung der Shape-Schnittstelle: Kreis
+class Circle implements Shape {
+    @Override
+    public void draw(String fillColor) {
+        // Zeichne einen Kreis mit der angegebenen Farbe
+        System.out.println("Zeichne Kreis mit der Farbe " + fillColor);
+    }
+}
+
+// Composite-Klasse, die mehrere Formen (Shapes) enthalten kann
+class Drawing implements Shape {
+
+    // Liste, um alle enthaltenen Formen (Shapes) zu speichern
+    private List<Shape> shapes = new ArrayList<>();
+
+    @Override
+    public void draw(String fillColor) {
+        // Iteriere durch alle gespeicherten Formen und zeichne sie
+        for (Shape shape : shapes) {
+            shape.draw(fillColor);
+        }
+    }
+
+    // Methode, um eine neue Form zur Zeichnung hinzuzufügen
+    public void add(Shape shape) {
+        shapes.add(shape);
+    }
+
+    // Methode, um eine Form aus der Zeichnung zu entfernen
+    public void remove(Shape shape) {
+        shapes.remove(shape);
+    }
+
+    // Methode, um alle Formen aus der Zeichnung zu entfernen
+    public void clear() {
+        System.out.println("Alle Formen aus der Zeichnung entfernen.");
+        shapes.clear();
+    }
+}
+
+// Hauptklasse zur Demonstration des Composite-Musters
+public class Main {
+
+    public static void main(String[] args) {
+        // Erstelle einige einzelne Formen
+        Shape triangle1 = new Triangle();
+        Shape triangle2 = new Triangle();
+        Shape circle = new Circle();
+
+        // Erstelle eine Zeichnung (Composite), die Formen enthalten kann
+        Drawing drawing = new Drawing();
+        drawing.add(triangle1); // Füge ein Dreieck hinzu
+        drawing.add(triangle2); // Füge ein weiteres Dreieck hinzu
+        drawing.add(circle);    // Füge einen Kreis hinzu
+
+        // Zeichne alle Formen in der Zeichnung mit der Farbe Rot
+        drawing.draw("Rot");
+
+        // Entferne alle Formen aus der Zeichnung
+        drawing.clear();
+
+        // Füge nur bestimmte Formen wieder hinzu
+        drawing.add(triangle1); // Füge ein Dreieck hinzu
+        drawing.add(circle);    // Füge einen Kreis hinzu
+
+        // Zeichne die neuen Formen mit der Farbe Grün
+        drawing.draw("Grün");
+    }
+}
+

Programmierung2/src/JunitTest/Einführung.java

@@ -6,7 +6,7 @@ public class Einführung {
 	 * - 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) {
-
+			System.out.println(-10 << 4 );
 	}
 	
 	public int add(int a, int b) {

Programmierung2/src/SQL/JavaDatenbanken/Wochentage.java

@@ -0,0 +1,18 @@
+package SQL.JavaDatenbanken;
+
+public enum Wochentage {
+	MONTAG("MONTAG");
+	
+	private String name;
+	
+	private Wochentage(String name) {
+		this.name = name;
+	}
+	
+	public String toString() {
+		
+		return name;
+	}
+}
+
+

Programmierung2/src/Teste/kopieArray.java

@@ -1,12 +1,7 @@
 package Teste;
-
-import java.util.ArrayList;
-
 public class kopieArray {
 
 	public static void main(String[] args) {
-		
-		ArrayList<String> test;
 //		/*
 //		 * 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
@@ -22,7 +17,7 @@ public class kopieArray {
 //		for (int i = 0; i <orgArray.length; i++)
 //			richtigeKopieArray[i] = orgArray[i];
 //
-	System.out.println(2 % 7);
+	
 			
 	
 	}