Ende der Vorlesungen

Programmierung2/src/Algorithmus/SwitchCases.java

@@ -1,13 +1,23 @@
 package Algorithmus;
 
+import java.util.ArrayList;
+
+
 public class SwitchCases {
 
 	public static void main(String[] args) {
-		/*
+		ArrayList<Mitarbeiter> arr = new ArrayList<>();
-		 * Die Daten Typen, die erlaubt sind:
+		
-		 * - int, char, enum, String und die Wrapper-Typen (Integer, Character, etc.).
+		arr.add(new Manager());
-		 */
 		
 	}
 
 }
+
+class Mitarbeiter{
+	
+}
+
+class Manager extends Mitarbeiter{
+	
+}

Programmierung2/src/BinaryTree/GenericBaum.java

@@ -0,0 +1,6 @@
+package BinaryTree;
+
+public class GenericBaum<T,G> {
+	
+	
+}

Programmierung2/src/DesignPatterns/Adapter.java

@@ -0,0 +1,87 @@
+package DesignPatterns;
+
+public class Adapter {
+
+	public static void main(String[] args) {
+        Vehicle car = new Car();
+
+        Vehicle bicycle = new BicycleAdapter(new Bicycle());
+
+        playWithVehicle(car);
+
+        playWithVehicle(bicycle);
+    }
+
+    private static void playWithVehicle(Vehicle vehicle) {
+
+        vehicle.accelerate();
+        vehicle.pushBreak();
+        vehicle.soundHorn();
+        System.out.println("\n");
+    }
+}
+
+interface Vehicle {
+
+    void accelerate();
+    void pushBreak();
+    void soundHorn();
+}
+
+class Car implements Vehicle {
+
+    @Override
+    public void accelerate() {
+        System.out.println("Car starts to move");
+    }
+
+    @Override
+    public void pushBreak() {
+        System.out.println("Car Stopped");
+    }
+
+    @Override
+    public void soundHorn() {
+        System.out.println("Beeb Beep");
+    }
+}
+
+class Bicycle {
+
+    public void pedal(){
+        System.out.println("Bic starts to move");
+    }
+
+    public void stop() {
+        System.out.println("Bic stopped");
+    }
+
+    public void ringBell() {
+        System.out.println("Ring ring");
+    }
+}
+
+
+class BicycleAdapter implements Vehicle {
+    private Bicycle bicycle;
+
+
+    public BicycleAdapter(Bicycle bicycle) {
+        this.bicycle = bicycle;
+    }
+
+    @Override
+    public void accelerate() {
+        bicycle.pedal();
+    }
+
+    @Override
+    public void pushBreak() {
+        bicycle.stop();
+    }
+
+    @Override
+    public void soundHorn() {
+        bicycle.ringBell();
+    }
+}

Programmierung2/src/DesignPatterns/BuilderPattern.java

