diff --git a/Programmierung2/src/Algorithmus/Array.java b/Programmierung2/src/Algorithmus/Array.java new file mode 100644 index 0000000..a1057aa --- /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..69e92ad --- /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/BinaryTree/BinaryBaumList.java b/Programmierung2/src/BinaryTree/BinaryBaumList.java new file mode 100644 index 0000000..8d88007 --- /dev/null +++ b/Programmierung2/src/BinaryTree/BinaryBaumList.java @@ -0,0 +1,80 @@ +package BinaryTree; + +public class BinaryBaumList { + Node root; + + public void addFirstElement(int value) { + Node node = new Node(); //1. erstelle ein Node + node.value = value; // 2. gib dieser Node ein Value + if (root == null)//3. wenn meine Liste leer ist + this.root = node; + System.out.println("Erste Element: " + root.value); + } + + private void HinzufügenVonElementen(int value) { + Node newNode = new Node(); + newNode.value = value; + Node temp = root; + Node merker = temp; + while(temp != null) { + merker = temp; + if (value < temp.value) + temp = temp.left; + + else + temp = temp.right; + } + if (value < merker.value) { + merker.left =newNode; + System.out.println("linke neue Knote " + merker.left.value); + }else { + merker.right =newNode; + System.out.println("rechte neue Knote " + root.right.value); + } + + } + + public void addElement(int value) { + if (root == null) + addFirstElement(value); + else + HinzufügenVonElementen(value); + + } + + + public void addstatic(int value) { + Node newNode = new Node(); + newNode.value = value; + // wenn meine Liste leer ist + if (root == null) { + this.root = newNode; + return; + } + + //wenn ja, dann soll ich nur die linke Knoten des Baumes betrachte + Node temp = root; + if (newNode.value < root.value) { + root.left = newNode; + System.out.println("linke seite " + root.left.value); + } + + else { + root.right = newNode; + System.out.println("rechte seite " + root.right.value); + } + + } + +// public void printRoot() { +// Node temp = root; +// Node left = root.left; +// Node right = root.right; +// +// while(temp != null || left != null || right != null) +// System.out.println("Value: " + this.root.value); +// } + + + +} diff --git a/Programmierung2/src/BinaryTree/Node.java b/Programmierung2/src/BinaryTree/Node.java new file mode 100644 index 0000000..40800a9 --- /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..0b516a9 --- /dev/null +++ b/Programmierung2/src/BinaryTree/Test.java @@ -0,0 +1,19 @@ +package BinaryTree; + +public class Test { + + public static void main(String[] args) { + Node n1 = new Node(); + BinaryBaumList b1 = new BinaryBaumList(); + + b1.addFirstElement(10); + b1.addElement(7); + b1.addElement(20); + b1.addElement(-2); + b1.addElement(2); + b1.addElement(1); + +// b1.printRoot(); + } + +} diff --git a/Programmierung2/src/BinaryTree/Tree Data Structure.odt b/Programmierung2/src/BinaryTree/Tree Data Structure.odt new file mode 100644 index 0000000..c54272e 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..edead70 --- /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..dba91b7 --- /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..900013a --- /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..dda19a6 --- /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..22cc730 --- /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/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..cf9c4a7 --- /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..735deda --- /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()); + } +}