diff --git a/Programmierung2/.classpath b/Programmierung2/.classpath new file mode 100644 index 0000000..c5f72f6 --- /dev/null +++ b/Programmierung2/.classpath @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/Programmierung2/.gitignore b/Programmierung2/.gitignore new file mode 100644 index 0000000..3e2fcc7 --- /dev/null +++ b/Programmierung2/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/Programmierung2/.project b/Programmierung2/.project new file mode 100644 index 0000000..90bb32a --- /dev/null +++ b/Programmierung2/.project @@ -0,0 +1,17 @@ + + + Programmierung2 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/Programmierung2/.settings/org.eclipse.core.resources.prefs b/Programmierung2/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..4824b80 --- /dev/null +++ b/Programmierung2/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/Programmierung2/.settings/org.eclipse.jdt.core.prefs b/Programmierung2/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..a9bbf2d --- /dev/null +++ b/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 diff --git a/Programmierung2/src/Algorithmus/Algorithmus.java b/Programmierung2/src/Algorithmus/Algorithmus.java new file mode 100644 index 0000000..cc8a1ef --- /dev/null +++ b/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 + } + + +} diff --git a/Programmierung2/src/Algorithmus/Array.java b/Programmierung2/src/Algorithmus/Array.java new file mode 100644 index 0000000..2d546cd --- /dev/null +++ b/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 + */ + + } + +} diff --git a/Programmierung2/src/Algorithmus/Complexity(Big O Notation).odt b/Programmierung2/src/Algorithmus/Complexity(Big O Notation).odt new file mode 100644 index 0000000..031bada Binary files /dev/null and b/Programmierung2/src/Algorithmus/Complexity(Big O Notation).odt differ diff --git a/Programmierung2/src/Algorithmus/Logischen_Operatoren.java b/Programmierung2/src/Algorithmus/Logischen_Operatoren.java new file mode 100644 index 0000000..ba843e2 --- /dev/null +++ b/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 + + + + + } +} diff --git a/Programmierung2/src/BankSystemGUI/BankController.java b/Programmierung2/src/BankSystemGUI/BankController.java new file mode 100644 index 0000000..3ac3b4b --- /dev/null +++ b/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(); + + } + } +} + diff --git a/Programmierung2/src/BankSystemGUI/BankSystem.java b/Programmierung2/src/BankSystemGUI/BankSystem.java new file mode 100644 index 0000000..60e2856 --- /dev/null +++ b/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 + "]"; + } + +} diff --git a/Programmierung2/src/BankSystemGUI/BankSystemTest.java b/Programmierung2/src/BankSystemGUI/BankSystemTest.java new file mode 100644 index 0000000..2caba08 --- /dev/null +++ b/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 + } +} diff --git a/Programmierung2/src/BankSystemGUI/Hauptfenster.java b/Programmierung2/src/BankSystemGUI/Hauptfenster.java new file mode 100644 index 0000000..ab0ab21 --- /dev/null +++ b/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(); + } + +} diff --git a/Programmierung2/src/BankSystemGUI/Kunde.txt b/Programmierung2/src/BankSystemGUI/Kunde.txt new file mode 100644 index 0000000..d26bc86 --- /dev/null +++ b/Programmierung2/src/BankSystemGUI/Kunde.txt @@ -0,0 +1,7 @@ +ID: 1 +Vorname: obai +Nachname: albek +Password: 12345 +Email: obay@gmail.com +kontoStand 0.0 + diff --git a/Programmierung2/src/BankSystemGUI/LogIn.java b/Programmierung2/src/BankSystemGUI/LogIn.java new file mode 100644 index 0000000..f04f434 --- /dev/null +++ b/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) { + + + } + +} + + + diff --git a/Programmierung2/src/BankSystemGUI/Test.java b/Programmierung2/src/BankSystemGUI/Test.java new file mode 100644 index 0000000..0db1f2b --- /dev/null +++ b/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()); +// + + } + +} diff --git a/Programmierung2/src/BankSystemGUI/Window.java b/Programmierung2/src/BankSystemGUI/Window.java new file mode 100644 index 0000000..2fdbcb1 --- /dev/null +++ b/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); + + } + + +} diff --git a/Programmierung2/src/BinaryTree/BinaryBaumList.java b/Programmierung2/src/BinaryTree/BinaryBaumList.java new file mode 100644 index 0000000..58d18c1 --- /dev/null +++ b/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 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); + } + +} diff --git a/Programmierung2/src/BinaryTree/Debugg Für Findhöhe Methode.pdf b/Programmierung2/src/BinaryTree/Debugg Für Findhöhe Methode.pdf new file mode 100644 index 0000000..0be43b7 Binary files /dev/null and b/Programmierung2/src/BinaryTree/Debugg Für Findhöhe Methode.pdf differ diff --git a/Programmierung2/src/BinaryTree/Debugg Für Lösche Knote.pdf b/Programmierung2/src/BinaryTree/Debugg Für Lösche Knote.pdf new file mode 100644 index 0000000..3666bf9 Binary files /dev/null and b/Programmierung2/src/BinaryTree/Debugg Für Lösche Knote.pdf differ diff --git a/Programmierung2/src/BinaryTree/Debugg Für Print Verfahren.pdf b/Programmierung2/src/BinaryTree/Debugg Für Print Verfahren.pdf new file mode 100644 index 0000000..1202b15 Binary files /dev/null and b/Programmierung2/src/BinaryTree/Debugg Für Print Verfahren.pdf differ diff --git a/Programmierung2/src/BinaryTree/JuintTeste.java b/Programmierung2/src/BinaryTree/JuintTeste.java new file mode 100644 index 0000000..4f860e2 --- /dev/null +++ b/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); + + } + +} diff --git a/Programmierung2/src/BinaryTree/Node.java b/Programmierung2/src/BinaryTree/Node.java new file mode 100644 index 0000000..724943d --- /dev/null +++ b/Programmierung2/src/BinaryTree/Node.java @@ -0,0 +1,8 @@ +package BinaryTree; + +public class Node { + int value; + Node left; + Node right; + +} diff --git a/Programmierung2/src/BinaryTree/Test.java b/Programmierung2/src/BinaryTree/Test.java new file mode 100644 index 0000000..55ca449 --- /dev/null +++ b/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("]"); + + } + + + + + +} diff --git a/Programmierung2/src/BinaryTree/Tree Data Structure.odt b/Programmierung2/src/BinaryTree/Tree Data Structure.odt new file mode 100644 index 0000000..17b5035 Binary files /dev/null and b/Programmierung2/src/BinaryTree/Tree Data Structure.odt differ diff --git a/Programmierung2/src/Collection/Collections.java b/Programmierung2/src/Collection/Collections.java new file mode 100644 index 0000000..99db1d0 --- /dev/null +++ b/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 + * + */ + +} diff --git a/Programmierung2/src/Collection/Lists.java b/Programmierung2/src/Collection/Lists.java new file mode 100644 index 0000000..c81cf01 --- /dev/null +++ b/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 arrayList = new ArrayList<>(); + + LinkedList linkedList = new LinkedList<>(); + + List vector = new Vector<>(); + // stack erbt von Vector + Stack 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); + + } + +} diff --git a/Programmierung2/src/Collection/Queueslist.java b/Programmierung2/src/Collection/Queueslist.java new file mode 100644 index 0000000..a573033 --- /dev/null +++ b/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 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 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 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 + + } + +} diff --git a/Programmierung2/src/Collection/Setlists.java b/Programmierung2/src/Collection/Setlists.java new file mode 100644 index 0000000..4f62a8e --- /dev/null +++ b/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 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 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 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); + + + } + +} diff --git a/Programmierung2/src/FassadenKlasse/Fassade Entwurf.odt b/Programmierung2/src/FassadenKlasse/Fassade Entwurf.odt new file mode 100644 index 0000000..d13e5c8 Binary files /dev/null and b/Programmierung2/src/FassadenKlasse/Fassade Entwurf.odt differ diff --git a/Programmierung2/src/FassadenKlasse/Fassadenklasse.java b/Programmierung2/src/FassadenKlasse/Fassadenklasse.java new file mode 100644 index 0000000..4c712bc --- /dev/null +++ b/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(); + } + } + diff --git a/Programmierung2/src/GUIAnwendungen/BewegePanle.java b/Programmierung2/src/GUIAnwendungen/BewegePanle.java new file mode 100644 index 0000000..6567841 --- /dev/null +++ b/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); + } + } + diff --git a/Programmierung2/src/GUIAnwendungen/Borderlayout.java b/Programmierung2/src/GUIAnwendungen/Borderlayout.java new file mode 100644 index 0000000..29d2497 --- /dev/null +++ b/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); + + } + +} diff --git a/Programmierung2/src/GUIAnwendungen/Flowlayout.java b/Programmierung2/src/GUIAnwendungen/Flowlayout.java new file mode 100644 index 0000000..3a26b0a --- /dev/null +++ b/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); + } + + +} diff --git a/Programmierung2/src/GUIAnwendungen/GridBagLayoutExample.java b/Programmierung2/src/GUIAnwendungen/GridBagLayoutExample.java new file mode 100644 index 0000000..8aafbcb --- /dev/null +++ b/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); + } +} diff --git a/Programmierung2/src/GUIAnwendungen/Gridlayout.java b/Programmierung2/src/GUIAnwendungen/Gridlayout.java new file mode 100644 index 0000000..97825d2 --- /dev/null +++ b/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); + + + } + +} diff --git a/Programmierung2/src/GUIAnwendungen/Jframe.java b/Programmierung2/src/GUIAnwendungen/Jframe.java new file mode 100644 index 0000000..6ab865c --- /dev/null +++ b/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)); + + } + +} diff --git a/Programmierung2/src/GUIAnwendungen/Jpanel.java b/Programmierung2/src/GUIAnwendungen/Jpanel.java new file mode 100644 index 0000000..7512f43 --- /dev/null +++ b/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); + + + } + +} \ No newline at end of file diff --git a/Programmierung2/src/GUIAnwendungen/KeyBindingsExample.java b/Programmierung2/src/GUIAnwendungen/KeyBindingsExample.java new file mode 100644 index 0000000..25032a6 --- /dev/null +++ b/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(); + } +} diff --git a/Programmierung2/src/GUIAnwendungen/Labels.java b/Programmierung2/src/GUIAnwendungen/Labels.java new file mode 100644 index 0000000..1c4b1aa --- /dev/null +++ b/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); + + + + + + + } + +} diff --git a/Programmierung2/src/GUIAnwendungen/ShowMessage.java b/Programmierung2/src/GUIAnwendungen/ShowMessage.java new file mode 100644 index 0000000..8bbc4f7 --- /dev/null +++ b/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); + } + } + + + diff --git a/Programmierung2/src/GUIAnwendungen/Test.jpg b/Programmierung2/src/GUIAnwendungen/Test.jpg new file mode 100644 index 0000000..0c7ff29 Binary files /dev/null and b/Programmierung2/src/GUIAnwendungen/Test.jpg differ diff --git a/Programmierung2/src/GUIAnwendungen/TextEingaben.java b/Programmierung2/src/GUIAnwendungen/TextEingaben.java new file mode 100644 index 0000000..8afb92a --- /dev/null +++ b/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(); + } +} + diff --git a/Programmierung2/src/GUIAnwendungen/jbutton.java b/Programmierung2/src/GUIAnwendungen/jbutton.java new file mode 100644 index 0000000..f1f5e9b --- /dev/null +++ b/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 + + } + + +} diff --git a/Programmierung2/src/JunitTest/Einführung.java b/Programmierung2/src/JunitTest/Einführung.java new file mode 100644 index 0000000..357e75d --- /dev/null +++ b/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; + } + +} diff --git a/Programmierung2/src/JunitTest/EinführungTest.java b/Programmierung2/src/JunitTest/EinführungTest.java new file mode 100644 index 0000000..677c5e6 --- /dev/null +++ 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)); + } +} diff --git a/Programmierung2/src/JunitTest/Skript Automatisiert testen (1).pdf b/Programmierung2/src/JunitTest/Skript Automatisiert testen (1).pdf new file mode 100644 index 0000000..d55f331 Binary files /dev/null and b/Programmierung2/src/JunitTest/Skript Automatisiert testen (1).pdf differ diff --git a/Programmierung2/src/Linked_List/ElementList.java b/Programmierung2/src/Linked_List/ElementList.java new file mode 100644 index 0000000..04f0fde --- /dev/null +++ b/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("]"); + + } + +} diff --git a/Programmierung2/src/Linked_List/Node.java b/Programmierung2/src/Linked_List/Node.java new file mode 100644 index 0000000..d95e9b2 --- /dev/null +++ b/Programmierung2/src/Linked_List/Node.java @@ -0,0 +1,6 @@ +package Linked_List; + +public class Node { + int value; + Node next; +} diff --git a/Programmierung2/src/Linked_List/Test.java b/Programmierung2/src/Linked_List/Test.java new file mode 100644 index 0000000..f78335e --- /dev/null +++ b/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(); + } + +} diff --git a/Programmierung2/src/MVC_Desighn/MVC-Designmuster.odt b/Programmierung2/src/MVC_Desighn/MVC-Designmuster.odt new file mode 100644 index 0000000..1b8f6a4 Binary files /dev/null and b/Programmierung2/src/MVC_Desighn/MVC-Designmuster.odt differ diff --git a/Programmierung2/src/MVC_Desighn/Person_Daten.java b/Programmierung2/src/MVC_Desighn/Person_Daten.java new file mode 100644 index 0000000..9634845 --- /dev/null +++ b/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()); + } + +} + + + + diff --git a/Programmierung2/src/MVC_Desighn/Person_GUI.java b/Programmierung2/src/MVC_Desighn/Person_GUI.java new file mode 100644 index 0000000..ff6a7fb --- /dev/null +++ b/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()); + } +} diff --git a/Programmierung2/src/Teste/kopieArray.java b/Programmierung2/src/Teste/kopieArray.java new file mode 100644 index 0000000..770724d --- /dev/null +++ b/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 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(); + + +} diff --git a/Programmierung2/src/oop/Abstraction/Auto.java b/Programmierung2/src/oop/Abstraction/Auto.java new file mode 100644 index 0000000..808af6b --- /dev/null +++ b/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(); + + + +} diff --git a/Programmierung2/src/oop/Abstraction/Auto2.java b/Programmierung2/src/oop/Abstraction/Auto2.java new file mode 100644 index 0000000..5ab66f9 --- /dev/null +++ b/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); + + } + + + + +} diff --git a/Programmierung2/src/oop/Abstraction/Hatchback.java b/Programmierung2/src/oop/Abstraction/Hatchback.java new file mode 100644 index 0000000..f79bb00 --- /dev/null +++ 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"); + + } + + + +} diff --git a/Programmierung2/src/oop/Abstraction/MarkerInterface.java b/Programmierung2/src/oop/Abstraction/MarkerInterface.java new file mode 100644 index 0000000..b932ab2 --- /dev/null +++ b/Programmierung2/src/oop/Abstraction/MarkerInterface.java @@ -0,0 +1,6 @@ +package oop.Abstraction; + +public class MarkerInterface { + // Keine Methoden oder Konstanten + +} diff --git a/Programmierung2/src/oop/Abstraction/NestedInterface.java b/Programmierung2/src/oop/Abstraction/NestedInterface.java new file mode 100644 index 0000000..ce9e13a --- /dev/null +++ b/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"); + } + + } + +} diff --git a/Programmierung2/src/oop/Abstraction/SUV.java b/Programmierung2/src/oop/Abstraction/SUV.java new file mode 100644 index 0000000..43c8933 --- /dev/null +++ b/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"); + + } + + +} diff --git a/Programmierung2/src/oop/Abstraction/Test.java b/Programmierung2/src/oop/Abstraction/Test.java new file mode 100644 index 0000000..abf3cbe --- /dev/null +++ b/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 + + } + +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/AnonymousInnerClass.java b/Programmierung2/src/oop/AnonymousInnerClass/AnonymousInnerClass.java new file mode 100644 index 0000000..3f2bec1 --- /dev/null +++ b/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. + * + * + */ + +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/Interface.java b/Programmierung2/src/oop/AnonymousInnerClass/Interface.java new file mode 100644 index 0000000..f5576ad --- /dev/null +++ b/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(); + } +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/Konstruktor.java b/Programmierung2/src/oop/AnonymousInnerClass/Konstruktor.java new file mode 100644 index 0000000..d11def6 --- /dev/null +++ b/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(); + + } + +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/RewardClass.java b/Programmierung2/src/oop/AnonymousInnerClass/RewardClass.java new file mode 100644 index 0000000..be6a1f1 --- /dev/null +++ b/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€."); + } + + +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/Test.java b/Programmierung2/src/oop/AnonymousInnerClass/Test.java new file mode 100644 index 0000000..4245650 --- /dev/null +++ b/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 + */ + } + +} diff --git a/Programmierung2/src/oop/Aufgaben/BankKonto.java b/Programmierung2/src/oop/Aufgaben/BankKonto.java new file mode 100644 index 0000000..17e9f24 --- /dev/null +++ b/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; + } + +} diff --git a/Programmierung2/src/oop/Aufgaben/Kreis.java b/Programmierung2/src/oop/Aufgaben/Kreis.java new file mode 100644 index 0000000..e1d3492 --- /dev/null +++ b/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() ; + } + + +} diff --git a/Programmierung2/src/oop/Aufgaben/Mitarbeiter.java b/Programmierung2/src/oop/Aufgaben/Mitarbeiter.java new file mode 100644 index 0000000..e7ded0f --- /dev/null +++ b/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; + } + + +} diff --git a/Programmierung2/src/oop/Aufgaben/Personalverwaltung.java b/Programmierung2/src/oop/Aufgaben/Personalverwaltung.java new file mode 100644 index 0000000..e85f1f1 --- /dev/null +++ b/Programmierung2/src/oop/Aufgaben/Personalverwaltung.java @@ -0,0 +1,32 @@ +package oop.Aufgaben; + +import java.util.ArrayList; + +public class Personalverwaltung { + + ArrayList mitarbeiterliste = new ArrayList(); + + + + 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); + } + } + +} diff --git a/Programmierung2/src/oop/Einführung/Einführung.java b/Programmierung2/src/oop/Einführung/Einführung.java new file mode 100644 index 0000000..69bbe81 --- /dev/null +++ b/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; + } +} diff --git a/Programmierung2/src/oop/Enumeration/EnumMethods.java b/Programmierung2/src/oop/Enumeration/EnumMethods.java new file mode 100644 index 0000000..04c82ab --- /dev/null +++ b/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 days = EnumSet.allOf(EnumMethods.class); + System.out.println(days); + + // gibt nur Werte ,die ich eingebe + EnumSet day = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.FREITAG); + System.out.println(day); + + // gibt nur einmal Diesntag aus! + EnumSet day1 = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.DIENSTAG); + System.out.println(day); + + // gibt mir von Konstante to Kosntnate zurück! + EnumSet range = EnumSet.range(EnumMethods.DIENSTAG, EnumMethods.FREITAG); + System.out.println(range); + + + EnumSet noneOf = EnumSet.noneOf(EnumMethods.class); + noneOf.add(DIENSTAG); + noneOf.addAll(noneOf); + noneOf.remove(DIENSTAG); + noneOf.removeAll(noneOf); + System.out.println(noneOf); + + } + +} diff --git a/Programmierung2/src/oop/Enumeration/Enumeration.java b/Programmierung2/src/oop/Enumeration/Enumeration.java new file mode 100644 index 0000000..ad943cd --- /dev/null +++ b/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 + * + */ + +} diff --git a/Programmierung2/src/oop/Enumeration/Numbers.java b/Programmierung2/src/oop/Enumeration/Numbers.java new file mode 100644 index 0000000..5e13bc4 --- /dev/null +++ b/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"); + } + +} diff --git a/Programmierung2/src/oop/Enumeration/Order.java b/Programmierung2/src/oop/Enumeration/Order.java new file mode 100644 index 0000000..1fc947d --- /dev/null +++ b/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; + } + + + +} diff --git a/Programmierung2/src/oop/Enumeration/OrderTest.java b/Programmierung2/src/oop/Enumeration/OrderTest.java new file mode 100644 index 0000000..c4d484e --- /dev/null +++ b/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()); + + } + +} diff --git a/Programmierung2/src/oop/Enumeration/Test.java b/Programmierung2/src/oop/Enumeration/Test.java new file mode 100644 index 0000000..f6c1955 --- /dev/null +++ b/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(); + + + + + + } + +} diff --git a/Programmierung2/src/oop/Enumeration/Wochentage.java b/Programmierung2/src/oop/Enumeration/Wochentage.java new file mode 100644 index 0000000..52dc75c --- /dev/null +++ b/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(); + + +} diff --git a/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-04-58.png b/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-04-58.png new file mode 100644 index 0000000..a5ed8dc Binary files /dev/null and b/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-04-58.png differ diff --git a/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-07-28.png b/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-07-28.png new file mode 100644 index 0000000..7d7a4aa Binary files /dev/null and b/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-07-28.png differ diff --git a/Programmierung2/src/oop/ExceptionHandling/CheckedException.java b/Programmierung2/src/oop/ExceptionHandling/CheckedException.java new file mode 100644 index 0000000..435cfb4 --- /dev/null +++ b/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); + } + } + +} diff --git a/Programmierung2/src/oop/ExceptionHandling/ExceptionHandling.java b/Programmierung2/src/oop/ExceptionHandling/ExceptionHandling.java new file mode 100644 index 0000000..47be6b6 --- /dev/null +++ b/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"); + + + + } + + +} diff --git a/Programmierung2/src/oop/ExceptionHandling/Finally.java b/Programmierung2/src/oop/ExceptionHandling/Finally.java new file mode 100644 index 0000000..5269b16 --- /dev/null +++ b/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; + } + } +} diff --git a/Programmierung2/src/oop/ExceptionHandling/MultiCatchBlocks.java b/Programmierung2/src/oop/ExceptionHandling/MultiCatchBlocks.java new file mode 100644 index 0000000..75c8f16 --- /dev/null +++ b/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); + } + } + + +} diff --git a/Programmierung2/src/oop/ExceptionHandling/Throwkeyword.java b/Programmierung2/src/oop/ExceptionHandling/Throwkeyword.java new file mode 100644 index 0000000..61e88a5 --- /dev/null +++ b/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"); + } +} diff --git a/Programmierung2/src/oop/ExceptionHandling/ThrowsKeyword.java b/Programmierung2/src/oop/ExceptionHandling/ThrowsKeyword.java new file mode 100644 index 0000000..09314e7 --- /dev/null +++ b/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); + } + + } +} diff --git a/Programmierung2/src/oop/ExceptionHandling/UnCheckedException.java b/Programmierung2/src/oop/ExceptionHandling/UnCheckedException.java new file mode 100644 index 0000000..f146af4 --- /dev/null +++ b/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(); + } +} diff --git a/Programmierung2/src/oop/File-Handling.odt b/Programmierung2/src/oop/File-Handling.odt new file mode 100644 index 0000000..2bc3d1a Binary files /dev/null and b/Programmierung2/src/oop/File-Handling.odt differ diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Eingefügtes Bild.png b/Programmierung2/src/oop/FileHandling/ByteKlassen/Eingefügtes Bild.png new file mode 100644 index 0000000..5096fe1 Binary files /dev/null and b/Programmierung2/src/oop/FileHandling/ByteKlassen/Eingefügtes Bild.png differ diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Fileinputstream.java b/Programmierung2/src/oop/FileHandling/ByteKlassen/Fileinputstream.java new file mode 100644 index 0000000..e874841 --- /dev/null +++ b/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); + } + + + + } +} diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Filoutputstream.java b/Programmierung2/src/oop/FileHandling/ByteKlassen/Filoutputstream.java new file mode 100644 index 0000000..2285678 --- /dev/null +++ b/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()); + } + + +} diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/LeseEinBild.java b/Programmierung2/src/oop/FileHandling/ByteKlassen/LeseEinBild.java new file mode 100644 index 0000000..0ad11be --- /dev/null +++ b/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(); + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Test b/Programmierung2/src/oop/FileHandling/ByteKlassen/Test new file mode 100644 index 0000000..f2ba8f8 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/ByteKlassen/Test @@ -0,0 +1 @@ +abc \ No newline at end of file diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Test2 b/Programmierung2/src/oop/FileHandling/ByteKlassen/Test2 new file mode 100644 index 0000000..9d3f046 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/ByteKlassen/Test2 @@ -0,0 +1 @@ +ä \ No newline at end of file diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/neues Bild.png b/Programmierung2/src/oop/FileHandling/ByteKlassen/neues Bild.png new file mode 100644 index 0000000..5096fe1 Binary files /dev/null and b/Programmierung2/src/oop/FileHandling/ByteKlassen/neues Bild.png differ diff --git a/Programmierung2/src/oop/FileHandling/FileHandling.java b/Programmierung2/src/oop/FileHandling/FileHandling.java new file mode 100644 index 0000000..6f0c5f4 --- /dev/null +++ b/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. + */ + + +} diff --git a/Programmierung2/src/oop/FileHandling/FileKlasse.java b/Programmierung2/src/oop/FileHandling/FileKlasse.java new file mode 100644 index 0000000..1eea286 --- /dev/null +++ b/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."); + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/FileTest.txt b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/FileTest.txt new file mode 100644 index 0000000..c9d61dc Binary files /dev/null and b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/FileTest.txt differ diff --git a/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/Test.java b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/Test.java new file mode 100644 index 0000000..1871c66 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/Test.java @@ -0,0 +1,53 @@ +package oop.FileHandling.SerializationAndDeserialization; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.ArrayList; + +public class Test { + + public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException { + + File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\SerializationAndDeserialization\\FileTest.txt"); + + //(Serialization): schreibe das Objekt auf dem File als byte stream + ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file)); + writeObjekt write = new writeObjekt(111,"obai",3.4); + oos.writeObject(write); + + //(Deserialization): Lese das Objekt auf dem File als byte stream + ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); + + // Das zurückgegebene Objekt muss in den spezifischen Typ gecastet werden + writeObjekt f1 = (writeObjekt) ois.readObject(); + System.out.println(f1); + + + + // multiple objects (lesen & schreiben) + + //schreiben: + writeObjekt s1 = new writeObjekt(111,"Obai",2.2); + writeObjekt s2 = new writeObjekt(111,"Omar",2.2); + ArrayList list = new ArrayList<>(); + list.add(s1); + list.add(s2); + + ObjectOutputStream writeList = new ObjectOutputStream(new FileOutputStream(file)); + writeList.writeObject(list); + + //Lesen: + ObjectInputStream readList = new ObjectInputStream(new FileInputStream(file)); + ArrayList multiobjekt = (ArrayList)readList.readObject(); + System.out.println(multiobjekt); + + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/writeObjekt.java b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/writeObjekt.java new file mode 100644 index 0000000..3177e53 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/writeObjekt.java @@ -0,0 +1,48 @@ +package oop.FileHandling.SerializationAndDeserialization; + +import java.io.Serializable; +/* + * Serializable ist ein marker (leere) Interface kalsse, soll implementiert werden + */ + +public class writeObjekt implements Serializable { + + int id; + String name; + double Note; + + public writeObjekt(int id, String name, double note) { + this.id = id; + this.name = name; + Note = note; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public double getNote() { + return Note; + } + + public void setNote(double note) { + Note = note; + } + + @Override + public String toString() { + return "Student [id=" + id + ", name=" + name + ", Note=" + Note + "]"; + } +} diff --git a/Programmierung2/src/oop/FileHandling/TestFolder/1.txt b/Programmierung2/src/oop/FileHandling/TestFolder/1.txt new file mode 100644 index 0000000..e69de29 diff --git a/Programmierung2/src/oop/FileHandling/TestFolder/2.txt b/Programmierung2/src/oop/FileHandling/TestFolder/2.txt new file mode 100644 index 0000000..e69de29 diff --git a/Programmierung2/src/oop/FileHandling/character/Bufferedreader.java b/Programmierung2/src/oop/FileHandling/character/Bufferedreader.java new file mode 100644 index 0000000..c7a1b71 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/character/Bufferedreader.java @@ -0,0 +1,28 @@ +package oop.FileHandling.character; +import java.io.FileReader; +import java.io.File; +import java.io.IOException; +import java.io.BufferedReader; + +/* + * - hauptfubktion: Liest ganze Zeilen (line by line) auf einmal und ruft die Methode readLine() aus + * + */ +public class Bufferedreader { + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1")); + String line = br.readLine(); + /* + * - Liest nur eine einzige Line auf dem File + * Lösungsmöglichkeit => Loop erzeugen + */ + while(line != null) { + System.out.println(line); // print die erste Line + line = br.readLine(); // spring auf die nächste Linie + } + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Bufferedwriter.java b/Programmierung2/src/oop/FileHandling/character/Bufferedwriter.java new file mode 100644 index 0000000..8b3ed3a --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/character/Bufferedwriter.java @@ -0,0 +1,36 @@ +package oop.FileHandling.character; +import java.io.FileWriter; +import java.io.File; +import java.io.IOException; + +import java.io.BufferedWriter; +/* + * - hauptfubktion: Liest ganze Zeilen auf einmal und ruft die Methode readLine() aus + * - br.write(97); => 'a' sie liest keine Integer zahlen + * - br.write(10.5) => error geht nicht + * - br.write(boolean) => error geht nicht + * Alternative Möglichkeit (PrintWriter ) kann alle Daten Typs auf dem File schreiben + */ +public class Bufferedwriter { + + public static void main(String[] args) throws IOException { + /* + * - BufferedWriter übernimmt keine Pfad für einen File, + * sondern übernimmt sie ein Objekt aus der Klasse (FileWriter) die extends die Abstrakte Klasse Writer + * - FileWriter Klass hilft mir BufferedWriter zu verwenden + */ + + /* + * true, damit Wenn {@code true}, werden die Daten (fix geschpeichert) + * anstatt an den Anfang. also die Datein werden nicht überschrieben werden + */ + BufferedWriter b1 = new BufferedWriter(new FileWriter("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1",true)); + b1.write("Hallo Welt"); + b1.newLine(); // neue Linie + b1.write("Hallo Welt2"); + b1.flush(); + b1.close(); + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Filereader.java b/Programmierung2/src/oop/FileHandling/character/Filereader.java new file mode 100644 index 0000000..ce0d80b --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/character/Filereader.java @@ -0,0 +1,35 @@ +package oop.FileHandling.character; + +import java.io.File; +import java.io.FileReader; +import java.io.IOException; + +public class Filereader { + /* + * - Das Verfahren läuft ganz geanu wie beim FileInputStream + * - Kritik: FileReader liest jedes Char ich habe 10 Zeichen + * die Methode read() wird in dem Fall sich selbst 10 mal aufrufen + * Alternativ möglichkeit (BufferedReader) + */ + public static void main(String[] args) throws IOException { + + File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1"); + FileReader fr = new FileReader(file); + + // lese Dateien + // Variante 1: + int i; + while((i = fr.read()) != -1) + System.out.print((char)i); + + // Variante 2: Mit Hilfe von File Klasse + char[] speicher = new char[(int) file.length()]; + fr.read(speicher); + for (char c : speicher) + System.out.print(c); + + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Filewriter.java b/Programmierung2/src/oop/FileHandling/character/Filewriter.java new file mode 100644 index 0000000..53ae7ae --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/character/Filewriter.java @@ -0,0 +1,28 @@ +package oop.FileHandling.character; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; + +public class Filewriter { + // für Schreiben auf einem beliebig File + public static void main(String[] args) throws IOException { + //erstelle einen File + File newFile = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1"); + if (newFile.createNewFile()) // createNewFile() gibt boolean zurück,ob der File ergolgreich erstellt wurde oder nicht + System.out.println("Datei erstellt: " + newFile.getName()); // der File muss im Pfad nicht existieren, damit es erstellt wurde + + String str = "Hallo Welt"; + FileWriter fr = new FileWriter("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1"); + fr.write(str); //wird Hallo Welt auf dem File geschrieben! + fr.write("\n"); // breakline im File + fr.write(str, 0, str.length()); //schreibt string von int x inkl bis int y exklus + fr.write("\n"); + fr.write('2'); + + fr.close(); + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/OutPutStreamWriter.java b/Programmierung2/src/oop/FileHandling/character/OutPutStreamWriter.java new file mode 100644 index 0000000..297e8ec --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/character/OutPutStreamWriter.java @@ -0,0 +1,18 @@ +package oop.FileHandling.character; +import java.io.Writer; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStreamWriter; + +public class OutPutStreamWriter { + + public static void main(String[] args) throws IOException { + // die Klasse (OutputStreamWriter) extends (Writer) + + Writer writer = new OutputStreamWriter(new FileOutputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1")); + String str = "hi Welt"; + writer.write(str); + writer.flush();// da ich diese Methode aufgerufen habe, wurden die Datein zugeschieckt! + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Printwriter.java b/Programmierung2/src/oop/FileHandling/character/Printwriter.java new file mode 100644 index 0000000..83df508 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/character/Printwriter.java @@ -0,0 +1,32 @@ +package oop.FileHandling.character; + +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintWriter; + +public class Printwriter { + /* + * - schreibt alle Daten Typs auf dem File + * - flush() soll aufgerufen werden + */ + public static void main(String[] args) throws IOException { + // - flush() soll aufgerufen werden + PrintWriter pr = new PrintWriter("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1"); +// pr.println(97); +// pr.println("AAA"); +// pr.println('B'); +// pr.println(true); +// pr.flush(); + + // oder + FileWriter fr = new FileWriter("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1"); + PrintWriter pr2 = new PrintWriter(fr, true); //true steht für flush() Aufruf + pr2.write(97); // wenn wir write verwenden, sollen wir flush() aufrufen + pr2.println("AAA"); + pr2.println('B'); + pr2.println(true); + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Scannerklass.java b/Programmierung2/src/oop/FileHandling/character/Scannerklass.java new file mode 100644 index 0000000..4dca9e9 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/character/Scannerklass.java @@ -0,0 +1,25 @@ +package oop.FileHandling.character; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.Scanner; + +public class Scannerklass { + + public static void main(String[] args) throws IOException { + File fr = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1"); + Scanner scan = new Scanner(fr); + + //System.out.println(scan.next()); liest nur ein wort und hört dann auf + //System.out.println(scan.nextLine()); // Liest nur eine Line und hört dann auf +// +// while(scan.hasNextLine())// hilfe mir alle Zeilen zu lesen +// System.out.println(scan.nextLine()); + + scan.useDelimiter("w"); // gibt Foramt für den Text aus dem File + while(scan.hasNext())// hilfe mir alle Wörter zu lesen + System.out.println(scan.next()); + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Test1 b/Programmierung2/src/oop/FileHandling/character/Test1 new file mode 100644 index 0000000..e69de29 diff --git a/Programmierung2/src/oop/FinalKeyword/FinalKeywords.java b/Programmierung2/src/oop/FinalKeyword/FinalKeywords.java new file mode 100644 index 0000000..d958b29 --- /dev/null +++ b/Programmierung2/src/oop/FinalKeyword/FinalKeywords.java @@ -0,0 +1,38 @@ +package oop.FinalKeyword; + +public class FinalKeywords { + + /* + * Final is a non-access modifier applicable only to: + * Final variables oder (Constant Variables) oder (const Variables) + * Final parameters + * Final methods + * Final classes + * Final References + * + * + * Final variables oder: + * final variable soll immer groß geschrieben werden. + * für final variable kann nicht setter und getter erstellt werden + * final static variable können in Constructor keinen Wert zuweisen werden + * final variable sind mit Scanner gültig + * + * + * + * Final methods: + * final methods können nicht überschrieben werden. complier error + * final-Methoden können in überladen werden. + * + * + * Final Classes: + * final classes können nicht geerbt werden. + * classes die Private Konstruktoren hat, kann auch nicht geerbt werden + * + * + * + *Final References: + *final References können nur einmal Werte zugewiesen Werden. + * + */ + +} diff --git a/Programmierung2/src/oop/FinalKeyword/Student.java b/Programmierung2/src/oop/FinalKeyword/Student.java new file mode 100644 index 0000000..cde7a7c --- /dev/null +++ b/Programmierung2/src/oop/FinalKeyword/Student.java @@ -0,0 +1,64 @@ +package oop.FinalKeyword; + +public class Student { + final int STUDENT_ID ; + final static int degree; + String name; + int geburtstag; + + /* so geht + * {STUDENT_ID = 200;} + */ + + + //oder so; + Student(){ + STUDENT_ID = 20; + //degree = 2; Das ist verboten + } + // nur in static block + static { + degree = 20; + } + + + public Student(final int STUDENT_ID, String name, int geburtstag) { + //STUDENT_ID = 0; verboten, das STUDENT_ID final ist + this.STUDENT_ID = STUDENT_ID; + this.name = name; + this.geburtstag = geburtstag; + } + + // getmethod ist gültig + public int getSTUDENT_ID() { + return STUDENT_ID; + } + + + /*das ist verboten, weil wir STUDENT_ID nicht ersetzen dürfen + + * public int setSTUDENT_ID(int STUDENT_ID) { + this.STUDENT_ID = STUDENT_ID; + } + */ + + + @Override + final public String toString() { + return "Student [STUDENT_ID=" + STUDENT_ID + ", name=" + name + ", geburtstag=" + geburtstag + "]"; + } +} + + + +class GraduatedStudent extends Student{ + + /*Verboten + * @Override + * public String toString() { + return "Student [STUDENT_ID=" + STUDENT_ID + ", name=" + name + ", geburtstag=" + geburtstag + "]"; + } + */ + + +} diff --git a/Programmierung2/src/oop/FinalKeyword/Test.java b/Programmierung2/src/oop/FinalKeyword/Test.java new file mode 100644 index 0000000..f0ae605 --- /dev/null +++ b/Programmierung2/src/oop/FinalKeyword/Test.java @@ -0,0 +1,14 @@ +package oop.FinalKeyword; + + +public class Test { + + public static void main(String[] args) { + final Student st1 = new Student(123,"obai",2001); + + // st1 = new Student (123,"obai",2001); Verboten + + System.out.print(st1.toString()); + } + +} diff --git a/Programmierung2/src/oop/Generics/AddMitarbeiter.java b/Programmierung2/src/oop/Generics/AddMitarbeiter.java new file mode 100644 index 0000000..40684c0 --- /dev/null +++ b/Programmierung2/src/oop/Generics/AddMitarbeiter.java @@ -0,0 +1,21 @@ +package oop.Generics; +import java.util.ArrayList; + + +public class AddMitarbeiter { + + ArrayList m1 = new ArrayList<>(); + + public ArrayList getM1() { + return m1; + } + + public void setM1(ArrayList m1) { + this.m1 = m1; + } + + @Override + public String toString() { + return "AddMitarbeiter [m1=" + m1 + "]"; + } +} diff --git a/Programmierung2/src/oop/Generics/DateTyps.java b/Programmierung2/src/oop/Generics/DateTyps.java new file mode 100644 index 0000000..8c01c09 --- /dev/null +++ b/Programmierung2/src/oop/Generics/DateTyps.java @@ -0,0 +1,23 @@ +package oop.Generics; + +public class DateTyps { + + private T inhalt; + private F inhalt2; + + public void setInhalt(T inhalt, F inhalt2 ) { + this.inhalt = inhalt; + this.inhalt2 = inhalt2; + } + + public T getInhalt() { + + return inhalt; + + } + + public F getInhalt2() { + return inhalt2; + } + +} diff --git a/Programmierung2/src/oop/Generics/EinfachesBeispiel.java b/Programmierung2/src/oop/Generics/EinfachesBeispiel.java new file mode 100644 index 0000000..a67b15a --- /dev/null +++ b/Programmierung2/src/oop/Generics/EinfachesBeispiel.java @@ -0,0 +1,61 @@ +package oop.Generics; + +import java.util.ArrayList; + +public class EinfachesBeispiel { + + + + public static void main(String[] args) { + + + + + int[] intArray = {1,2,3,4,5}; + double[] doubleArray = {1.1,2.2,3.3,4.12,4.4}; + float[] floatArray = {1.1f,2.2f,3.3f,4.12f,4.4f}; + + //auslesen(floatArray); + + // für Generic + Integer[] IntegerArray = {1,2,3,4,5}; + Double[] DoubleArray = {1.1,2.2,3.3,4.12,4.4}; + Float[] FloatArray = {1.1f,2.2f,3.3f,4.12f,4.4f}; + Character[] characterArray = {'a','b','c'}; + String[] stringArray = {"hallo","Welt"}; + + //auslesenGenerics(stringArray); + + + var variable = 1.1; + System.out.print(variable); + + } + public static void auslesen(int[] array) { + + for (int i : array) + System.out.print(i + " "); + } + + public static void auslesen(double[] array) { + + for (double i : array) + System.out.print(i + " "); + } + + + public static void auslesen(float[] array) { + + for (float i : array) + System.out.print(i + " "); + } + + // ich muss nicht immer die Mthode überladen wie oben die Methoden + // ich schicke also eine Objekt an diese Methode + public static void auslesenGenerics(obj[] array) { + + for (obj i : array) + System.out.print(i + " "); + } + +} diff --git a/Programmierung2/src/oop/Generics/Generics.java b/Programmierung2/src/oop/Generics/Generics.java new file mode 100644 index 0000000..275b635 --- /dev/null +++ b/Programmierung2/src/oop/Generics/Generics.java @@ -0,0 +1,19 @@ +package oop.Generics; + +public class Generics { + + /* + * Generics ist ein Konzept in der Programmierung, das es ermöglicht, Klassen, Methoden und Schnittstellen so zu schreiben + * ,dass sie mit beliebigen Datentypen arbeiten können. + * Anstatt festzulegen, dass eine Klasse oder Methode nur mit einem bestimmten Datentyp (z.B. int, String) arbeiten kann + * , können Generics verwendet werden, um den Datentyp flexibel zu gestalten. + * + * Generic wird durch: Namen ein Typparameter in spitzen Klammern (<>) angegeben wird + * + * Generic funktionert mit: + * 1. Klassen: (public class Box) + * 2. Methoden: (public static void printArray(T[] array)) + * 3. Interfaces: (public interface Container) + */ + +} diff --git a/Programmierung2/src/oop/Generics/Mietarbeiter.java b/Programmierung2/src/oop/Generics/Mietarbeiter.java new file mode 100644 index 0000000..30b0ba1 --- /dev/null +++ b/Programmierung2/src/oop/Generics/Mietarbeiter.java @@ -0,0 +1,23 @@ +package oop.Generics; + +public class Mietarbeiter { + + String name; + int alter; + + public Mietarbeiter(String name, int alter) { + super(); + this.name = name; + this.alter = alter; + } + + + + @Override + public String toString() { + return "Mietarbeiter [name=" + name + ", alter=" + alter + "]"; + } + + + +} diff --git a/Programmierung2/src/oop/Generics/Test.java b/Programmierung2/src/oop/Generics/Test.java new file mode 100644 index 0000000..e93b911 --- /dev/null +++ b/Programmierung2/src/oop/Generics/Test.java @@ -0,0 +1,22 @@ +package oop.Generics; + +import java.util.ArrayList; + +public class Test { + + public static void main(String[] args) { + + Mietarbeiter m = new Mietarbeiter("obai", 24); + AddMitarbeiter addMitarbeiter = new AddMitarbeiter(); + + addMitarbeiter.getM1().add(m); + + System.out.println(addMitarbeiter); + + + + //DateTyps d1 = new DateTyps<>(); + + } + +} diff --git a/Programmierung2/src/oop/InnereKlassen/Allgemein.java b/Programmierung2/src/oop/InnereKlassen/Allgemein.java new file mode 100644 index 0000000..3ac0ad7 --- /dev/null +++ b/Programmierung2/src/oop/InnereKlassen/Allgemein.java @@ -0,0 +1,25 @@ +package oop.InnereKlassen; + +public class Allgemein { + + /*Was ist das? + * - In Java gibt es vier Haupttypen von inneren Klassen (auch bekannt als Nested Classes) + * - Diese Klassen werden innerhalb einer anderen Klasse definiert und haben unterschiedliche Eigenschaften und Anwendungsfälle + * - es ist die Möglichkeit eine Klasse in eine andere Klasse zu binden + * - diese Klasse heißt "innere Klasse" + * - Java definiert vier Typen von inneren Klassen + * + * + * . Zusammenfassung: + * - Statische Innere Klassen: sind unabhängig von der äußeren Klasseninstanz und haben Zugriff nur auf die statischen Mitglieder der äußeren Klasse. + * - Nicht-statische Innere Klassen: benötigen eine Instanz der äußeren Klasse und haben Zugriff auf alle Mitglieder dieser Instanz. + * - Lokale Innere Klassen: sind methoden-spezifisch und können nur innerhalb der Methode verwendet werden, in der sie definiert sind. + * - Anonyme Innere Klassen: sind namenlose Klassen, die sofort erstellt werden und in der Regel verwendet werden, um eine Schnittstelle oder abstrakte Klasse schnell zu implementieren. + */ + class Außen{ + class Innen{ + + } + } + +} diff --git a/Programmierung2/src/oop/InnereKlassen/AnonymeInnereKlassen.java b/Programmierung2/src/oop/InnereKlassen/AnonymeInnereKlassen.java new file mode 100644 index 0000000..acc02aa --- /dev/null +++ b/Programmierung2/src/oop/InnereKlassen/AnonymeInnereKlassen.java @@ -0,0 +1,26 @@ +package oop.InnereKlassen; + +public class AnonymeInnereKlassen { + /* + * - hat keinen eigenen Name + * - Sie wird sofort in einer Ausdrücke definiert und instanziiert, oft als Implementierung einer Schnittstelle oder als Erweiterung einer Klasse, wenn nur eine einzige Instanz benötigt wird. + * - Sie wird sofort in einer Ausdrücke definiert und instanziiert, oft als Implementierung einer Schnittstelle oder als Erweiterung einer Klasse, wenn nur eine einzige Instanz benötigt wird. + * - sind ideal für einmalige Verwendungen + * - die verwendung von extends und imolements ist nicht erlaubt + */ + + interface MyInterface { + void display(); + } + + public static void main(String[] args) { + MyInterface obj = new MyInterface() { + @Override + public void display() { + System.out.println("Hello from Anonymous Inner Class"); + } + }; + obj.display(); + } + +} diff --git a/Programmierung2/src/oop/InnereKlassen/LokaleInnereKlasse.java b/Programmierung2/src/oop/InnereKlassen/LokaleInnereKlasse.java new file mode 100644 index 0000000..9f26a7a --- /dev/null +++ b/Programmierung2/src/oop/InnereKlassen/LokaleInnereKlasse.java @@ -0,0 +1,48 @@ +package oop.InnereKlassen; +/* + * - wird nur innerhalb einer Methode, eines Konstruktors oder eines Blocks definiert + * - Sie ist nur innerhalb des Umfangs sichtbar, in dem sie definiert ist. + * - Wird typischerweise verwendet, um eine Klasse zu definieren, die nur in einer bestimmten Methode benötigt wird. + * - lokale Schnittstellen (interfaces) sind nicht erlaubt + * + */ +public class LokaleInnereKlasse { + + final int x = 2; + private final String nichtLokal = "ich bin nicht Lokal"; + + public static void main(String[] args) { + // diese Klasse ist nur innerhalb der Main methode sichtbar + class LokaleKlasse{ + public String toString(){ + return "ich bin Lokal22"; + } + + } + + LokaleKlasse lokal = new LokaleKlasse(); + System.out.println(lokal.toString()); + + LokaleInnereKlasse test = new LokaleInnereKlasse(); + test.zweiteLokaleKlasse(); + + } + + public void zweiteLokaleKlasse() { + + final String ausgabe = "Ich bin lokal in einer methode"; + + class LokaleKlass2{ + private final String lokal = "Ich bin Lokal"; + + public void print() { + System.out.println(nichtLokal + " " + ausgabe + " "+ " " + lokal ); + } + + } + + LokaleKlass2 lokale2 = new LokaleKlass2(); + lokale2.print(); + + } +} diff --git a/Programmierung2/src/oop/InnereKlassen/NichtStatischeInnereKlasse.java b/Programmierung2/src/oop/InnereKlassen/NichtStatischeInnereKlasse.java new file mode 100644 index 0000000..8571ae0 --- /dev/null +++ b/Programmierung2/src/oop/InnereKlassen/NichtStatischeInnereKlasse.java @@ -0,0 +1,45 @@ +package oop.InnereKlassen; +/* + * - heißt auch (member class) + * - zählt auch als Attribut + * - kann auf alle Elemente der äußere Klasse zugreifen,die auch (private sind) + * - um ein Objekt der Hauptspeicher zu erzeugen, soll Objekt Computer erst erzeugt werden + * - unterschied zu statischen, da statischen ohne Objekt der äußere klassen sein können + * - nicht-statische-innere klassen dürfen keine statische Elemente definieren + * - sind wichtig für kompositionen + */ + +public class NichtStatischeInnereKlasse { + + public class Computer{ + // String static user = "obai"; verboten + String hersteller = "HP"; + Hauptspeicher speicher = new Hauptspeicher(); + // ist verboten + public static void print() { + System.out.println("hallo"); + } + + class Hauptspeicher{ + int groesse = 1024; + + public String gethersteller() { + //Zugriff auf das Attribut 'hersteller' der äußeren Klasse 'Computer' + return hersteller; + } + + + } + + } + + public static void main(String[] args) { + NichtStatischeInnereKlasse n1 = new NichtStatischeInnereKlasse(); + + NichtStatischeInnereKlasse.Computer c1 = n1.new Computer(); + Computer.Hauptspeicher h1= c1.new Hauptspeicher(); + System.out.println(h1.gethersteller() + " " + h1.groesse); + c1.print(); + } + +} diff --git a/Programmierung2/src/oop/InnereKlassen/StatischeInnereKlasse.java b/Programmierung2/src/oop/InnereKlassen/StatischeInnereKlasse.java new file mode 100644 index 0000000..e7ee5e3 --- /dev/null +++ b/Programmierung2/src/oop/InnereKlassen/StatischeInnereKlasse.java @@ -0,0 +1,80 @@ +package oop.InnereKlassen; +/* + * - diese ist die einfachste Variante einer innere Klasse + * - wege der Schachtelung wird dieser Typ im Englischen "nested top-Level class" genannt + * - diese Klasse kann das Gleiche wie "normale" Klassen oder Schnittstellen + * - statische innere Klasse benötigen keine Instanzen (Exemplare) der äußeren Klasse + * - statische innere Klasse werden nur sehr selten verwendet + * - Statische innere Klassen in Java können auf die statischen Elemente der äußeren Klasse zugreifen, + * (sobald) diese Elemente in der statischen inneren Klasse aufgerufen werden + * - der Zugriff von der äußeren Klasse auf die innere Klasse ist nur möglich, wenn die äußere Klasse eine Instanz der inneren Klasse erstellt, + es sei denn, die innere Klasse ist statisch + + - der statische Klasse soll anderen Name als der äußere Klasse haben + + * Wichtig: es gibt aber einen Weg, um auf die nicht-statische Elemente zuzugreifen (mit ein Objekt) + */ + +public class StatischeInnereKlasse { + public static int x = 2; + private int y = 1; + + // äußere Klasse + public static String außen() { + return "ich bin außen"; + } + + // Zugriff auf die innere Klasse von äußen + public int getf() { + Innereklasse k1 = new Innereklasse(); + return k1.f; + } + + //Innere klasse + public static class Innereklasse{ + public static int d = x; + public static int f = 20; + + public String toString() { + return "ich bin innen"; + } + //Aufruf der statische Attribute der x der äußern klasse + public int getx() { + return x; + } + + // Aufruf der nicht statische Elemente der äußere Klasse + public void printy(StatischeInnereKlasse ob) { + System.out.println(ob.y); + } + + //Aufruf der Konstruktor der äußere Klasse + void accessOuterConstructor() { + // Erstellen einer neuen Instanz der äußeren Klasse und Zugriff auf ihre Elemente + StatischeInnereKlasse newOuterInstance = new StatischeInnereKlasse(); + System.out.println("New Instance Variable: " + newOuterInstance.y); + } + + } + + + + + //zugreife auf innen und außen + public static void main(String[] args) { + + //zugriff nur auf das äußere Klasse + StatischeInnereKlasse außereKlasse = new StatischeInnereKlasse(); + System.out.println(außereKlasse.toString()); + //zugriff auf die elemente der innere Klasse von äußen + System.out.println(außereKlasse.getf()); + //System.out.println(außereKlasse.f); Fehler geht nicht + + //Zugriff auf die innere Klasse + StatischeInnereKlasse.Innereklasse innere = new StatischeInnereKlasse.Innereklasse(); + System.out.println(innere.getx());//2 + //System.out.println(innere.d); + innere.printy(außereKlasse); + } + +} diff --git a/Programmierung2/src/oop/Interface/Auto.java b/Programmierung2/src/oop/Interface/Auto.java new file mode 100644 index 0000000..dbcd99b --- /dev/null +++ b/Programmierung2/src/oop/Interface/Auto.java @@ -0,0 +1,58 @@ +package oop.Interface; + +public final class Auto implements Movable,SelfDrivable { + + int x,y; + int numberOffahrer; + + + public Auto() { + + } + + public Auto(int x, int y) { + this.x = x; + this.y = y; + } + + @Override + public void destination(String d) { + System.out.println("Destination = " + d); + } + + @Override + public void drive() { + System.out.println("drive"); + + } + + @Override + public void moveUp() { + y--; + } + + @Override + public void moveDown() { + y++; + } + + @Override + public void moveLeft() { + x--; + } + + @Override + public void moveRight() { + x++; + } + + public void newMethod() { + + System.out.print("SelfDrivable"); + } + + + + + +} diff --git a/Programmierung2/src/oop/Interface/Interface.java b/Programmierung2/src/oop/Interface/Interface.java new file mode 100644 index 0000000..fbf1a44 --- /dev/null +++ b/Programmierung2/src/oop/Interface/Interface.java @@ -0,0 +1,63 @@ +package oop.Interface; + +public class Interface { + + /*Was ist das? + * Eigentlich ist das fast wie die Abstrakte klassen außer: + * + * Implementierung Mehrfachvererbung + * abstrakte Klasse + * + * public interface klasseName + * alle Attribute werden automatisch (public static final) + * fast alle methoden werden automatisch (public abstract) + * ,außer die default methoden, die sollen aber in unterkalsse mit dem Wort public (soll geschrieben werden) implementiert werden und die können überschrieben werden + * Interface kann auch statiche methoden haben, die implementiert werden sollen + * default methoden sind nur in Interface erlaubt! + * final methoden sind nicht erlaubt, da sie abstrake sind und sollen überschreiben werden! + * private methoden sind erlaubt aber nur in der selben Klasse! + * Interface kann keinen Konstruktor haben! + * die untereklasse soll alle methode der Interface klasse implementieren + * + * + * NestedInterface: + * public interface NestedInterface { + void test(); + + interface InnerInterface { + default void test2() { + System.out.print("Innerinterface"); + } + } + + implements wid durch NestedInterface.InnerInterface + + *Functional Interface: + * @FunctionalInterface + public interface Test2{ + int berechne(int a, int b); + + } + * @FunctionalInterface dieses Interfaceklasse kann nur + * (eine abstratke) methode haben aber unendlich viele + * default,static und private methoden haben + * + * Marker or Tagging Interface: + * ist ein Interface in Java, das keine Methoden oder Konstanten deklarier + * + * + * + * wichtig: + * . eine unterekalsse extends eine Obereklasse + * . eine normale oder final Klasse kann implements eine interface klasse + * . eine interface klasse extends eine interface klasse + * + * welche java types kann interface implementieren? + * 1. klassen + * 2. abstrakte klassen + * 3. nested Klassen (Verschateten klassen) + * 4. Enum + * 5. dynamic proxy + */ + +} diff --git a/Programmierung2/src/oop/Interface/Movable.java b/Programmierung2/src/oop/Interface/Movable.java new file mode 100644 index 0000000..345b620 --- /dev/null +++ b/Programmierung2/src/oop/Interface/Movable.java @@ -0,0 +1,15 @@ +package oop.Interface; + +public interface Movable { + + void moveUp(); + void moveDown(); + void moveLeft(); + void moveRight(); + + default void newMethod() { + + System.out.print("SelfDrivable"); + } + +} diff --git a/Programmierung2/src/oop/Interface/SelfDrivable.java b/Programmierung2/src/oop/Interface/SelfDrivable.java new file mode 100644 index 0000000..c5b792a --- /dev/null +++ b/Programmierung2/src/oop/Interface/SelfDrivable.java @@ -0,0 +1,30 @@ +package oop.Interface; + +public interface SelfDrivable { + String AUTO_NAME = "BMW"; // ist default public static final + + + void destination (String d); + void drive(); + + default void newMethod() { + + System.out.print("SelfDrivable"); + } + + + static void klasseMethode() { + + System.out.print("Statiche Methode"); + } + + private void hilfsMethode() { + System.out.println("Hilfsmethode, die von anderen Methoden im Interface genutzt wird"); + } + + default void standardMethode1() { + System.out.println("Standardmethode 1"); + hilfsMethode(); // Aufruf der privaten Methode innerhalb des Interfaces + } + +} diff --git a/Programmierung2/src/oop/Interface/Test.java b/Programmierung2/src/oop/Interface/Test.java new file mode 100644 index 0000000..b7f60eb --- /dev/null +++ b/Programmierung2/src/oop/Interface/Test.java @@ -0,0 +1,11 @@ +package oop.Interface; + + +public class Test { + + public static void main(String[] args) { + Movable a1 = new Auto(); + + } + +} diff --git a/Programmierung2/src/oop/Konstroktur/Konstroktur.java b/Programmierung2/src/oop/Konstroktur/Konstroktur.java new file mode 100644 index 0000000..80a03d4 --- /dev/null +++ b/Programmierung2/src/oop/Konstroktur/Konstroktur.java @@ -0,0 +1,124 @@ +package oop.Konstroktur; + +public class Konstroktur { + + private String name; + private String beschreibung; + private double price; + private int quantity; + private double discount; + private String color; + + + //Konstruktor: + /* + * Muss heißen wie die Klasse + * Muss public sein + * muss kein Return Wert haben + * kann nicht abstrakt, static, final oder private sein + * jedes Objekt kann nur eine einzige Konstruktor aufrufen + * this.attribute = parameter + * Default Konstroktur wird nur aufgerufen, wenn überhaupt kein Construktor haben + */ + + //Arten von Konstruktor: + + + //1. Default Konstroktur, wird automatisch aufgerufen, wenn wir kein Konstruktor erstellen + + //public Konstroktur() {} + + + + // 2. no-argument constructor für default werte + public Konstroktur() { + this.name = "Kein Name"; + this.beschreibung = "Kein Beschreibung"; + this.price = 0.0; + this.quantity = 0; + this.discount = 0.0; + + } + + //3.1 argument constructor für dynamische werte + public Konstroktur(String name, String beschreibung, double price, int quantity, double discount) { + this.name = name; + this.beschreibung = beschreibung; + this.price = price; + this.quantity = quantity; + this.discount = discount; + } + + //3.2 Aufruf eines andere Konstruktor ( Chaining) + public Konstroktur(String name, String beschreibung, double price, int quantity, double discount,String color) { + + this (name,beschreibung,price,quantity,discount); // Aufruf der Konstruktor + this.color = color; + } + + // 4.1 Mit unterschiedlichen datentypen aber gleiche Parametern + public Konstroktur(String n) { + this.name = "Kein Name"; + this.beschreibung = "Kein Beschreibung"; + this.price = 0.0; + this.quantity = 0; + this.discount = 0.0; + + } + + + // 4.2 Mit unterschiedlichen datentypen aber gleiche Parametern + public Konstroktur(int n) { + this.name = "Kein Name"; + this.beschreibung = "Kein Beschreibung"; + this.price = 0.0; + this.quantity = 0; + this.discount = 0.0; + + } + + // 5.1 andere Rheinfolge + public Konstroktur(String n, int z) { + this.name = "Kein Name"; + this.beschreibung = "Kein Beschreibung"; + this.price = 0.0; + this.quantity = 0; + this.discount = 0.0; + + } + + + // 5.2 andere Rheinfolge + public Konstroktur(int z , String n) { + this.name = "Kein Name"; + this.beschreibung = "Kein Beschreibung"; + this.price = 0.0; + this.quantity = 0; + this.discount = 0.0; + } + + + // 6. Copy Constructor (dient dazu, Werte eines Objektes in anderem Objekt zu speicher) + public Konstroktur(Konstroktur k1) { + this.name = k1.name; + this.beschreibung = k1.beschreibung; + this.price = k1.price; + this.quantity = k1.quantity; + this.discount = k1.discount; + + } + + + + + public void display() { + + System.out.println("Name = " + name); + System.out.println("Beschreibung = " + beschreibung); + System.out.println("price = " + price); + System.out.println(" quantity = " + quantity); + System.out.println("discount = " + discount); + } + + +} diff --git a/Programmierung2/src/oop/Polymorphism/DailyMitarbeiter.java b/Programmierung2/src/oop/Polymorphism/DailyMitarbeiter.java new file mode 100644 index 0000000..554af4f --- /dev/null +++ b/Programmierung2/src/oop/Polymorphism/DailyMitarbeiter.java @@ -0,0 +1,35 @@ +package oop.Polymorphism; + +public class DailyMitarbeiter extends Mitarbeiter { + private double Werktagspreis; + private int tagesrate; + + public double getWerktagspreis() { + return Werktagspreis; + } + + public void setWerktagspreis(double werktagspreis) { + Werktagspreis = werktagspreis; + } + + public int getTagesrate() { + return tagesrate; + } + + public void setTagesrate(int tagesrate) { + this.tagesrate = tagesrate; + } + + public DailyMitarbeiter() {} + + + public DailyMitarbeiter(String name, String adresse, String abteilung, String email, double gehalt, double Werktagspreis,int tagesrate) { + super(name, adresse, abteilung, email, gehalt); + this.Werktagspreis = Werktagspreis; + this.tagesrate = tagesrate; + } + + + + +} diff --git a/Programmierung2/src/oop/Polymorphism/GehaltMitarbeiter.java b/Programmierung2/src/oop/Polymorphism/GehaltMitarbeiter.java new file mode 100644 index 0000000..3ed3dfe --- /dev/null +++ b/Programmierung2/src/oop/Polymorphism/GehaltMitarbeiter.java @@ -0,0 +1,31 @@ +package oop.Polymorphism; + +public class GehaltMitarbeiter extends Mitarbeiter { + + double bouns; + + public GehaltMitarbeiter() {} + + public double getBouns() { + return bouns; + } + + public void setBouns(double bouns) { + this.bouns = bouns; + } + + public GehaltMitarbeiter(String name, String adresse, String abteilung, String email, double gehalt,double bouns) { + super(name, adresse, abteilung, email, gehalt); + this.bouns = bouns; + + } + + @Override + public double getGehalt() { + return super.getGehalt() + this.bouns; + } + // entweder super.getGehalt() + // oder gehalt von private zu protected umwandlen + + +} diff --git a/Programmierung2/src/oop/Polymorphism/HourlyMitarbeiter.java b/Programmierung2/src/oop/Polymorphism/HourlyMitarbeiter.java new file mode 100644 index 0000000..8aca14a --- /dev/null +++ b/Programmierung2/src/oop/Polymorphism/HourlyMitarbeiter.java @@ -0,0 +1,43 @@ +package oop.Polymorphism; + +public class HourlyMitarbeiter extends Mitarbeiter { + + private double arbeitsstundenpreis; + private int stundensatz; + + public double getArbeitsstundenpreis() { + return arbeitsstundenpreis; + } + + public void setArbeitsstundenpreis(double arbeitsstundenpreis) { + this.arbeitsstundenpreis = arbeitsstundenpreis; + } + + public int getStundensatz() { + return stundensatz; + } + + public void setStundensatz(int stundensatz) { + this.stundensatz = stundensatz; + } + + + @Override + public double getGehalt() { + + return arbeitsstundenpreis * stundensatz; + } + + public HourlyMitarbeiter() {} + + + + public HourlyMitarbeiter(String name, String adresse, String abteilung, String email, double gehalt,double arbeitsstundenpreis,int stundensatz ) { + super(name, adresse, abteilung, email, gehalt); + this.arbeitsstundenpreis = arbeitsstundenpreis; + this.stundensatz = stundensatz; + } + + + +} diff --git a/Programmierung2/src/oop/Polymorphism/Mitarbeiter.java b/Programmierung2/src/oop/Polymorphism/Mitarbeiter.java new file mode 100644 index 0000000..87ae933 --- /dev/null +++ b/Programmierung2/src/oop/Polymorphism/Mitarbeiter.java @@ -0,0 +1,60 @@ +package oop.Polymorphism; + +public class Mitarbeiter { + + private String name; + private String adresse; + private String abteilung; + private String email; + private double gehalt; + + + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getAdresse() { + return adresse; + } + public void setAdresse(String adresse) { + this.adresse = adresse; + } + + public String getAbteilung() { + return abteilung; + } + + public void setAbteilung(String abteilung) { + this.abteilung = abteilung; + } + + public String getEmail() { + return email; + } + public void setEmail(String email) { + this.email = email; + } + + public double getGehalt() { + return gehalt; + } + public void setGehalt(double gehalt) { + this.gehalt = gehalt; + } + + public Mitarbeiter(String name, String adresse, String abteilung, String email, double gehalt) { + this.name = name; + this.adresse = adresse; + this.abteilung = abteilung; + this.email = email; + this.gehalt = gehalt; + } + + public Mitarbeiter() {} + +} diff --git a/Programmierung2/src/oop/Polymorphism/Polymorphism.java b/Programmierung2/src/oop/Polymorphism/Polymorphism.java new file mode 100644 index 0000000..1efe6e4 --- /dev/null +++ b/Programmierung2/src/oop/Polymorphism/Polymorphism.java @@ -0,0 +1,30 @@ +package oop.Polymorphism; + +public class Polymorphism { + + + /*Was ist das? + * + * Method Overloading: Schlüsselwort (ohne) + * + * Compile-time Polymorphism (Early binding or static binding) (frühe Bindung). + * + * • Statische Methoden können überladen werden + * • den selben Namen + * • Parameterlist unterscheiden sich in der Anzahl oder dem type der Parameter + * • innerhalb der selben oder abgeleiteten Klasse + * + * Method Overriding: Schlüsselwort (@Override) + * + * runtime-time Polymorphism (Late binding or Dynamic Polymorphism) (späte Bindung) + * + * • Statische Methoden können nicht überschreiben werden + * • geht nur in Kindklasse also nur in Verebung mit (@Override) + * • den selben Namen + * • den selben Rückgabetyp + * • die selbe Parameterliste + * • aber anderes Verhalten + */ + + +} diff --git a/Programmierung2/src/oop/Polymorphism/Test.java b/Programmierung2/src/oop/Polymorphism/Test.java new file mode 100644 index 0000000..b12befb --- /dev/null +++ b/Programmierung2/src/oop/Polymorphism/Test.java @@ -0,0 +1,53 @@ +package oop.Polymorphism; + +public class Test { + + public static void main(String[] args) { + + Mitarbeiter[] refarray = new Mitarbeiter[4]; // das geht auch + refarray[0] = new Mitarbeiter(); + refarray[1] = new GehaltMitarbeiter(); + refarray[2] = new DailyMitarbeiter(); + refarray[3] = new HourlyMitarbeiter(); + + for (int i = 0; i A ) Class B erbt von Class A + * 2. Miultilever Verebung:(C-> B -> A ) Class C erbt von Class B und Class B erbt von Class A + * 3. Hierarchical Verebung: ( B -> A und C -> A) Class B erbt von A und C von A + * + * Wichtig: Muliverebung ist in Java nicht unterstützt + * Lösungsmöglichkeit (Interface) also mit Interface kann + * ( B -> A und B -> C) + */ + + +/* + * verebung mit schlüsselwort extends + * Kindklasse ruft ihre constructor und ihre VaterKonstroktor + * constructor kann nicht verebt werden aber wir von kindklasse aufgerufen + * also kindklasse gibt Parentconstructor und ihre constructor aus + * + */ +public class Verebung { + + protected String name; + protected String emailAdresse; + protected String phone; + protected String wohnung; + protected String adresse; + protected int gerbutstag; + + + public Verebung() { + + System.out.println("Partentklasse"); + } + + + + public Verebung(String name,String emailAdresse,String phone, String wohnung, String adresse,int gerbutstag) { + this.name = name; + this.emailAdresse = emailAdresse; + this.phone = phone; + this.wohnung = wohnung; + this.adresse = adresse; + this.gerbutstag = gerbutstag; + + } + + + public String getName() { + return name; + } + + + public void setName(String name) { + this.name = name; + } + + + public String getEmailAdresse() { + return emailAdresse; + } + + + public void setEmailAdresse(String emailAdresse) { + this.emailAdresse = emailAdresse; + } + + + public String getPhone() { + return phone; + } + + + public void setPhone(String phone) { + this.phone = phone; + } + + + public String getWohnung() { + return wohnung; + } + + + public void setWohnung(String wohnung) { + this.wohnung = wohnung; + } + + + public String getAdresse() { + return adresse; + } + + + public void setAdresse(String adresse) { + this.adresse = adresse; + } + + + public int getGerbutstag() { + return gerbutstag; + } + + + public void setGerbutstag(int gerbutstag) { + this.gerbutstag = gerbutstag; + } + + +} diff --git a/Programmierung2/src/oop/Verebung/Verebung2.java b/Programmierung2/src/oop/Verebung/Verebung2.java new file mode 100644 index 0000000..42b3eef --- /dev/null +++ b/Programmierung2/src/oop/Verebung/Verebung2.java @@ -0,0 +1,38 @@ +package oop.Verebung; + +public class Verebung2 extends Verebung { + + String projktName; + + public Verebung2(String name,String emailAdresse,String phone, String wohnung, String adresse,int gerbutstag,String projktName) { + /* + * wichtig: Super soll erste geschrieben werden + * Super benutzen wir nur für Parentklass in seinem Kindklass + * + * Also ist falsch: + * this.projktName = projktName; + * super(name,emailAdresse,phone, wohnung,adresse,gerbutstag); + * + * Das geht auch: + * super.attribute + * super.methode + */ + + + //super(); // default constructor aufrufen + super(name,emailAdresse,phone, wohnung,adresse,gerbutstag);// constructor mit Argumenten aufrufen + this.projktName = projktName; + } + + public String getprojktName() { + + + return projktName; + } + + public void setprojktName(String projktName) { + + this.projktName = projktName; + } + +} diff --git a/Programmierung2/src/oop/Verebung/Verebung3.java b/Programmierung2/src/oop/Verebung/Verebung3.java new file mode 100644 index 0000000..70325db --- /dev/null +++ b/Programmierung2/src/oop/Verebung/Verebung3.java @@ -0,0 +1,10 @@ +package oop.Verebung; + +public class Verebung3 extends Verebung2 { + + public Verebung3(String name,String emailAdresse,String phone, String wohnung, String adresse,int gerbutstag,String projktName) { + super(name,emailAdresse,phone, wohnung,adresse,gerbutstag,projktName);// constructor mit Argumenten aufrufen + System.out.println("Kindklasse 2"); + } + +} diff --git a/Programmierung2/src/Übungen/Abrechnung.java b/Programmierung2/src/Übungen/Abrechnung.java new file mode 100644 index 0000000..7534cea --- /dev/null +++ b/Programmierung2/src/Übungen/Abrechnung.java @@ -0,0 +1,27 @@ +package Übungen; +public abstract class Abrechnung { + private int periode; + private Mitarbeiter mitarbeiter; + + public Abrechnung(int periode, Mitarbeiter m){ + + this.periode = periode; + this.mitarbeiter = m; + } + + public int getPeriode() { + + return this.periode; + } + public Mitarbeiter getMitarbeiter() { + + return this.mitarbeiter; + } + public abstract double getVerdienst(); + + @Override + public String toString() { + return "Periode= " + periode + ", Mitarbeiter= " + mitarbeiter.toString() + ", Verdienst= " + getVerdienst(); + } + +} \ No newline at end of file diff --git a/Programmierung2/src/Übungen/BankSystem.java b/Programmierung2/src/Übungen/BankSystem.java new file mode 100644 index 0000000..f16f65b --- /dev/null +++ b/Programmierung2/src/Übungen/BankSystem.java @@ -0,0 +1,186 @@ +package Übungen; +import java.util.ArrayList; +import java.util.Scanner; +public class BankSystem { + + protected String name; + protected String vorname; + protected String password; + protected String email; + protected double kontosstand; + protected int alter; + protected Scanner scanner; + protected ArrayList speicher; + protected static int nextKundenNummer; // Statische Variable für die nächste Kunden-ID + + public BankSystem() {}; + + public BankSystem(String name, String vorname, String password , String email,int alter) { + this.name = name; + this.vorname = vorname; + this.password = password; + this.email = email; + this.kontosstand = 0; // 0€ + this.setAlter(alter); + this.scanner = new Scanner(System.in); + this.speicher = new ArrayList<>(); + nextKundenNummer++; + } + + public void ueberweisung(BankSystem empfaenger) { + + System.out.println("KontoStand: " + this.kontosstand + " €" + "\n" + this.getVorname() + " " + this.getName()); + + System.out.println("Geben Sie den Betrag ein: "); + double betrag = scanner.nextDouble(); + scanner.nextLine(); + System.out.println("Geben Sie den Password ein: "); + String password = scanner.nextLine(); + + if (checkKontoStand(betrag) && checkPassword(password)) { + this.kontosstand -= betrag; + speicher.add(- (betrag)); + + empfaenger.kontosstand +=betrag; + empfaenger.speicher.add(betrag); + System.out.println("Das wurde erfolgreich überwiesen"); + } + + else + System.out.println("Du hast kein genug Geld auf deinem Konto!"); + } + + public void kontoauszug(){ + + int zähler = 3; + System.out.print("Bitte geben Sie erst den Password ein: "); + String password = scanner.nextLine(); + while(!checkPassword(password) && zähler > 1) { + zähler--;//2 + System.out.println("Du hast " + zähler + " Versuche."); + System.out.print("Bitte geben Sie erst den Password ein: "); + password = scanner.nextLine(); + + } + if (zähler == 1) + System.err.println("Dein Konto wurde gespert!"); + + else { + double auszahlung = 0; + double einzahlung = 0; + for (double i : speicher) { + if (i < 0) { + System.out.println("Ihre Auszahlung: "+ i); + auszahlung += i; + } + else { + System.out.println("Ihre Einzahlung: "+ i); + einzahlung += i; + } + } + System.out.println("Die Summe alle Auszahlungen = "+ auszahlung); + System.out.println("Die Summe alle Einzahlungen = "+ einzahlung); + System.out.println("Dein aktuelles Kontostand = "+ this.getKontosstand()); + } + + } + + private boolean checkPassword (String password) { + return this.password.equals(password); + } + + protected boolean checkKontoStand(double geld) { + return geld <= this.kontosstand; + } + + + public void auszahlen(){ + + System.out.println("Bitte geben Sie den Betrag ein: "); + + double auszahlen = scanner.nextDouble(); + scanner.nextLine(); + System.out.print("Bitte geben Sie den Password ein: "); + String password = scanner.nextLine(); + if (checkPassword(password)) { + if (checkKontoStand(auszahlen)) { + this.kontosstand -= auszahlen; + speicher.add(-(auszahlen)); + System.out.println("Auszahlung erfolgreich! Neuer Kontostand: " + this.kontosstand); + + } + + else + System.out.println("Geld reicht nicht aus!"); + } + + else + System.out.println("falsches Password!"); + } + + + + public void addGeld(double geld) { + + this.kontosstand += geld; + speicher.add(geld); + System.out.println("Einzahlung erfolgreich! Neuer Kontostand: " + this.kontosstand); + + } + + + + + + @Override + public String toString() { + return "BankSystem [name=" + name + ", vorname=" + vorname + ", password=" + password + ", email=" + email + + ", kontosstand=" + kontosstand + ", alter=" + alter + "]"; + } + + 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 String getEmail() { + return email; + } + public void setEmail(String email) { + this.email = email; + } + public double getKontosstand() { + return kontosstand; + } + public void setKontosstand(double kontosstand) { + this.kontosstand = kontosstand; + } + + public int getAlter() { + return alter; + } + + public void setAlter(int alter) { + if (alter <= 20) + System.out.println("Nein,du musst Kundenart kriegen!"); + else + this.alter = alter; + } + + + + +} diff --git a/Programmierung2/src/Übungen/BlackJack/BlackJack.java b/Programmierung2/src/Übungen/BlackJack/BlackJack.java new file mode 100644 index 0000000..62ea766 --- /dev/null +++ b/Programmierung2/src/Übungen/BlackJack/BlackJack.java @@ -0,0 +1,273 @@ +package Übungen.BlackJack; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Random; +import java.util.Scanner; + +// Modell +public class BlackJack { + private String spielerName; + private int guthaben; + private int punkte; + private int speichereEinsatz; + private boolean hitspiele; + + public BlackJack(String spielerName, int guthaben) { + this.spielerName = spielerName; + this.guthaben = guthaben; + this.punkte = 0; + this.speichereEinsatz = 0; + this.hitspiele = false; + } + + public int getSpeichereEinsatz() { + return speichereEinsatz; + } + + public void setSpeichereEinsatz(int speichereEinsatz) { + this.speichereEinsatz = speichereEinsatz; + } + + public String getSpielerName() { + return spielerName; + } + + public void setSpielerName(String spielerName) { + this.spielerName = spielerName; + } + + public int getGuthaben() { + return guthaben; + } + + public void addGuthaben(int betrag) { + this.guthaben += betrag; + } + + public void subtrahiereGuthaben(int betrag) { + this.guthaben -= betrag; + } + + public int getPunkte() { + return punkte; + } + + public void addPunkte(int punkte) { + this.punkte += punkte; + } + + public boolean isHitspiele() { + return hitspiele; + } + + public void setHitspiele(boolean hitspiele) { + this.hitspiele = hitspiele; + } + + @Override + public String toString() { + return "Spieler [Name=" + spielerName + ", Guthaben=" + guthaben + "€]"; + } +} + +// Die GUI klasse oder View +class BlackJackView { + private Scanner scanner; + + public BlackJackView() { + scanner = new Scanner(System.in); + } + + public void zeigeSpielerDetails(BlackJack spieler) { + System.out.println(spieler.getSpielerName() + " hat " + spieler.getGuthaben() + "€ und " + spieler.getPunkte() + + " Punkte."); + } + + public void zeigeNachricht(String nachricht) { + System.out.println(nachricht); + } + + public int frageEinsatz() { + System.out.println("Wähle einen Einsatz von: [5€, 10€, 25€, 100€]"); + return scanner.nextInt(); + } + + public String frageObGuthabenAufladen() { + System.out.println("Du hast nicht genug Guthaben. Möchtest du Guthaben aufladen? Ja/Nein"); + return scanner.next(); + } + + public int frageGuthabenBetrag() { + System.out.println("Wie viel möchtest du aufladen?"); + return scanner.nextInt(); + } + + public String frageObHitOderStand() { + System.out.println("Du hast nicht genug Guthaben. Möchtest du Guthaben aufladen? Ja/Nein"); + return scanner.next(); + } + + public void schließeScanner() { + scanner.close(); + } +} + +// Controller verwaltung das Spielabluaf +class Spiel { + + private BlackJack spieler1; + private BlackJack spieler2; + private ArrayList kartendeck; + private Random random; + private ArrayList erlaubteEinsätze; + private BlackJackView view; + + public Spiel(BlackJack spieler1, BlackJack spieler2, BlackJackView view) { + this.spieler1 = spieler1; + this.spieler2 = spieler2; + this.view = view; + this.random = new Random(); + this.erlaubteEinsätze = new ArrayList<>(); + kartendeck = new ArrayList<>(); + initialisiereKartendeck(); + } + + public void initialisiereKartendeck() { + for (int i = 1; i <= 11; i++) { + kartendeck.add(i); + } + Collections.shuffle(kartendeck); + } + + public ArrayList getKartendeck() { + return kartendeck; + } + + public boolean guthabenAufladen(BlackJack spieler) { + String antwort = view.frageObGuthabenAufladen(); + if (antwort.equalsIgnoreCase("ja")) { + int betrag = view.frageGuthabenBetrag(); + if (betrag > 0) { + spieler.addGuthaben(betrag); + view.zeigeNachricht("Dein neues Guthaben: " + spieler.getGuthaben() + "€"); + return true; + } + } + return false; + } + + public boolean einsatzBestimmen(BlackJack spieler) { + erlaubteEinsätze.add(5); + erlaubteEinsätze.add(10); + erlaubteEinsätze.add(25); + erlaubteEinsätze.add(100); + + boolean einsatzAkzeptiert = false; + view.zeigeNachricht( + "Hallo " + spieler.getSpielerName() + ", dein aktuelles Guthaben: " + spieler.getGuthaben() + "€"); + while (!einsatzAkzeptiert) { + if (spieler.getGuthaben() < 5) { + if (guthabenAufladen(spieler)) { + continue; + } else { + return false; + } + } + + int einsatz = view.frageEinsatz(); + if (!erlaubteEinsätze.contains(einsatz)) { + view.zeigeNachricht("Falsche Eingabe. Bitte versuche es erneut."); + continue; + } + + if (einsatz > spieler.getGuthaben()) { + if (guthabenAufladen(spieler)) { + continue; + } else { + return false; + } + } + + if (erlaubteEinsätze.contains(einsatz)) { + spieler.setSpeichereEinsatz(einsatz); + spieler.subtrahiereGuthaben(einsatz); + view.zeigeNachricht("Neues Guthaben: " + spieler.getGuthaben() + "€"); + einsatzAkzeptiert = true; + } + } + return einsatzAkzeptiert; + } + + public void zweiKartenZiehen() { + int punkte1 = zieheZweiKarten(spieler1); + view.zeigeNachricht(spieler1.getSpielerName() + " hat " + punkte1 + " Punkte."); + + int punkte2 = zieheZweiKarten(spieler2); + view.zeigeNachricht(spieler2.getSpielerName() + " hat " + punkte2 + " Punkte."); + } + + private int zieheZweiKarten(BlackJack spieler) { + int ersteKarte = kartendeck.get(random.nextInt(kartendeck.size())); + int zweiteKarte = kartendeck.get(random.nextInt(kartendeck.size())); + int summe = ersteKarte + zweiteKarte; + spieler.addPunkte(summe); + return summe; + } + + public void gewinnerPrüfen(BlackJack spieler1, BlackJack spieler2) { + if (spieler1.getPunkte() < 22 && (spieler1.getPunkte() > spieler2.getPunkte() || spieler2.getPunkte() > 21)) { + int gewinn = spieler1.getSpeichereEinsatz() * 2; + spieler1.addGuthaben(gewinn); + view.zeigeNachricht( + spieler1.getSpielerName() + " hat gewonnen! Neues Guthaben: " + spieler1.getGuthaben() + "€"); + } else if (spieler2.getPunkte() < 22 + && (spieler2.getPunkte() > spieler1.getPunkte() || spieler1.getPunkte() > 21)) { + int gewinn = spieler2.getSpeichereEinsatz() * 2; + spieler2.addGuthaben(gewinn); + view.zeigeNachricht( + spieler2.getSpielerName() + " hat gewonnen! Neues Guthaben: " + spieler2.getGuthaben() + "€"); + } else { + view.zeigeNachricht("Unentschieden!"); + } + } + + public void bestimmeSpieabluaf(BlackJack spieler) { + view.zeigeNachricht("------------------------------------------"); + view.zeigeNachricht("Willkommen im Blackjack-Spiel:"); + zweiKartenZiehen(); + spieler.setHitspiele(true); + while (spieler.isHitspiele()) { + if (spieler.getPunkte() >= 21) + spieler.setHitspiele(false); + + if (spieler.isHitspiele()) { + view.zeigeNachricht(spieler.getSpielerName() + " : Möchten Sie hit oder stand? Aktuelle Hand: " + + spieler.getPunkte()); + String auswahl = view.frageObHitOderStand(); + + if (auswahl.equalsIgnoreCase("hit")) { + eineKarteZiehen(spieler); + spielerPunkteAnzeigen(spieler); + } else if (auswahl.equalsIgnoreCase("stand")) { + spieler.setHitspiele(false); + spielerPunkteAnzeigen(spieler); + } else { + view.zeigeNachricht("Falsche Eingabe: Bitte geben Sie entweder 'hit' oder 'stand' ein."); + continue; + } + } + } + } + + public void eineKarteZiehen(BlackJack spieler) { + int karte = kartendeck.get(random.nextInt(kartendeck.size())); + spieler.addPunkte(karte); + view.zeigeNachricht(spieler.getSpielerName() + " hat " + spieler.getPunkte() + " Punkte."); + } + + public void spielerPunkteAnzeigen(BlackJack spieler) { + view.zeigeNachricht(spieler.getSpielerName() + " hat " + spieler.getPunkte() + " Punkte."); + } + +} diff --git a/Programmierung2/src/Übungen/BlackJack/JunitTest.java b/Programmierung2/src/Übungen/BlackJack/JunitTest.java new file mode 100644 index 0000000..4e3fbd8 --- /dev/null +++ b/Programmierung2/src/Übungen/BlackJack/JunitTest.java @@ -0,0 +1,40 @@ +package Übungen.BlackJack; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.Collections; + +import org.junit.jupiter.api.Test; + +class JunitTest { + // (expected,actual (welche wert gibt der Methode zurück?),message fehle) + + @Test + void modellKlasse() { + // assertEquals(überprüft Parameter miteinander) + BlackJack t1 = new BlackJack("obai",20); + BlackJack t2 = new BlackJack("omar",21); + BlackJackView v1 = new BlackJackView(); + Spiel spie1 = new Spiel(t1,t2,v1); +// assertEquals("obai", t1.getSpielerName(), "Der Name sollte 'obai' sein."); +// assertEquals(21,t1.getGuthaben(),"Guthaben habe stimmen nicht"); +// assertNotNull(t1,"es ist nicht null"); + + // teste arrayList zahlen +// ArrayList kartendeck = new ArrayList<>(); +// for (int i = 1; i <= 11; i++) { +// kartendeck.add(i); +// } +// assertEquals(kartendeck,spie1.getKartendeck()); + + //aktziptieren nur einen Bedinung die entweder wahr oder true ist +// assertFalse(spie1.einsatzBestimmen(t1)); +// assertFalse(spie1.einsatzBestimmen(t1)); + + spie1.zweiKartenZiehen(); + } + +} diff --git a/Programmierung2/src/Übungen/BlackJack/Test.java b/Programmierung2/src/Übungen/BlackJack/Test.java new file mode 100644 index 0000000..78db6b9 --- /dev/null +++ b/Programmierung2/src/Übungen/BlackJack/Test.java @@ -0,0 +1,35 @@ +package Übungen.BlackJack; +import java.util.ArrayList; +import java.util.Scanner; + +public class Test { + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + + BlackJack spieler1 = new BlackJack("Obai", 500); + BlackJack spieler2 = new BlackJack("abd", 100); + BlackJackView spiel1 = new BlackJackView(); + + System.out.println(spieler1); + System.out.println(spieler2); + System.out.println(); + + + Spiel newSpiel = new Spiel(spieler1, spieler2,spiel1); + boolean bestimmespieler; + + bestimmespieler = newSpiel.einsatzBestimmen(spieler1); + if (bestimmespieler) + bestimmespieler = newSpiel.einsatzBestimmen(spieler2); + + + if (bestimmespieler) { + newSpiel.zweiKartenZiehen(); + newSpiel.bestimmeSpieabluaf(spieler1); + } + + spiel1.schließeScanner(); + } + +} diff --git a/Programmierung2/src/Übungen/GehaltsAbrechnung.java b/Programmierung2/src/Übungen/GehaltsAbrechnung.java new file mode 100644 index 0000000..e42688f --- /dev/null +++ b/Programmierung2/src/Übungen/GehaltsAbrechnung.java @@ -0,0 +1,16 @@ +package Übungen; +public class GehaltsAbrechnung extends Abrechnung { + + private double gehalt; + + public GehaltsAbrechnung(int periode, Mitarbeiter m, double gehalt){ + + super(periode, m); + this.gehalt = gehalt; + } + + @Override + public double getVerdienst() { + return this.gehalt; + } +} diff --git a/Programmierung2/src/Übungen/Kunden.java b/Programmierung2/src/Übungen/Kunden.java new file mode 100644 index 0000000..7d64d7c --- /dev/null +++ b/Programmierung2/src/Übungen/Kunden.java @@ -0,0 +1,26 @@ +package Übungen; +public class Kunden { + + public static void main(String[] args) { + BankSystem kunde1 = new BankSystem("Albek","Obai","12345","obay@gmail.com",25); + + kunde1.addGeld(50000); + System.out.println(kunde1.toString()); + + System.out.println(); + System.out.println(); + + BankSystem s1 = new SchuelerKonto("Albek","Obai","12345","obay@gmail.com",12,"Justus",9); + s1.addGeld(120); + + System.out.println(s1.toString()); + + + + +// KundenBank k1 = new KundenBank(); +// k1.setSpeicherKunde(kunde1);; +// System.out.println(k1.getSpeicherKunde()); + } + +} diff --git a/Programmierung2/src/Übungen/KundenBank.java b/Programmierung2/src/Übungen/KundenBank.java new file mode 100644 index 0000000..775d5da --- /dev/null +++ b/Programmierung2/src/Übungen/KundenBank.java @@ -0,0 +1,24 @@ +package Übungen; + +import java.util.ArrayList; + +public class KundenBank { + + private ArrayList speicherKunde = new ArrayList<>(); + + public ArrayList getSpeicherKunde() { + return speicherKunde; + } + + public void setSpeicherKunde(BankSystem speicherKunde) { + this.speicherKunde.add(speicherKunde); + } + + @Override + public String toString() { + return "KundenBank [BankKunden=" + speicherKunde + "]"; + } + + + +} diff --git a/Programmierung2/src/Übungen/Lohnabrechnung.java b/Programmierung2/src/Übungen/Lohnabrechnung.java new file mode 100644 index 0000000..db35059 --- /dev/null +++ b/Programmierung2/src/Übungen/Lohnabrechnung.java @@ -0,0 +1,18 @@ +package Übungen; +public class Lohnabrechnung extends Abrechnung { + + private double stundenLohn; + private double anzahlStunden; + + public Lohnabrechnung(int periode, Mitarbeiter m, double stundenLohn, int anzahlStunden){ + + super(periode, m); + this.stundenLohn = stundenLohn; + this.anzahlStunden = anzahlStunden; + } + + public double getVerdienst(){ + + return stundenLohn * anzahlStunden; + } +} diff --git a/Programmierung2/src/Übungen/Mitarbeiter.java b/Programmierung2/src/Übungen/Mitarbeiter.java new file mode 100644 index 0000000..44263d3 --- /dev/null +++ b/Programmierung2/src/Übungen/Mitarbeiter.java @@ -0,0 +1,27 @@ +package Übungen; +public class Mitarbeiter { + protected int id; + protected String name; + private static int counterID = 0; + + + public Mitarbeiter(){} + + public Mitarbeiter(String name){ + + this.id = ++counterID; + this.name = name; + } + + public String getName(){ + return name; + } + public void setName(String name){ + this.name = name; + } + + @Override + public String toString(){ + return "Name = " + name + ", Id = " + id; + } +} diff --git a/Programmierung2/src/Übungen/PersonalVerwaltung.java b/Programmierung2/src/Übungen/PersonalVerwaltung.java new file mode 100644 index 0000000..56dcaef --- /dev/null +++ b/Programmierung2/src/Übungen/PersonalVerwaltung.java @@ -0,0 +1,45 @@ +package Übungen; +import java.lang.reflect.Array; +import java.util.ArrayList; + +public class PersonalVerwaltung extends Mitarbeiter { + + ArrayList mitarbeiterList = new ArrayList<>(); + ArrayList AbrechnungenList = new ArrayList<>(); + + public void setAbrechnung(Abrechnung ab){ + this.AbrechnungenList.add(ab); + } + + public ArrayList getAbrechnungs(){ + + return this.AbrechnungenList; + } + + public void removeAbrechnung(Abrechnung ab){ + + if (this.AbrechnungenList.contains(ab)) + this.AbrechnungenList.remove(ab); + else + System.err.println("Abrechnung ist nicht da!"); + } + + + public void setMitarbeiter(Mitarbeiter ma){ + + this.mitarbeiterList.add(ma); + } + public ArrayList getMitarbeiter(){ + + return mitarbeiterList; + } + + public void removeMitarbeiter(Mitarbeiter m1){ + if (this.mitarbeiterList.contains(m1)) + this.mitarbeiterList.remove(m1); + else + System.err.println("Mitarbeiter existiert nicht!");; + } + + +} diff --git a/Programmierung2/src/Übungen/Radio.java b/Programmierung2/src/Übungen/Radio.java new file mode 100644 index 0000000..c1c2d9c --- /dev/null +++ b/Programmierung2/src/Übungen/Radio.java @@ -0,0 +1,60 @@ +package Übungen; +public class Radio { + boolean eingeschaltet; + int lautstaerker; + double frequenz; + + public Radio(){} + + public Radio(boolean eingeschaltet, int lautstaerker, double frequenz){ + + this.eingeschaltet = eingeschaltet; + this.lautstaerker = lautstaerker; + this.frequenz = frequenz; + } + + public void lauter(){ + if (this.eingeschaltet) + while (lautstaerker <= 10) + lautstaerker++; + else + System.err.println("Das Radio ist aus!"); + + System.out.println("Lautstärke des Radios= "+ lautstaerker); + } + + public void leiser(){ + if (this.eingeschaltet) + while (lautstaerker >= 0) + lautstaerker--; + else + System.out.println("Das Radio ist aus!"); + + System.out.println("Lautstärke des Radios= "+ lautstaerker); + } + + public String an(){ + this.eingeschaltet = true; + return "an"; + } + + public boolean aus(){ + return this.eingeschaltet = false; + } + + public void waehleSender(double frequenz){ + if (frequenz < 85.0 || frequenz > 110.0) + this.frequenz = 99.9; + else + this.frequenz = frequenz; + } + + @Override + public String toString(){ + if (this.eingeschaltet) + return"Radio an: Freq = " + this.frequenz + ", Laut = " + this.lautstaerker; + + return "Radio ist aus!"; + } + +} diff --git a/Programmierung2/src/Übungen/SchuelerKonto.java b/Programmierung2/src/Übungen/SchuelerKonto.java new file mode 100644 index 0000000..090547f --- /dev/null +++ b/Programmierung2/src/Übungen/SchuelerKonto.java @@ -0,0 +1,60 @@ +package Übungen; + +public class SchuelerKonto extends BankSystem { + + private String schulename; + private int klasse; + + public SchuelerKonto(String name, String vorname, String password, String email, int alter, String schulename, int klasse) { + super(name, vorname, password, email, alter); + this.schulename = schulename; + this.klasse = klasse; + } + + @Override + public void addGeld(double geld) { + if (this.kontosstand < 500) { + this.kontosstand += geld; + speicher.add(geld); + System.out.println("Einzahlung erfolgreich! Neuer Kontostand: " + this.kontosstand); + } else { + System.out.println("Du kannst keine neuen Einzahlungen vornehmen."); + } + } + + @Override + public void ueberweisung(BankSystem empfaenger) { + throw new UnsupportedOperationException("Überweisungen sind für Schülerkonten nicht erlaubt."); + } + + @Override + public void setAlter(int alter) { + if (alter > 20) + System.out.println("Nein, du kannst nicht die Kundenart Schueler haben!"); + else + this.alter = alter; + } + + @Override + public String toString() { + return "SchuelerKonto [Schulename=" + schulename + ", Klasse=" + klasse + ", name=" + name + ", vorname=" + + vorname + ", password=" + password + ", email=" + email + ", kontosstand=" + kontosstand + ", alter=" + + alter + "]"; + } + + public String getSchulename() { + return schulename; + } + + public void setSchulename(String schulename) { + this.schulename = schulename; + } + + public int getKlasse() { + return klasse; + } + + public void setKlasse(int klasse) { + this.klasse = klasse; + } +} diff --git a/Programmierung2/src/Übungen/StudentenKunden.java b/Programmierung2/src/Übungen/StudentenKunden.java new file mode 100644 index 0000000..743a2e0 --- /dev/null +++ b/Programmierung2/src/Übungen/StudentenKunden.java @@ -0,0 +1,7 @@ +package Übungen; + +public class StudentenKunden extends BankSystem { + + + +} diff --git a/Programmierung2/src/Übungen/TestMitarbeiter.java b/Programmierung2/src/Übungen/TestMitarbeiter.java new file mode 100644 index 0000000..53b49a6 --- /dev/null +++ b/Programmierung2/src/Übungen/TestMitarbeiter.java @@ -0,0 +1,20 @@ +package Übungen; +public class TestMitarbeiter { + + public static void main(String[] args) { + Mitarbeiter m1 = new Mitarbeiter("obai"); + System.out.println(m1.toString()); + + Mitarbeiter m2 = new Mitarbeiter("Omar"); + + PersonalVerwaltung p1 = new PersonalVerwaltung(); + p1.setMitarbeiter(m1); + p1.setMitarbeiter(m2); + p1.removeMitarbeiter(m1); + System.out.println(p1.getMitarbeiter()); + + GehaltsAbrechnung gh1 = new GehaltsAbrechnung(124, m2, 40); + System.out.println(gh1.toString()); + + } +} diff --git a/Programmierung2/src/Übungen/TestRadio.java b/Programmierung2/src/Übungen/TestRadio.java new file mode 100644 index 0000000..a9a48a1 --- /dev/null +++ b/Programmierung2/src/Übungen/TestRadio.java @@ -0,0 +1,13 @@ +package Übungen; +public class TestRadio { + + public static void main(String[] args) { + Radio r1 = new Radio(true,2,90); + //System.out.println(r1.toString()); + r1.waehleSender(75.0); + // System.out.println(r1.toString()); + r1.aus(); + System.out.println(r1.toString()); + } + +} diff --git a/Programmierung2/src/Übungen/Tic_Tac_Toe.java b/Programmierung2/src/Übungen/Tic_Tac_Toe.java new file mode 100644 index 0000000..21f9e5c --- /dev/null +++ b/Programmierung2/src/Übungen/Tic_Tac_Toe.java @@ -0,0 +1,111 @@ +package Übungen; +import java.util.Scanner; + +public class Tic_Tac_Toe { + static Scanner scan = new Scanner(System.in); + static String[][] spielField = new String[3][3]; + static final String playerx = "x" ; + static final String playero = "o" ; + + public static void main(String[] args){ + + + printSpielfeld(); + while (true) { + System.out.println("Bitte geben Sie 'x' und neue Position ein: "); + String playerx =scan.nextLine(); + int x = scan.nextInt(); + int y = scan.nextInt(); + while (!checkSet(playerx, x, y)) { + scan.nextLine(); + System.out.println("Falsche Eingabe! Versuchen Sie nochmal: "); + playerx =scan.nextLine(); + x = scan.nextInt(); + y = scan.nextInt(); + if (checkSet(playerx, x, y)) + break; + } + ausgabeSpielFeld(playerx, x, y); + if (checkGewinner(playerx)) { + System.out.println("Spieler X hat gewonnen!"); + break; + } + scan.nextLine(); + + System.out.println("Bitte geben Sie 'O' und neue Position ein: "); + String playero =scan.nextLine(); + x = scan.nextInt(); + y = scan.nextInt(); + while (!checkSet(playero, x, y)) { + scan.nextLine(); + System.out.println("Falsche Eingabe! Versuchen Sie nochmal: "); + playero =scan.nextLine(); + x = scan.nextInt(); + y = scan.nextInt(); + } + ausgabeSpielFeld(playero, x, y); + if (checkGewinner(playero)) { + System.out.println("Spieler O hat gewonnen!"); + break; + } + scan.nextLine(); + } + } + + public static boolean checkSet(String X_O, int x, int y){ + if ( x < 0 || x > 2 || y < 0 || y > 2) + return false; + + if (!(spielField[x][y].equals("-")) ) + return false; + + return true; + } + + public static boolean checkGewinner(String player){ + for(int i = 0 ; i < 3; i++){ + if (spielField[i][0].equals(player) && spielField[i][1].equals(player) && spielField[i][2].equals(player)) + return true; + } + for (int i = 0; i < 3; i++){ + if (spielField[0][i].equals(player) &&spielField[1][i].equals(player) &&spielField[2][i].equals(player)) + return true; + } + if (spielField[0][0].equals(player)&& spielField[1][1].equals(player)&& spielField[2][2].equals(player)) + return true; + + if (spielField[0][2].equals(player)&& spielField[1][1].equals(player)&& spielField[2][0].equals(player)) + return true; + + return false; + } + + public static void ausgabeSpielFeld(String X_O, int x, int y){ + spielField[x][y] = X_O; + for (int i = 0; i < 3; i++){ + for (int j = 0; j < 3; j++){ + System.out.print(spielField[i][j] + "|"); + } + System.out.println(); + } + + + + } + public static void printSpielfeld(){ + for (int i = 0; i < 3; i++){ + for (int j = 0; j < 3; j++){ + if (j == 2){ + spielField[i][j] = "-"; + System.out.print(spielField[i][j]); + }else{ + spielField[i][j] = "-"; + System.out.print(spielField[i][j]); + System.out.print("|"); + } + } + System.out.println(); + } + + } +} diff --git a/Programmierung2/src/Übungen/Whatsapp.java b/Programmierung2/src/Übungen/Whatsapp.java new file mode 100644 index 0000000..8d0e854 --- /dev/null +++ b/Programmierung2/src/Übungen/Whatsapp.java @@ -0,0 +1,228 @@ +package Übungen; +import java.util.ArrayList; + +public class Whatsapp { + private String name; + private String teleN; + private String nachricht; + private ArrayList speicherContact; + private ArrayList speicherNummern; + private ArrayList blockContact; + + public Whatsapp(String name, String teleN) { + this.name = name; + this.nachricht = null; + this.teleN = teleN; + this.speicherContact = new ArrayList<>(); + this.blockContact = new ArrayList<>(); + speicherContact.add(this.name); + this.speicherNummern = new ArrayList<>(); + speicherNummern.add(teleN); + } + + + public void addContact(String name, String teleN){ + if (name != null && teleN != null){ + speicherContact.add(name); + speicherNummern.add(teleN); + } + } + + public ArrayList getContact(){ + return this.speicherContact; + } + + public void printContacte(){ + System.out.println("Deine KontaktListe: "); + + for (int i = 0; i < speicherContact.size();i++) + System.out.println("Name: " + speicherContact.get(i) +", Telefonummer: " + speicherNummern.get(i)); + + } + + public void blocKontakt(Whatsapp block) { + if (!blockContact.contains(block.getName())) { + this.blockContact.add(block.getName()); + System.out.println(this.name + " hat " + block.getName() + " blockiert"); + } + + else + System.err.println("Ist bereit Blockiert"); + } + + public ArrayList getblockContact(){ + return blockContact; + } + + public String searchContact(String name){ + for (int i = 0; i saveMessages; + + public Nachrichten(Whatsapp sender, Whatsapp receiver) { + this.sender = sender; //obai + this.receiver = receiver; //omar + this.saveMessages = new ArrayList<>(); + } + + public void sendMessage(Whatsapp sender, Whatsapp receiver, String message) { + if (receiver.getblockContact().contains(sender.getName())) { + String blockMessage = "Du wurdest von " + receiver.getName() + " blockiert!"; + System.err.println(blockMessage); + return; + } + if (sender.getblockContact().contains(receiver.getName())) { + String blockMessage = "Du hast " + receiver.getName() + " blockiert!"; + System.err.println(blockMessage); + return; + } + + if (receiver != null) { + receiver.setNachricht(message); + String infoMessage = sender.getName() + " sendet " + receiver.getName() + " : " + receiver.getNachricht(); + saveMessages.add(infoMessage); + } + } + + + public ArrayList getinfoMessage() { + return saveMessages; + } + + public void printsaveMessages() { + System.out.println("Chat Room: "); + for(String s:saveMessages) + System.out.println(s); + } + +} + +class Groups{ + Whatsapp hersteller; + ArrayList admins; + ArrayList addmembers; + ArrayList allMessages; + String groupsname; + + + Groups(Whatsapp hersteller, String groupsname){ + this.hersteller = hersteller; + this.groupsname = groupsname; + this.addmembers = new ArrayList<>(); + this.admins = new ArrayList<>(); + this.allMessages = new ArrayList<>(); + addmembers.add(hersteller); + admins.add(hersteller); + System.out.println(this.hersteller.getName() + "(Admin): hat die Groupe " + this.groupsname + " erstellt"); + } + + public void sendeMessages(Whatsapp sender, String message) { + if (addmembers.contains(sender)) { + String speicher = sender.getName() + " : " + message ; + allMessages.add(speicher); + } + } + + public ArrayList getallMessages(){ + return allMessages; + } + + public void printallMessages() { + for (String s: allMessages) + System.out.println(s); + } + + public void removeMember(Whatsapp remover, Whatsapp toBeRemoved) { + if (!admins.contains(remover)) { + System.err.println("Du bist kein Admin"); + return; + } + if (!addmembers.contains(toBeRemoved)) { + System.err.println("Mitglied nicht in der Gruppe"); + return; + } + addmembers.remove(toBeRemoved); + System.out.println(toBeRemoved.getName() + " wurde aus der Gruppe entfernt."); + } + + + public void addMembers(Whatsapp member) { + if (!addmembers.contains(member)) + addmembers.add(member); + else + System.err.println("member ist bereits da!"); + } + + public void addAdmin(Whatsapp admin, Whatsapp toBeAdmin) { + if (!admins.contains(admin)) { + System.err.println("Du musst Admin sein"); + return; + } + if (admins.contains(toBeAdmin)) { + System.err.println(toBeAdmin.getName() + " ist bereits Admin."); + return; + } + admins.add(toBeAdmin); + System.out.println(admin.getName() + " hat " + toBeAdmin.getName() + " als Admin benannt."); + } + + + public ArrayList getaddmembers(){ + + return addmembers; + } + + public void printaddmembers(Whatsapp printer) { + if (!addmembers.contains(printer)) { + System.err.println("du bist kein Mitglied!"); + return; + } + + System.out.println("Alle Members:"); + int i = 1; + for (Whatsapp s : addmembers) { + String memberName = printer.getContact().contains(s.getName()) ? s.getName() : "Unbekannt"; + + if (admins.contains(s)) + System.out.println("Mitglied(Admin) " + i + " : " + memberName); + else + System.out.println("Mitglied " + i + " : " + memberName); + i++; + } + } + } + diff --git a/Programmierung2/src/Übungen/WhatsappTest.java b/Programmierung2/src/Übungen/WhatsappTest.java new file mode 100644 index 0000000..51a55fa --- /dev/null +++ b/Programmierung2/src/Übungen/WhatsappTest.java @@ -0,0 +1,41 @@ +package Übungen; +import java.util.ArrayList; + +public class WhatsappTest { + + public static void main(String[] args) { + Whatsapp obai = new Whatsapp("obai", "049321384324"); + Whatsapp omar = new Whatsapp("omar", "049321384324"); + Whatsapp abd = new Whatsapp("abd", "049321321"); + Whatsapp oula = new Whatsapp("oula", "049321321"); + + + Nachrichten messages = new Nachrichten(obai,omar); + messages.sendMessage(obai, omar, "Hallo omar"); + messages.sendMessage(omar, obai, "Hallo obai"); + messages.sendMessage(omar, obai, "was machst du?"); + messages.printsaveMessages(); + omar.blocKontakt(obai); + messages.sendMessage(omar, obai, "was machst du?"); + messages.printsaveMessages(); + +// Groups gr1 = new Groups(obai,"Almidani"); +// gr1.addMembers(omar); +// gr1.addMembers(abd); +// +// obai.addContact("abd","004848214"); +// obai.addContact("omar","004848214"); +// gr1.addAdmin(obai, omar); +// gr1.printaddmembers(obai); +// System.out.println(); +// System.out.println(); +// System.out.println(); +// gr1.printaddmembers(omar); +// gr1.sendeMessages(abd, "Hallo Omar"); +// gr1.sendeMessages(omar, "Hallo Abd"); +// +// +// gr1.printallMessages(); + } + +}