was neues

Programmierung2/src/Algorithmus/Array.java

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

Programmierung2/src/Algorithmus/Logischen_Operatoren.java

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

Programmierung2/src/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);
+//	}
+	
+	
+
+}

Programmierung2/src/BinaryTree/Node.java

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

Programmierung2/src/BinaryTree/Test.java

@@ -0,0 +1,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();
+	}
+
+}

Programmierung2/src/Collection/Collections.java

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

Programmierung2/src/Collection/Lists.java

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

Programmierung2/src/Collection/Queueslist.java

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

Programmierung2/src/Collection/Setlists.java

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

Programmierung2/src/FassadenKlasse/Fassadenklasse.java

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

Programmierung2/src/MVC_Desighn/Person_Daten.java

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

Programmierung2/src/MVC_Desighn/Person_GUI.java

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