diff --git a/Programmierung2/src/Algorithmus/Allgemeine_Übungen.java b/Programmierung2/src/Algorithmus/Allgemeine_Übungen.java index 2096dc5..7752d6c 100644 --- a/Programmierung2/src/Algorithmus/Allgemeine_Übungen.java +++ b/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 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 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; + } + + } + +} diff --git a/Programmierung2/src/Algorithmus/BitweisesOperatoren/AND.java b/Programmierung2/src/Algorithmus/BitweisesOperatoren/AND.java index 0b37aff..9ec64ca 100644 --- a/Programmierung2/src/Algorithmus/BitweisesOperatoren/AND.java +++ b/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 + + } +} diff --git a/Programmierung2/src/Algorithmus/BitweisesOperatoren/NOT.java b/Programmierung2/src/Algorithmus/BitweisesOperatoren/NOT.java index fb1a8cc..e69bafc 100644 --- a/Programmierung2/src/Algorithmus/BitweisesOperatoren/NOT.java +++ b/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"); + } +} diff --git a/Programmierung2/src/Algorithmus/MehrfachsVerebung.java b/Programmierung2/src/Algorithmus/MehrfachsVerebung.java new file mode 100644 index 0000000..66b13e6 --- /dev/null +++ b/Programmierung2/src/Algorithmus/MehrfachsVerebung.java @@ -0,0 +1,12 @@ +package Algorithmus; + +public class MehrfachsVerebung { + + public static void main(String[] args) { + + + } + + +} + diff --git a/Programmierung2/src/Algorithmus/VariadischeFunktionen.java b/Programmierung2/src/Algorithmus/VariadischeFunktionen.java index 36348ce..a26ba6a 100644 --- a/Programmierung2/src/Algorithmus/VariadischeFunktionen.java +++ b/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)); + } + +} diff --git a/Programmierung2/src/BinaryTree/Trees Zusammenfassung.odt b/Programmierung2/src/BinaryTree/Trees Zusammenfassung.odt index 8d5ed92..4b1a11a 100644 Binary files a/Programmierung2/src/BinaryTree/Trees Zusammenfassung.odt and b/Programmierung2/src/BinaryTree/Trees Zusammenfassung.odt differ diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Kompositum-Entwurfsmuster (Composite).odt b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Kompositum-Entwurfsmuster (Composite).odt new file mode 100644 index 0000000..b694652 Binary files /dev/null and b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Kompositum-Entwurfsmuster (Composite).odt differ diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Main.java b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Main.java new file mode 100644 index 0000000..4705833 --- /dev/null +++ b/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 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"); + } +} + diff --git a/Programmierung2/src/JunitTest/Einführung.java b/Programmierung2/src/JunitTest/Einführung.java index 357e75d..5249bff 100644 --- a/Programmierung2/src/JunitTest/Einführung.java +++ b/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) { diff --git a/Programmierung2/src/SQL/JavaDatenbanken/Wochentage.java b/Programmierung2/src/SQL/JavaDatenbanken/Wochentage.java new file mode 100644 index 0000000..24500cc --- /dev/null +++ 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; + } +} + + diff --git a/Programmierung2/src/Teste/kopieArray.java b/Programmierung2/src/Teste/kopieArray.java index 125c51a..02a8aac 100644 --- a/Programmierung2/src/Teste/kopieArray.java +++ b/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 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