@@ -1,4 +1,4 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.BuilderPatter;
+package DesignPatterns;
 
 public class BuilderPattern {
 	// Private Felder

Programmierung2/src/DesignPatterns/Composite.java

@@ -1,4 +1,4 @@
-package DesignPatterns.strukturellen_Entwurfsmustern.Composite;
+package DesignPatterns;
 
 import java.util.*;
 
@@ -58,7 +58,7 @@ class Drawing implements Shape {
 }
 
 // Hauptklasse zur Demonstration des Composite-Musters
-public class Main {
+public class Composite {
 
     public static void main(String[] args) {
         // Erstelle einige einzelne Formen

Programmierung2/src/DesignPatterns/Dekorator.java

@@ -0,0 +1,91 @@
+package DesignPatterns;
+
+//Gemeinsame Schnittstelle
+interface Kaffee {
+	
+ String beschreibung();
+ double preis();
+}
+
+//Basisobjekt
+class EinfacherKaffee implements Kaffee {
+    @Override
+    public String beschreibung() {
+        return "Einfacher Kaffee";
+    }
+
+    @Override
+    public double preis() {
+        return 2.00; // Basispreis
+    }
+}
+
+//Abstrakter Dekorator
+abstract class KaffeeDekorator implements Kaffee {
+    protected Kaffee kaffee;
+
+    public KaffeeDekorator(Kaffee kaffee) {
+        this.kaffee = kaffee;
+    }
+
+    @Override
+    public String beschreibung() {
+        return kaffee.beschreibung();
+    }
+
+    @Override
+    public double preis() {
+        return kaffee.preis();
+    }
+}
+
+//Milch-Dekorator
+class Milch extends KaffeeDekorator {
+    public Milch(Kaffee kaffee) {
+        super(kaffee);
+    }
+
+    @Override
+    public String beschreibung() {
+        return kaffee.beschreibung() + ", Milch";
+    }
+
+    @Override
+    public double preis() {
+        return kaffee.preis() + 0.50; // Preis für Milch hinzufügen
+    }
+}
+
+//Zucker-Dekorator
+class Zucker extends KaffeeDekorator {
+    public Zucker(Kaffee kaffee) {
+        super(kaffee);
+    }
+
+    @Override
+    public String beschreibung() {
+        return kaffee.beschreibung() + ", Zucker";
+    }
+
+    @Override
+    public double preis() {
+        return kaffee.preis() + 0.20; // Preis für Zucker hinzufügen
+    }
+}
+public class Dekorator {
+
+	 public static void main(String[] args) {
+	        // Basis-Kaffee
+	        Kaffee kaffee = new EinfacherKaffee();
+	        System.out.println(kaffee.beschreibung() + " kostet: " + kaffee.preis() + "€");
+
+	        // Kaffee mit Milch
+	        kaffee = new Milch(kaffee);
+	        System.out.println(kaffee.beschreibung() + " kostet: " + kaffee.preis() + "€");
+
+	        // Kaffee mit Milch und Zucker
+	        kaffee = new Zucker(kaffee);
+	        System.out.println(kaffee.beschreibung() + " kostet: " + kaffee.preis() + "€");
+	    }
+
+}

Programmierung2/src/DesignPatterns/DekoratorKaffe.java

@@ -0,0 +1,63 @@
+package DesignPatterns;
+
+interface Kaffe{
+	
+	String getBeschreibung();
+	
+	double getPreis();
+}
+
+class EinfacherKaffee implements Kaffe{
+
+	@Override
+	public String getBeschreibung() {
+		return "Kaffe ";
+	}
+
+	@Override
+	public double getPreis() {
+		return 2.5;
+	}
+	
+}
+
+abstract class KaffeDekorator implements Kaffe {
+	protected Kaffe kaffe;
+	KaffeDekorator(Kaffe kaffe){
+		this.kaffe = kaffe;
+	}
+	@Override
+	public String getBeschreibung() {
+		return kaffe.getBeschreibung();
+	}
+
+	@Override
+	public double getPreis() {
+		return kaffe.getPreis();
+	}
+}
+
+class Milch extends KaffeDekorator{
+
+	Milch(Kaffe kaffe) {
+		super(kaffe);
+	}
+	@Override
+	public String getBeschreibung() {
+		return super.getBeschreibung() + " + ,Milch";
+	}
+
+	@Override
+	public double getPreis() {
+		return super.getPreis() + 1.2;
+	}
+}
+
+public class DekoratorKaffe {
+	
+	public static void main(String[] args) {
+		Kaffe normaleKaffe = new EinfacherKaffee();
+		Kaffe kaffeMitMilch = new Milch(normaleKaffe);
+		System.out.println(kaffeMitMilch.getBeschreibung());
+	}
+}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/Student.java

@@ -1,71 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.BuilderPatter;
-
-public class Student {
-
-	private String name;
-	private String vorname;
-	
-	public Student() {
-		
-	}
-	
-	private Student(BuildStu b) {
-		this.name = b.name;
-		this.vorname = b.vorname;
-	}
-
-	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 static class BuildStu{
-		private String name;
-		private String vorname;
-		
-		public BuildStu setname(String name) {
-			
-			this.name = name;
-			return this;
-		}
-		
-		public BuildStu setvorname(String vorname) {
-			
-			this.vorname = vorname;
-			return this;
-		}
-		
-		public Student builder() {
-			
-			return new Student(this);
-		}
-		
-	}
-	
-	public class Test{
-		int i =2 ;
-	}
-	
-  	public static void main(String[] args) {
-  		int i = 2;
-  		Student s = new Student.BuildStu()
-  				.setname("obai")
-  				.setvorname("omar")
-  				.builder();
-  		
-  		Student.Test test = new Student().new Test();
-  	}
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/FactoryMit_Java_Reflection.java

@@ -1,67 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory;
-
-public class FactoryMit_Java_Reflection {
-	
-	 public static void main(String[] args) {
-	        try {
-	            // Erzeugung eines Hundes mit der Factory-Methode
-	            Tier hund = Tier.erzeugeTier("Hund", 3);
-	            System.out.println(hund);  // Ausgabe: Hund, Alter: 3
-
-	            // Erzeugung einer Katze mit der Factory-Methode
-	            Tier katze = Tier.erzeugeTier("Katze", 5);
-	            System.out.println(katze);  // Ausgabe: Katze, Alter: 5
-	        } catch (Exception e) {
-	            e.printStackTrace();
-	        }
-	    }
-}
-//Basisklasse Tier
-class Tier {
-    private int alter;
-
-    public Tier(int alter) {
-        this.alter = alter;
-    }
-
-    public int getAlter() {
-        return alter;
-    }
-
-    @Override
-    public String toString() {
-        return "Tier, Alter: " + alter;
-    }
-
-    // Die Factory-Methode, die ein Tier-Objekt erzeugt
-    public static Tier erzeugeTier(String tierart, int alter) throws Exception {
-        // Sucht die Klasse basierend auf dem tierart-String und erstellt eine neue Instanz
-        return (Tier) Class.forName(tierart)
-                .getDeclaredConstructor(Integer.TYPE)
-                .newInstance(alter);
-    }
-}
-
-//Klasse Hund, erbt von Tier
-class Hund extends Tier {
-    public Hund(int alter) {
-        super(alter);
-    }
-
-    @Override
-    public String toString() {
-        return "Hund, Alter: " + getAlter();
-    }
-}
-
-//Klasse Katze, erbt von Tier
-class Katze extends Tier {
-    public Katze(int alter) {
-        super(alter);
-    }
-
-    @Override
-    public String toString() {
-        return "Katze, Alter: " + getAlter();
-    }
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/FaktoryMethode.java

@@ -1,24 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo;
-
-import DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain.Animal;
-import DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain.Cat;
-import DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain.Dog;
-
-public class FaktoryMethode {
-	
-	public static Animal erzeugeTiere(String species,String name, int alter) {
-		switch (species) {
-		
-			case "Dog":
-				return new Dog(name,alter);
-				
-			case "Cat":
-				return new Cat(name,alter);
-				
-			default:
-				return null;
-				
-		}	
-	}
-
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/ZooMain.java

@@ -1,18 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo;
-
-import java.lang.reflect.InvocationTargetException;
-import DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain.*;
-
-public class ZooMain {
-
-	public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException {
-//		Animal tiere = Animal.erzeugeTier("Britisch","DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain.Cat", 12);
-//		
-//		System.out.println(tiere.speak());
-		
-		Animal tiere = FaktoryMethode.erzeugeTiere("Cat", "bob", 12);
-		
-		tiere.speak();
-	}
-
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/ZooUI.java

@@ -1,34 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo;
-
-import java.util.Scanner;
-
-public class ZooUI {
-	
-	FaktoryMethode system;
-	
-	public ZooUI() {
-		startProgramm();
-		
-	}
-	
-	private void startProgramm() {
-		Scanner eingabe = new Scanner(System.in);
-		System.out.println("Willkommen in meinem ZOO");
-		while (true) {
-			System.out.println("Welches Tier möchten Sie haben?");
-			System.out.println("1. Katze");
-			System.out.println("2. Hund");
-			System.out.println("3. Mouse");
-			String auswahl = eingabe.nextLine();
-			String name = eingabe.nextLine();
-			int alter = eingabe.nextInt();
-			switch (auswahl) {
-				case "Katze":
-					System.out.println("Name: ");
-					system.erzeugeTiere(auswahl, auswahl, 0);
-			}
-			
-			
-		}
-	}
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Animal.java

@@ -1,49 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain;
-
-import java.lang.reflect.InvocationTargetException;
-
-public abstract class Animal {
-	private String name;
-	private int alter;
-	private String species;
-
-	public Animal(String name, int alter) {
-		this.name = name;
-		this.alter = alter;
-	}
-
-	public abstract String speak();
-	
-	public String getSpecies() {
-		return species;
-	}
-
-	public String getName() {
-		return name;
-	}
-
-	public void setName(String name) {
-		this.name = name;
-	}
-
-	public int getBirthyear() {
-		return alter;
-	}
-
-	public void setBirthyear(int birthyear) {
-		this.alter = birthyear;
-	}
-
-	public void setSpecies(String species) {
-		this.species = species;
-	}
-	
-	
-	public static Animal erzeugeTier(String species ,String name, int alter) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException {
-		return (Animal) Class.forName(species)
-				.getDeclaredConstructor(String.class, Integer.TYPE)
-				.newInstance(name,alter);
-	}
-	
-
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Cat.java

@@ -1,14 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain;
-
-public class Cat extends Animal {
-
-	public Cat( String name, int alter) {
-		super(name, alter);
-	}
-
-	@Override
-	public String speak() {
-		return super.getSpecies()+ " macht: Meow";
-	}
-
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Dog.java

@@ -1,14 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain;
-
-public class Dog extends Animal {
-
-	
-	public Dog( String name, int alter) {
-		super(name, alter);
-	}
-
-	@Override
-	public String speak() {
-		return super.getName() + " macht: Woof";
-	}
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Mouse.java

@@ -1,14 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain;
-
-public class Mouse extends Animal {
-
-	public Mouse(String name, int alter) {
-		super(name, alter);
-	}
-
-	@Override
-	public String speak() {
-		return super.getSpecies() + " macht etwas  etwas";
-	}
-
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Zoo.java

@@ -1,8 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain;
-
-public class Zoo {
-	
-	
-	
-	
-}

Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Singaleton/Singleton.java

@@ -1,52 +0,0 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Singaleton;
-
-/* 
- *  - verhindert, dass von einer Klasse mehr als ein Objekt erstellt werden kann
- *  	Das wird dadurch erreicht, dass das gewünschte Objekt in einer Klasse selbst erzeugt dann als statische Instanz abgerufen wird
- *  
- *  Eigenschaften: 
- *  - Konstruktor muss als „private“ deklariert. 
- *  - Eine öffentliche statische Methode, die die Instanz der Klasse zurückgib
- *  - private static memberVariable
- */
-public class Singleton {
-	
-	 // privater Konstruktor mit Zugriffsschutz von außen, also die kann nicht mit new erzeugt werden
-	private Singleton() {}
-	
-	 // vor Zugriff von außen geschützt und statisch
-	private static Singleton erzeuge_Objekt = null;
-	
-	
-	// öffentliche Methode, Aufruf durch Code
-	// Aber Thread_unsicher
-	public static Singleton getObejekt_Thread_unsicher() {
-		
-		if (erzeuge_Objekt == null)
-			erzeuge_Objekt = new Singleton();
-		return erzeuge_Objekt;	
-	}
-	
-	// Thread_sicher:
-	 public static synchronized Singleton getObejekt_Thread_sicher() {
-	        if (erzeuge_Objekt == null) {
-	            erzeuge_Objekt = new Singleton();
-	        }
-	        return erzeuge_Objekt;
-	    }
-	
-	 
-	// test
-	public void print() {
-		System.out.println("Hallo Welt!");
-	}
-	
-	
-	public static void main(String[] args) {
-		
-		// Verwendung Test
-		Singleton objekt = Singleton.getObejekt_Thread_unsicher();
-		objekt.print(); // Hallo Welt!
-	}
-	
-}

Programmierung2/src/DesignPatterns/Factory_method.java

@@ -1,4 +1,4 @@
-package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory;
+package DesignPatterns;
 
 /* - Erzeugung neuer Objekte nicht im Konstruktor einer Klasse durchführen, sondern durch eine statische Methode
  * 

Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Proxy_Pattern/BankkontoProxy.java

@@ -1,82 +0,0 @@
-package DesignPatterns.strukturellen_Entwurfsmustern.Proxy_Pattern;
-
-
-//Schritt 1: Definiere das gemeinsame Interface (Subject)
-interface Bankkonto {
-	void einzahlen(double betrag);
-
-	void abheben(double betrag);
-}
-
-
-//Schritt 2: Erstelle das echte Bankkonto (RealSubject)
-class EchtesBankkonto implements Bankkonto {
-	private double saldo;
-
-	@Override
-	public void einzahlen(double betrag) {
-		saldo += betrag;
-		System.out.println(betrag + " € eingezahlt. Neuer Kontostand: " + saldo + " €.");
-	}
-
-	@Override
-	public void abheben(double betrag) {
-		if (saldo >= betrag) {
-			saldo -= betrag;
-			System.out.println(betrag + " € abgehoben. Neuer Kontostand: " + saldo + " €.");
-		} else {
-			System.out.println("Nicht genügend Guthaben.");
-		}
-	}
-}
-
-
-//Schritt 3: Erstelle den Proxy
-public class BankkontoProxy implements Bankkonto {
-	private EchtesBankkonto echtesBankkonto;
-	private String zugangscode;
-
-	public BankkontoProxy(String zugangscode) {
-		this.echtesBankkonto = new EchtesBankkonto(); // Echtes Konto
-		this.zugangscode = zugangscode; // Zugriffskontrolle
-	}
-
-	private boolean autorisieren(String eingegebenerCode) {
-		return zugangscode.equals(eingegebenerCode); // Vergleich des Sicherheitscodes
-	}
-
-	@Override
-	public void einzahlen(double betrag) {
-		// Sicherheitsprüfung, bevor Zugriff gewährt wird
-		System.out.println("Sicherheitsüberprüfung...");
-		if (autorisieren("1234")) { // Beispiel: Der Code ist "1234"
-			echtesBankkonto.einzahlen(betrag);
-		} else {
-			System.out.println("Zugriff verweigert: Ungültiger Code.");
-		}
-	}
-
-	@Override
-	public void abheben(double betrag) {
-		System.out.println("Sicherheitsüberprüfung...");
-		if (autorisieren("1234")) {
-			echtesBankkonto.abheben(betrag);
-		} else {
-			System.out.println("Zugriff verweigert: Ungültiger Code.");
-		}
-	}
-
-	public static void main(String[] args) {
-		// Erstelle einen Proxy mit einem Zugangscode
-		Bankkonto bankkonto = new BankkontoProxy("1234");
-
-		// Führe eine Transaktion durch
-		bankkonto.einzahlen(100); // Sicherheitsüberprüfung -> Geld wird eingezahlt
-		bankkonto.abheben(50); // Sicherheitsüberprüfung -> Geld wird abgehoben
-
-		// Versuch, ohne richtigen Code auf das Konto zuzugreifen
-		Bankkonto falscherZugang = new BankkontoProxy("5678");
-		falscherZugang.abheben(10); // Sicherheitsüberprüfung -> Zugriff verweigert
-
-	}
-}

Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo2.java

@@ -0,0 +1,62 @@
+package GUIAnwendungen.Klausur;
+
+import java.awt.BorderLayout;
+import java.awt.GridLayout;
+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.JPanel;
+import javax.swing.JTextField;
+
+public class GuiDemo2 extends Object {
+
+	public static void main(String[] args) {
+		JFrame jf = new JFrame("Toller Titel");
+		
+		jf.add(new JLabel("Hallo Welt!"), BorderLayout.NORTH);
+		jf.add(new JTextField(10), BorderLayout.CENTER);
+		
+		JButton jb1 = new JButton("Cancel");
+		JButton jb2 = new JButton("OK");
+		
+		JPanel jp = new JPanel();
+		jp.setLayout(new GridLayout());
+		jp.add(jb1);
+		jp.add(jb2);
+	
+		jf.add(jp, BorderLayout.SOUTH);
+
+		jf.pack();
+		jf.setVisible(true);
+		
+		ActionListener obj = new GuiDemo2().new MyActionListener();  // beachte den "seltsamen" Konstruktor Aufruf
+		jb1.addActionListener(obj);
+		jb2.addActionListener(obj);
+		
+		//  obj.printSomething();	// geht nicht, da Methode bei ActionListener nicht sichtbar
+		
+		GuiDemo2.MyActionListener gd = (GuiDemo2.MyActionListener) obj;		// Downcast
+		gd.printSomething();	// nach Downcast geht es dann
+		
+		System.out.println("Ende Gelände...");
+	}
+	
+	// ActionListener-Implementierung als non-static member class
+	class MyActionListener implements ActionListener {
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			this.printSomething();
+			JButton src = (JButton) e.getSource();
+			System.out.println("Button geklickt: " + src.getText());
+		}
+		
+		public void printSomething() {
+			System.out.println("Something!");
+			MyActionListener mal = new MyActionListener();
+		}
+	}
+	
+} 

Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo3.java

@@ -0,0 +1,62 @@
+package GUIAnwendungen.Klausur;
+
+import java.awt.BorderLayout;
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.*;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+
+public class GuiDemo3 extends Object /* implements ActionListener */ {
+
+	public static void main(String[] args) {
+		JFrame jf = new JFrame("Toller Titel");
+		
+		jf.add(new JLabel("Hallo Welt!"), BorderLayout.NORTH);
+		jf.add(new JTextField(10), BorderLayout.CENTER);
+		
+		JButton jb1 = new JButton("Cancel");
+		JButton jb2 = new JButton("OK");
+		
+		JPanel jp = new JPanel();
+		jp.setLayout(new GridLayout());
+		jp.add(jb1);
+		jp.add(jb2);
+	
+		jf.add(jp, BorderLayout.SOUTH);
+
+		jf.pack();
+		jf.setVisible(true);
+		
+		// ActionListener-Implementierung als local class
+		class MyActionListener implements ActionListener {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				JButton src = (JButton) e.getSource();
+				System.out.println("Button geklickt: " + src.getText());
+			}
+		}
+		
+		ActionListener obj = new MyActionListener();  // nur in dieser Methode möglich
+		jb1.addActionListener(obj);
+		jb2.addActionListener(obj);
+		
+		System.out.println("Ende Gelände...");
+		
+		List<Integer> arr = new ArrayList<>();
+		arr.add(2);
+		arr.add(3);
+		addTenNumbers(arr);
+		}
+	public static void addTenNumbers (List<? super Integer> array) {
+		 for (int i = 0; i < 10; i++) {
+		 array.add(i);
+		 }
+		}
+
+} 

Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo4.java

@@ -0,0 +1,52 @@
+package GUIAnwendungen.Klausur;
+
+import java.awt.BorderLayout;
+import java.awt.GridLayout;
+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.JPanel;
+import javax.swing.JTextField;
+
+public class GuiDemo4 implements ActionListener {
+
+	public static void main(String[] args) {
+		JFrame jf = new JFrame("Toller Titel");
+		
+		jf.add(new JLabel("Hallo Welt!"), BorderLayout.NORTH);
+		jf.add(new JTextField(10), BorderLayout.CENTER);
+		
+		JButton jb1 = new JButton("Cancel");
+		JButton jb2 = new JButton("OK");
+		
+		JPanel jp = new JPanel();
+		jp.setLayout(new GridLayout());
+		jp.add(jb1);
+		jp.add(jb2);
+	
+		jf.add(jp, BorderLayout.SOUTH);
+
+		jf.pack();
+		jf.setVisible(true);
+		
+		jb1.addActionListener(new GuiDemo4());	// Klasse selbst implementiert das Interface
+		jb2.addActionListener(new ActionListener() {	// wir können das Interface auch mit einer anonymen inneren Klasse implementieren
+			public void actionPerformed(ActionEvent e) {
+				System.out.println("2. Button geklickt.");
+			}
+		});
+		
+		System.out.println("Ende Gelände...");
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		JButton src = (JButton) e.getSource();
+		System.out.println("Button geklickt: " + src.getText());
+	}
+	
+	
+}

Programmierung2/src/Klausur/Algorthmen.java

@@ -0,0 +1,36 @@
+package Klausur;
+import java.util.*;
+
+public class Algorthmen {
+	public static void main(String[] args) {
+        	
+		int[] arr = {1,2,3,4,5,6,7,8};
+		
+		
+		
+    }
+	
+	public static Map<Boolean,List<Integer>> oddNumbers(int[] arr){
+		
+		Map<Boolean,List<Integer>> gerade = new HashMap<>();
+		Map<Boolean,List<Integer>> ungerade = new HashMap<>();
+		
+		gerade.put(true, new ArrayList<>());
+		ungerade.put(false, new ArrayList<>());
+		
+		for (int i = 0; i < arr.length; i++ ) {
+			if (arr[i] %2 == 0 ) 
+				gerade.get(true).add(arr[i]);
+			
+			else
+				ungerade.get(false).add(arr[i]);
+		}
+		
+		
+		return null;
+		
+		
+	}
+
+    
+}

Programmierung2/src/Klausur/Bauobjekt.java

@@ -0,0 +1,78 @@
+package Klausur;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.stream.Collectors;
+
+public class Bauobjekt {
+	private int baujahr;
+	private double grundrissFlaeche;
+	private String besitzer;
+
+	public Bauobjekt(int baujahr, double grundrissFlaeche, String besitzer) {
+		super();
+		this.baujahr = baujahr;
+		this.grundrissFlaeche = grundrissFlaeche;
+		this.besitzer = besitzer;
+	}
+
+	public int getBaujahr() {
+		return baujahr;
+	}
+
+	public void setBaujahr(int baujahr) {
+		this.baujahr = baujahr;
+	}
+
+	public double getGrundrissFlaeche() {
+		return grundrissFlaeche;
+	}
+
+	public void setGrundrissFlaeche(double grundrissFlaeche) {
+		this.grundrissFlaeche = grundrissFlaeche;
+	}
+
+	public String getBesitzer() {
+		return besitzer;
+	}
+
+	public void setBesitzer(String besitzer) {
+		this.besitzer = besitzer;
+	}
+	
+	
+
+	@Override
+	public String toString() {
+		return "Bauobjekt [baujahr=" + baujahr + ", grundrissFlaeche=" + grundrissFlaeche + ", besitzer=" + besitzer
+				+ "]";
+	}
+
+	public static void main(String[] args) {
+		ArrayList <Bauobjekt> bos = new ArrayList<>();
+		
+		// Beispielobjekte für Bauobjekte
+	    Bauobjekt haus1 = new Bauobjekt(1995, 120.5, "Max Mustermann");
+	    Bauobjekt haus2 = new Bauobjekt(2008, 250.0, "Sabine Müller");
+	    Bauobjekt haus3 = new Bauobjekt(2015, 80.75, "Ali Ahmed");
+	    Bauobjekt haus4 = new Bauobjekt(1980, 300.0, "Firma XYZ GmbH");
+	    Bauobjekt haus5 = new Bauobjekt(2021, 150.25, "Sara Schmidt");
+
+	    // Objekte zur Liste hinzufügen
+	    bos.add(haus1);
+	    bos.add(haus2);
+	    bos.add(haus3);
+	    bos.add(haus4);
+	    bos.add(haus5);
+	    
+	    ArrayList<String> arr = bos.stream()
+	    		.sorted(Comparator.comparingInt(ob -> ob.getBaujahr()))
+	    		.filter(ob -> ob.getGrundrissFlaeche() < 100)
+	    		.map(ob -> ob.toString())
+	    		.collect(Collectors.toCollection(ArrayList::new));
+	    
+	    arr.forEach(System.out::println);
+
+	}
+
+}

Programmierung2/src/Klausur/Graph.java

@@ -0,0 +1,133 @@
+package Klausur;
+
+import java.util.*;
+
+//Klasse für den Graphen mit Generics
+class Graph<T> {
+
+ // Wir verwenden eine HashMap, um die Kanten im Graphen zu speichern
+ private Map<T, List<T>> map = new HashMap<>();
+
+ // Diese Methode fügt einen neuen Knoten (Vertex) zum Graphen hinzu
+ public void knotenHinzufuegen(T s) {
+     map.put(s, new LinkedList<T>());
+ }
+
+ // Diese Methode fügt eine Kante zwischen Quelle und Ziel hinzu
+ public void kanteHinzufuegen(T quelle, T ziel, boolean bidirektional) {
+
+     if (!map.containsKey(quelle)) {
+         knotenHinzufuegen(quelle);
+     }
+
+     if (!map.containsKey(ziel)) {
+         knotenHinzufuegen(ziel);
+     }
+
+     map.get(quelle).add(ziel);
+     if (bidirektional) {
+         map.get(ziel).add(quelle);
+     }
+ }
+
+ // Diese Methode gibt die Anzahl der Knoten (Vertices) im Graphen zurück
+ public void anzahlKnoten() {
+     System.out.println("Der Graph hat " + map.keySet().size() + " Knoten.");
+ }
+
+ // Diese Methode gibt die Anzahl der Kanten im Graphen zurück
+ public void anzahlKanten(boolean bidirektional) {
+     int anzahl = 0;
+     for (T v : map.keySet()) {
+         anzahl += map.get(v).size();
+     }
+     if (bidirektional) {
+         anzahl = anzahl / 2;
+     }
+     System.out.println("Der Graph hat " + anzahl + " Kanten.");
+ }
+
+ // Diese Methode überprüft, ob ein bestimmter Knoten vorhanden ist
+ public void hatKnoten(T s) {
+     if (map.containsKey(s)) {
+         System.out.println("Der Graph enthält " + s + " als Knoten.");
+     } else {
+         System.out.println("Der Graph enthält " + s + " nicht als Knoten.");
+     }
+ }
+
+ // Diese Methode überprüft, ob eine Kante zwischen zwei Knoten vorhanden ist
+ public void hatKante(T s, T d) {
+     if (map.get(s).contains(d)) {
+         System.out.println("Der Graph hat eine Kante zwischen " + s + " und " + d + ".");
+     } else {
+         System.out.println("Der Graph hat keine Kante zwischen " + s + " und " + d + ".");
+     }
+ }
+
+ // Diese Methode gibt die Nachbarn eines Knotens zurück
+ public void nachbarn(T s) {
+     if (!map.containsKey(s)) {
+         return;
+     }
+     System.out.println("Die Nachbarn von " + s + " sind:");
+     for (T w : map.get(s)) {
+         System.out.print(w + ", ");
+     }
+     System.out.println();
+ }
+
+ // Gibt die Adjazenzliste des Graphen aus
+ @Override
+ public String toString() {
+     StringBuilder builder = new StringBuilder();
+
+     for (T v : map.keySet()) {
+         builder.append(v.toString()).append(": ");
+         for (T w : map.get(v)) {
+             builder.append(w.toString()).append(" ");
+         }
+         builder.append("\n");
+     }
+
+     return builder.toString();
+ }
+}
+
+//Hauptprogramm (Driver Code)
+class Main {
+
+ public static void main(String args[]) {
+
+     // Objekt des Graphen wird erstellt
+     Graph<Integer> g = new Graph<>();
+
+     // Kanten werden hinzugefügt
+     // Da der Graph bidirektional ist, wird true übergeben
+     g.kanteHinzufuegen(0, 1, true);
+     g.kanteHinzufuegen(0, 4, true);
+     g.kanteHinzufuegen(1, 2, true);
+     g.kanteHinzufuegen(1, 3, true);
+     g.kanteHinzufuegen(1, 4, true);
+     g.kanteHinzufuegen(2, 3, true);
+     g.kanteHinzufuegen(3, 4, true);
+
+     // Den Graphen ausgeben
+     System.out.println("Graph:\n" + g.toString());
+
+     // Gibt die Anzahl der Knoten im Graphen aus
+     g.anzahlKnoten();
+
+     // Gibt die Anzahl der Kanten im Graphen aus
+     g.anzahlKanten(true);
+
+     // Überprüft, ob eine Kante zwischen zwei Knoten existiert
+     g.hatKante(3, 4);
+
+     // Überprüft, ob ein Knoten im Graphen existiert
+     g.hatKnoten(5);
+
+     // Gibt die Nachbarn eines Knotens aus
+     g.nachbarn(1);
+ }
+}

Programmierung2/src/Klausur/Lambda.java

@@ -0,0 +1,24 @@
+package Klausur;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Lambda {
+
+	public static void main(String[] args) {
+		List<Wochentag> tage = Arrays.asList(
+	            Wochentag.MITTWOCH,
+	            Wochentag.FREITAG,
+	            Wochentag.MONTAG,
+	            Wochentag.SONNTAG
+	        );
+		
+		tage.stream().collect(Collectors.partitioningBy(null));
+		}
+	}
+
+enum Wochentag implements Comparable<Wochentag> {
+    MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG;
+	
+	
+}

Programmierung2/src/Klausur/MyBaum.java

@@ -0,0 +1,229 @@
+
+package Klausur;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class MyBaum<T extends Comparable<T>> {
+	private Node<T> wurzel;
+	private int size;
+
+	public boolean add(T wert) {
+
+		if (wurzel == null) {
+			this.wurzel = new Node<T>(wert);
+			size++;
+			return true;
+		}
+	
+			
+		else {
+			size++;
+			return this.wurzel.add(wert);
+		}
+			
+		
+	
+		
+	}
+	
+	public boolean contain(T wert) {
+		if (wurzel.wert == wert)
+			return true;
+		
+		else
+			return wurzel.contain(wert);
+	}
+	
+	
+	public int getSize() {
+		return size;
+	}
+	
+	public void inorder() {
+		
+		wurzel.inorder();
+		
+	}
+	
+	public void postOrder() {
+		
+		wurzel.postOrder();;
+		
+	}
+	
+	public void levelOrder() {
+		wurzel.levelOrder(wurzel);
+	}
+	
+	
+	public void remove (T wert) {
+		
+		if(wurzel.wert == wert)
+			wurzel = null;
+		
+		else
+			wurzel.delete(wert);
+	}
+
+	class Node<T extends Comparable<T>>  {
+
+		Node<T> links;
+		Node<T> rechts;
+		T wert;
+
+		public Node(T wert) {
+			this.wert = wert;
+		}
+		
+		public boolean contain(T wert) {
+			
+			if (wert.compareTo(this.wert) < 0) {
+				if (links == null)
+					return false;
+				return links.contain(wert);
+				
+			}else if (wert.compareTo(this.wert) > 0) {
+				
+				if (rechts == null)
+					return false;
+				
+				return rechts.contain(wert);			
+			}
+			else
+				return true;
+		}
+		
+		public Node<T> delete(T wert) {
+			if (wert.compareTo(this.wert) < 0) {
+				if (this.links == null)
+					throw new IllegalArgumentException("Wert beim Löschen nicht gefunden.");
+				
+				links = links.delete(wert);
+				
+			} else if (wert.compareTo(this.wert) > 0) {
+				if (rechts == null)
+					throw new IllegalArgumentException("Wert beim Löschen nicht gefunden.");
+			
+				rechts = rechts.delete(wert);
+				
+			} else if (wert == this.wert) {
+				System.out.println("delete here " + this.wert);
+				
+				if (links == null && rechts == null)
+					return null;
+				
+				else if (links != null && rechts == null)
+					return this.links;
+				
+				else if (links == null && rechts != null)
+					return rechts;
+				
+				else {
+			            Node<T> biggst = links.findBiggest();  // Kleinsten Wert im rechten Teilbaum finden
+			            System.out.println("biggst " + biggst.wert);
+
+			            this.wert = biggst.wert;  // Wert ersetzen
+			            links = links.delete(biggst.wert);  // Den kleinsten Knoten löschen
+			        }
+			}
+				
+			return this;
+		} // delete
+		
+		
+		private Node<T> findSmallest() {
+		    if (links == null) {
+		        return this;  // Der kleinste Knoten ist der linkeste Knoten
+		    }
+		    return links.findSmallest();
+		}
+
+		
+		private Node<T> findBiggest() {
+			if (rechts == null)
+				return this;
+			
+			return rechts.findBiggest(); 
+		}		
+		
+		
+		
+
+		public boolean add(T wert) {
+
+			if (wert.compareTo(this.wert) < 0) {
+				if (links != null)
+					links.add(wert);
+				else {
+					links = new Node<>(wert);
+					return true;
+				}
+
+			} else if ((wert.compareTo(this.wert) > 0)) {
+				if (wert.compareTo(this.wert) > 0)
+					if (rechts != null)
+						rechts.add(wert);
+					else {
+						rechts = new Node<>(wert);
+						return true;
+					}		
+			}
+			return false;
+
+		}
+		
+		public void inorder() {
+			if (links != null)
+				links.inorder();
+			
+			System.out.print(this.wert + " ");
+			
+			if (rechts != null)
+				rechts.inorder();
+		}
+		
+		public void preOrder() {
+			System.out.print(this.wert + " ");
+			
+			if (links != null)
+				links.preOrder();
+			
+			if (rechts != null)
+				rechts.preOrder();
+		}
+		
+		public void postOrder() {
+			
+			if (links != null )
+				links.postOrder();
+			
+			if (rechts != null)
+				rechts.postOrder();
+			
+			System.out.print(this.wert + " ");
+		}
+		
+		
+		public void levelOrder(Node<T> wurzel) {
+
+			Queue<Node<T>> queue = new LinkedList<>();
+			queue.add(wurzel);
+
+			while (!queue.isEmpty()) {
+				Node<T> temp = queue.poll();
+
+				if (temp.links != null)
+					queue.add(temp.links);
+
+				if (temp.rechts != null)
+					queue.add(temp.rechts);
+				
+				System.out.print(temp.wert + " ");
+
+			}
+			
+		}
+
+	}
+}

Programmierung2/src/Klausur/MyGraph.java

@@ -0,0 +1,31 @@
+package Klausur;
+
+import java.util.*;
+
+public class MyGraph<T> {
+	
+	Map<T,List<T>> map;
+	
+	
+	public MyGraph() {
+		
+		this.map = new HashMap<>();
+	}
+	
+	public void addKnoten(T wert) {
+		map.put(wert, new LinkedList<>());
+	}
+	
+	public void addKanten(T quelle, T ziel, int gewicht) {
+		
+		if (!map.containsKey(quelle))
+			addKnoten(quelle);
+		
+		if (!map.containsKey(ziel))
+			addKnoten(ziel);
+		
+		map.get(quelle).add(ziel);
+	}
+	
+	
+}

Programmierung2/src/Klausur/Navi/Navi.java

@@ -0,0 +1,118 @@
+package Klausur.Navi;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Scanner;
+
+public class Navi {
+	private static Map<String, Ort> orte = new HashMap<>();
+	private static PriorityQueue<Ort> kandidaten = new PriorityQueue<>();
+
+	public static void main(String[] args) throws FileNotFoundException {
+		Scanner sc = new Scanner(new File("resources/orte.txt"));
+
+		while (sc.hasNextLine()) {
+			String line = sc.nextLine();
+
+			String[] infos = line.split(",");
+
+			String s1 = infos[0];
+			String s2 = infos[1];
+			
+			System.out.println(s1 + " <> " + s2);
+
+			Ort o1 = orte.get(s1);
+			Ort o2 = orte.get(s2);
+
+			if (o1 == null) {
+				o1 = new Ort(s1);
+				orte.put(s1, o1);
+			}
+			if (o2 == null) {
+				o2 = new Ort(s2);
+				orte.put(s2, o2);
+			}
+
+			int l = Integer.parseInt(infos[2]);
+			Strasse s = new Strasse(o1, o2, l);
+		} // while
+
+		sc.close();
+
+		System.out.println(orte.size() + " Orte angelegt.");
+		
+		// -------------------------------
+
+		System.out.println("Wir wollen von HD nach KL.");
+		Ort start = orte.get("Heidelberg");
+		Ort ziel = orte.get("Kaiserslautern");
+
+		System.out.println();
+		System.out.println("Starte Navigation.");
+
+		resetNavigation(start);
+		
+		navigiere(
+				start, 
+				ziel
+				);
+		
+		System.out.println();
+		
+		System.out.println("Route: ");
+		Ort ort = ziel;
+		System.out.println(ort);
+
+		while (!ort.getName().equals(start.getName())) {
+			ort = ort.getVorgaenger();
+			System.out.println(ort);
+		}
+
+		System.out.println("Fin.");
+	}
+
+	public static void resetNavigation(Ort start) {
+		orte.values().forEach(o -> {
+			o.reset();
+
+			if (o.getName().equals(start.getName()))
+				o.setEntfernung(0, null);
+		});
+	}
+
+	public static void navigiere(Ort start, Ort ziel) {
+		kandidaten.add(start);
+
+		while (kandidaten.size() != 0) {
+			Ort kandidat = kandidaten.poll();
+
+			if (kandidat == ziel) {
+				continue;
+			}
+			
+			System.out.println("Betrachte: " + kandidat);
+			
+			for (Strasse s : kandidat.getStrassen()) {
+				
+				if (s.isErledigt())
+					continue;
+				
+				Ort nachbar = s.getAndererOrt(kandidat);
+
+				nachbar.setEntfernung(kandidat.getEntfernung() + s.getLaenge(), kandidat);
+				System.out.println("Nachbar: " + nachbar.getName());
+				
+				kandidaten.add(nachbar);
+				
+				s.setErledigt(true);
+			} // for strasse
+			
+			System.out.println();
+		} // while kandidaten
+
+	} // navigiere
+
+}

Programmierung2/src/Klausur/Navi/Ort.java

@@ -0,0 +1,60 @@
+package Klausur.Navi;
+
+import java.util.ArrayList;
+
+public class Ort implements Comparable<Ort> {
+	private String name;
+	private ArrayList<Strasse> strassen;
+	
+	private int entfernung;
+	private Ort vorgaenger;
+
+	public Ort(String n) {
+		this.name = n;
+		this.strassen = new ArrayList<>();
+	}
+
+	public void addStrasse(Strasse str) {
+		strassen.add(str);
+	}
+
+	public String toString() {
+		return this.name + " hat " + strassen.size() + " Straßen "
+				+ "und eine Entfernung von " + entfernung + " km zum Startort.";
+	}
+
+	public void setEntfernung(int entf, Ort o) {
+		if (entf < this.entfernung) {
+			this.entfernung = entf;
+			vorgaenger = o;
+		}
+	}
+	
+	public int getEntfernung() {
+		return this.entfernung;
+	}
+
+	public void reset() {
+		this.entfernung = Integer.MAX_VALUE;
+		
+		for (Strasse s: strassen)
+			s.setErledigt(false);
+	}
+	
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public int compareTo(Ort o) {
+		return this.entfernung - o.entfernung;
+	}
+	
+	public Ort getVorgaenger() {
+		return vorgaenger;
+	}
+	
+	public ArrayList<Strasse> getStrassen() {
+		return strassen;
+	}
+}

Programmierung2/src/Klausur/Navi/Strasse.java

@@ -0,0 +1,42 @@
+package Klausur.Navi;
+
+public class Strasse {
+	private Ort ort1;
+	private Ort ort2;
+	
+	private int laenge;
+	private boolean erledigt;
+	
+	public Strasse(Ort o1, Ort o2, int l) {
+		this.ort1 = o1;
+		this.ort2 = o2;
+		this.laenge = l;
+		
+		o1.addStrasse(this);
+		o2.addStrasse(this);
+	}
+	
+	public Ort getAndererOrt(Ort start) {
+		if (ort1 == start) 
+			return ort2;
+		
+		return ort1;
+	}
+	
+	public int getLaenge() {
+		return laenge;
+	}
+	
+	public String toString() {
+		return "Straße: " + ort1.getName() + " " + ort2.getName();
+	}
+
+	public boolean isErledigt() {
+		return erledigt;
+	}
+
+	public void setErledigt(boolean erledigt) {
+		this.erledigt = erledigt;
+	}
+	
+}

Programmierung2/src/Klausur/Ort.java

@@ -0,0 +1,59 @@
+package Klausur;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+
+public class Ort {
+
+	int x;
+	String name;
+	String postleitzahl;
+	int einwohnerzahl;
+
+	public Ort(int x) {
+		this.x = x;
+
+	}
+
+	@Override
+	public String toString() {
+		return "Ort [x=" + x + "]";
+	}
+	
+	
+
+	public int getX() {
+		return x;
+	}
+	
+
+	public static void main(String[] args) {
+	ArrayList<Ort> arr = new ArrayList<>();
+	
+	arr.add(new Ort(2));
+	arr.add(new Ort(4));
+	
+	arr.stream()
+	.filter(p -> p.getX() < 2)
+	.mapToInt(p -> p.getX() * 12)
+	.sum();
+	
+		
+	}
+	
+	public static int xy(int n) {
+		
+		if (n < 0)
+			return 0;
+		
+		else if ( n == 0 || n == 1)
+			return 1;
+		else
+			return n* xy(n-1);
+	}
+}
+
+
+
+

Programmierung2/src/Klausur/Person.java

@@ -0,0 +1,36 @@
+package Klausur;
+
+import java.util.*;
+
+public class Person {
+
+	public void sprich() {
+
+		System.out.println("bin Person.");
+	}
+
+	public static void main(String[] args) {
+		HashMap<String, Integer> lohn = new HashMap<>();
+		lohn.put("Obai", 4000);
+		lohn.put("Omar", 222);
+
+		lohn.replaceAll((k, v) -> (int) v + (v * 5 / 100));
+
+	}
+}
+
+class Student extends Person {
+
+	@Override
+	public void sprich() {
+		System.out.println("bin Student.");
+	}
+}
+
+class Professor extends Person {
+
+	@Override
+	public void sprich() {
+		System.out.println("bin Professor.");
+	}
+}

Programmierung2/src/Klausur/TestBaum.java

@@ -0,0 +1,29 @@
+package Klausur;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class TestBaum {
+	MyBaum<Integer> baum;
+	
+	@BeforeEach
+	void setUp() throws Exception {
+		baum = new MyBaum<>();
+	}
+
+	@Test
+	void testaddMethode() {
+		assertTrue(baum.add(30));
+		assertFalse(baum.add(30));
+		assertTrue(baum.add(40));
+	}
+	
+	@Test
+	void testContainsMethode() {
+		baum.add(40);
+		assertTrue(baum.contain(40));
+	}
+
+}

Programmierung2/src/Klausur/mensch/Mensch.java

@@ -0,0 +1,39 @@
+package Klausur.mensch;
+
+public class Mensch {
+    int alter;
+
+    public Mensch(int alter) {
+        this.alter = alter;
+    }
+
+    @Override
+    public String toString() {
+        return "Mensch(" + alter + ")";
+    }
+    
+    public static void main(String[] args) {
+        Student s = new Student(20, 12345);
+        Object o =  s;
+        Mensch m = s;
+
+        System.out.println(o.toString()); // 1) Ausgabe: Student(12345)
+        System.out.println(m.toString()); // 2) Ausgabe: Student(12345)
+        System.out.println(s.toString()); // 3) Ausgabe: Student(12345)
+    }
+}
+
+class Student extends Mensch {
+    int matrnr;
+
+    public Student(int alter, int matrikelnummer) {
+        super(alter);
+        this.matrnr = matrikelnummer;
+    }
+
+    @Override
+    public String toString() {
+        return "Student(" + matrnr + ")";
+    }
+}
+

Programmierung2/src/Klausur/stream/Main.java

@@ -0,0 +1,125 @@
+package Klausur.stream;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+public class Main {
+
+    public static void main(String[] args) {
+        // Liste der Prüfungen
+        List<Pruefung> pruefungen1 = new ArrayList<>();
+        pruefungen1.add(new Pruefung("Mathematik", 5, "WS2023", 2.3));
+        pruefungen1.add(new Pruefung("Programmierung", 6, "SS2023", 1.7));
+        pruefungen1.add(new Pruefung("Betriebssysteme", 4, "WS2023", 3.0));
+
+        List<Pruefung> pruefungen2 = new ArrayList<>();
+        pruefungen2.add(new Pruefung("Mathematik", 5, "WS2023", 4.7)); // Nicht bestanden
+        pruefungen2.add(new Pruefung("Programmierung", 6, "SS2023", 2.0));
+        pruefungen2.add(new Pruefung("Datenbanken", 5, "WS2023", 3.3));
+
+        // Liste der Studenten
+        List<Student> studenten = new ArrayList<>();
+        studenten.add(new Student("Anna Müller", "Berlin", "Informatik", pruefungen1));
+        studenten.add(new Student("Max Meier", "Hamburg", "Wirtschaftsinformatik", pruefungen2));
+
+        
+        Map<String,List<Pruefung>> speicher = new HashMap<>();
+//        speicher = studenten.stream()
+//        .collect(Collectors.toMap(stu -> stu.getName(), p -> p.getPruefungen().stream().map(pr -> pr.toString()).collect(Collectors.toCollection(ArrayList::new))));
+        
+        System.out.println(speicher);
+        
+        
+        for (Student s : studenten) {
+        	if (!speicher.containsKey(s.getName()))
+        		speicher.put(s.getName(), s.getPruefungen());
+        	
+        	else
+        		speicher.get(s.getName()).add((Pruefung)s.getPruefungen());
+        }
+        
+        System.out.println(speicher);
+    }
+}
+
+class Student {
+    private String name;
+    private String wohnort;
+    private String studiengang;
+    private List<Pruefung> pruefungen;
+
+    public Student(String name, String wohnort, String studiengang, List<Pruefung> pruefungen) {
+        this.name = name;
+        this.wohnort = wohnort;
+        this.studiengang = studiengang;
+        this.pruefungen = pruefungen;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getWohnort() {
+        return wohnort;
+    }
+
+    public String getStudiengang() {
+        return studiengang;
+    }
+
+    public List<Pruefung> getPruefungen() {
+        return pruefungen;
+    }
+
+    @Override
+    public String toString() {
+        return "Student{" +
+                "name='" + name + '\'' +
+                ", wohnort='" + wohnort + '\'' +
+                ", studiengang='" + studiengang + '\'' +
+                ", pruefungen=" + pruefungen +
+                '}';
+    }
+}
+
+class Pruefung {
+    private String name;
+    private int ectsZahl;
+    private String semester;
+    private double note;
+
+    public Pruefung(String name, int ectsZahl, String semester, double note) {
+        this.name = name;
+        this.ectsZahl = ectsZahl;
+        this.semester = semester;
+        this.note = note;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getEctsZahl() {
+        return ectsZahl;
+    }
+
+    public String getSemester() {
+        return semester;
+    }
+
+    public double getNote() {
+        return note;
+    }
+
+    @Override
+    public String toString() {
+        return "Pruefung{" +
+                "name='" + name + '\'' +
+                ", ectsZahl=" + ectsZahl +
+                ", semester='" + semester + '\'' +
+                ", note=" + note +
+                '}';
+    }
+}
+

Programmierung2/src/Thread/Deadlock.java

@@ -0,0 +1,40 @@
+package Thread;
+
+public class Deadlock {
+
+	public static void main(String[] args) {
+		final String r1 = "edureka";
+		final String r2 = "java";
+		Thread t1 = new Thread() {
+			public void run() {
+				synchronized (r1) {
+					System.out.println("Thread 1: Locked r1");
+					try {
+						Thread.sleep(100);
+					} catch (InterruptedException e) {
+					}
+					// t1 ist hier
+					synchronized (r2) {
+						System.out.println("Thread 1: Locked r2");
+					}
+				}
+			}
+		};
+		Thread t2 = new Thread() {
+			public void run() {
+				synchronized (r2) {
+					System.out.println("Thread 2: Locked r1");
+					try {
+						Thread.sleep(100);
+					} catch (InterruptedException e) {
+					}
+					synchronized (r1) {
+						System.out.println("Thread 2: Locked r2");
+					}
+				}
+			}
+		};
+		t1.start();
+		t2.start();
+	}
+}

Programmierung2/src/Thread/MyRunnable.java

@@ -0,0 +1,30 @@
+package Thread;
+
+public class MyRunnable implements Runnable {
+
+	@Override
+	public void run() {
+
+		while (!Thread.currentThread().isInterrupted()) {
+
+			System.out.println("Hi");
+
+			try {
+				Thread.sleep(1000);
+
+			} catch (InterruptedException e) {
+				Thread.currentThread().interrupt();
+
+			}
+		}
+
+	}
+
+	public static void main(String[] args) {
+
+		Thread t1 = new Thread(new MyRunnable());
+
+		t1.start();
+	}
+
+}

Programmierung2/src/Thread/Runner4.java

@@ -0,0 +1,46 @@
+package Thread;
+
+class DeadlockExample {
+    private final Object lock1 = new Object();
+    private final Object lock2 = new Object();
+
+    public void method1() {
+        synchronized (lock1) {
+            System.out.println(Thread.currentThread().getName() + " hat lock1 ");
+            try {
+                Thread.sleep(50); // Simuliert eine Verzögerung
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            synchronized (lock2) {
+                System.out.println(Thread.currentThread().getName() + " hat lock2         ");
+            }
+        }
+    }
+
+    public void method2() {
+        synchronized (lock2) {
+            System.out.println(Thread.currentThread().getName() + " hat lock2 ");
+            try {
+                Thread.sleep(50); // Simuliert eine Verzögerung
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            synchronized (lock1) {
+                System.out.println(Thread.currentThread().getName() + " hat lock1      ");
+            }
+        }
+    }
+}
+
+public class Runner4 {
+    public static void main(String[] args) {
+        DeadlockExample example = new DeadlockExample();
+
+        Thread t1 = new Thread(example::method1, "Thread-1");
+        Thread t2 = new Thread(example::method2, "Thread-2");
+
+        t1.start();
+        t2.start();
+    }
+}

Programmierung2/src/Thread/SimpleHeapAndStack.java

@@ -1,26 +0,0 @@
-package Thread;
-
-import java.util.Random;
-
-class Runner4 implements Runnable {
-    private int zaehler = 0;
-
-    public void run() {
-        int local = new Random().nextInt();
-        System.out.println(local);
-        while (true) {
-            zaehler = local++; 
-        }
-    }
-}
-
-public class SimpleHeapAndStack {
-    public static void main(String[] args) {
-        Runner4 runner = new Runner4();
-        Thread t1 = new Thread(runner, "Thread-1");
-        Thread t2 = new Thread(runner, "Thread-2");
-
-        t1.start();
-        t2.start();
-    }
-}

Programmierung2/src/oop/FileHandling/Echo.java

@@ -0,0 +1,18 @@
+package oop.FileHandling;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Echo {
+	 public static void main(String[] args) throws IOException {
+
+	        BufferedReader br = new BufferedReader(
+	                new InputStreamReader(System.in));
+
+	        String line;
+	        while ((line = br.readLine()) != null) {
+	            System.out.println(line);
+	        }
+	    }
+}

Programmierung2/src/Übungen/Ponggame/Ball.java

@@ -9,8 +9,6 @@ import javax.swing.*;
 
 public class Ball extends Rectangle {
 	
-	
-	
 	int yBewegung;
 	int xBewegung;
 	int speed = 4;