diff --git a/Programmierung2/src/Algorithmus/SwitchCases.java b/Programmierung2/src/Algorithmus/SwitchCases.java index e07b6fd..fa0ac5e 100644 --- a/Programmierung2/src/Algorithmus/SwitchCases.java +++ b/Programmierung2/src/Algorithmus/SwitchCases.java @@ -1,13 +1,23 @@ -package Algorithmus; - -public class SwitchCases { - - public static void main(String[] args) { - /* - * Die Daten Typen, die erlaubt sind: - * - int, char, enum, String und die Wrapper-Typen (Integer, Character, etc.). - */ - - } - -} +package Algorithmus; + +import java.util.ArrayList; + + +public class SwitchCases { + + public static void main(String[] args) { + ArrayList arr = new ArrayList<>(); + + arr.add(new Manager()); + + } + +} + +class Mitarbeiter{ + +} + +class Manager extends Mitarbeiter{ + +} diff --git a/Programmierung2/src/BinaryTree/GenericBaum.java b/Programmierung2/src/BinaryTree/GenericBaum.java new file mode 100644 index 0000000..ac62578 --- /dev/null +++ b/Programmierung2/src/BinaryTree/GenericBaum.java @@ -0,0 +1,6 @@ +package BinaryTree; + +public class GenericBaum { + + +} diff --git a/Programmierung2/src/DesignPatterns/Adapter.java b/Programmierung2/src/DesignPatterns/Adapter.java new file mode 100644 index 0000000..6bd010e --- /dev/null +++ b/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(); + } +} \ No newline at end of file diff --git a/Programmierung2/src/DesignPatterns/All Design Patterns.pdf b/Programmierung2/src/DesignPatterns/All Design Patterns.pdf deleted file mode 100644 index a68ccd3..0000000 Binary files a/Programmierung2/src/DesignPatterns/All Design Patterns.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/BuilderPattern.java b/Programmierung2/src/DesignPatterns/BuilderPattern.java similarity index 95% rename from Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/BuilderPattern.java rename to Programmierung2/src/DesignPatterns/BuilderPattern.java index 78eb079..bedc360 100644 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/BuilderPattern.java +++ b/Programmierung2/src/DesignPatterns/BuilderPattern.java @@ -1,77 +1,77 @@ -package DesignPatterns.Erzeugungsmuster_CreationalPatterns.BuilderPatter; - -public class BuilderPattern { - // Private Felder - private String teig; - private String soße; - private String käse; - private String topping; - - // Private Konstruktor, nur der Builder kann diesen aufrufen - private BuilderPattern(Builder builder) { - this.teig = builder.teig; - this.soße = builder.soße; - this.käse = builder.käse; - this.topping = builder.topping; - } - - // Statische innere Klasse Builder - public static class Builder { - // Dieselben Felder wie in der äußeren Klasse - private String teig; - private String soße; - private String käse; - private String topping; - - // Methoden für das Setzen der Felder, die den Builder zurückgeben - public Builder teig(String teig) { - this.teig = teig; - return this; - } - - public Builder soße(String soße) { - this.soße = soße; - return this; - } - - public Builder käse(String käse) { - this.käse = käse; - return this; - } - - public Builder topping(String topping) { - this.topping = topping; - return this; - } - - // Die build-Methode erstellt das Pizza-Objekt - public BuilderPattern build() { - return new BuilderPattern(this); - } - } - - // Methode, um die Pizza anzuzeigen - public void anzeigen() { - System.out.println("Pizza mit " + teig + " Teig, " + soße + " Soße, " + - käse + " Käse und " + (topping != null ? topping : "ohne") + " Topping."); - } - - public static void main(String[] args) { - // Erstellen einer Pizza mit allen Zutaten - BuilderPattern pizza1 = new BuilderPattern.Builder() - .teig("Dünn") - .soße("Tomaten") - .käse("Mozzarella") - .topping("Salami") - .build(); - - // Erstellen einer Pizza ohne Topping - BuilderPattern pizza2 = new BuilderPattern.Builder() - .teig("Dick") - .soße("Tomaten") - .build(); - - pizza1.anzeigen(); // Ausgabe: Pizza mit Dünn Teig, Tomaten Soße, Mozzarella Käse und Salami Topping. - pizza2.anzeigen(); // Ausgabe: Pizza mit Dick Teig, Tomaten Soße, Cheddar Käse und ohne Topping. - } -} +package DesignPatterns; + +public class BuilderPattern { + // Private Felder + private String teig; + private String soße; + private String käse; + private String topping; + + // Private Konstruktor, nur der Builder kann diesen aufrufen + private BuilderPattern(Builder builder) { + this.teig = builder.teig; + this.soße = builder.soße; + this.käse = builder.käse; + this.topping = builder.topping; + } + + // Statische innere Klasse Builder + public static class Builder { + // Dieselben Felder wie in der äußeren Klasse + private String teig; + private String soße; + private String käse; + private String topping; + + // Methoden für das Setzen der Felder, die den Builder zurückgeben + public Builder teig(String teig) { + this.teig = teig; + return this; + } + + public Builder soße(String soße) { + this.soße = soße; + return this; + } + + public Builder käse(String käse) { + this.käse = käse; + return this; + } + + public Builder topping(String topping) { + this.topping = topping; + return this; + } + + // Die build-Methode erstellt das Pizza-Objekt + public BuilderPattern build() { + return new BuilderPattern(this); + } + } + + // Methode, um die Pizza anzuzeigen + public void anzeigen() { + System.out.println("Pizza mit " + teig + " Teig, " + soße + " Soße, " + + käse + " Käse und " + (topping != null ? topping : "ohne") + " Topping."); + } + + public static void main(String[] args) { + // Erstellen einer Pizza mit allen Zutaten + BuilderPattern pizza1 = new BuilderPattern.Builder() + .teig("Dünn") + .soße("Tomaten") + .käse("Mozzarella") + .topping("Salami") + .build(); + + // Erstellen einer Pizza ohne Topping + BuilderPattern pizza2 = new BuilderPattern.Builder() + .teig("Dick") + .soße("Tomaten") + .build(); + + pizza1.anzeigen(); // Ausgabe: Pizza mit Dünn Teig, Tomaten Soße, Mozzarella Käse und Salami Topping. + pizza2.anzeigen(); // Ausgabe: Pizza mit Dick Teig, Tomaten Soße, Cheddar Käse und ohne Topping. + } +} diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Main.java b/Programmierung2/src/DesignPatterns/Composite.java similarity index 93% rename from Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Main.java rename to Programmierung2/src/DesignPatterns/Composite.java index 4705833..7ee9cb3 100644 --- a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Main.java +++ b/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 diff --git a/Programmierung2/src/DesignPatterns/Dekorator.java b/Programmierung2/src/DesignPatterns/Dekorator.java new file mode 100644 index 0000000..c454283 --- /dev/null +++ b/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() + "€"); + } + +} diff --git a/Programmierung2/src/DesignPatterns/DekoratorKaffe.java b/Programmierung2/src/DesignPatterns/DekoratorKaffe.java new file mode 100644 index 0000000..4d9d7a9 --- /dev/null +++ b/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()); + } +} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/Builder-Pattern.pdf b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/Builder-Pattern.pdf deleted file mode 100644 index 29d5379..0000000 Binary files a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/Builder-Pattern.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/Student.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/Student.java deleted file mode 100644 index eb3e985..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/BuilderPatter/Student.java +++ /dev/null @@ -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(); - } -} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Factory Method.pdf b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Factory Method.pdf deleted file mode 100644 index 4423e41..0000000 Binary files a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Factory Method.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/FactoryMit_Java_Reflection.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/FactoryMit_Java_Reflection.java deleted file mode 100644 index 9012b85..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/FactoryMit_Java_Reflection.java +++ /dev/null @@ -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(); - } -} \ No newline at end of file diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/FaktoryMethode.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/FaktoryMethode.java deleted file mode 100644 index 52f09aa..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/FaktoryMethode.java +++ /dev/null @@ -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; - - } - } - -} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/ZooMain.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/ZooMain.java deleted file mode 100644 index f38352a..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/ZooMain.java +++ /dev/null @@ -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(); - } - -} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/ZooUI.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/ZooUI.java deleted file mode 100644 index a5dabc8..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/ZooUI.java +++ /dev/null @@ -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); - } - - - } - } -} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Animal.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Animal.java deleted file mode 100644 index c48bde6..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Animal.java +++ /dev/null @@ -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); - } - - -} \ No newline at end of file diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Cat.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Cat.java deleted file mode 100644 index 9811c80..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Cat.java +++ /dev/null @@ -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"; - } - -} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Dog.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Dog.java deleted file mode 100644 index c21be47..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Dog.java +++ /dev/null @@ -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"; - } -} \ No newline at end of file diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Mouse.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Mouse.java deleted file mode 100644 index e6a6162..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Mouse.java +++ /dev/null @@ -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"; - } - -} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Zoo.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Zoo.java deleted file mode 100644 index d3acf82..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Zoo/domain/Zoo.java +++ /dev/null @@ -1,8 +0,0 @@ -package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain; - -public class Zoo { - - - - -} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Prototype/Cloneable Interface.pdf b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Prototype/Cloneable Interface.pdf deleted file mode 100644 index 75a9692..0000000 Binary files a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Prototype/Cloneable Interface.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Prototype/Prototype-Entwurfsmuster.odt b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Prototype/Prototype-Entwurfsmuster.odt deleted file mode 100644 index 36aff0d..0000000 Binary files a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Prototype/Prototype-Entwurfsmuster.odt and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Singaleton/Singleton & Lazy Loading.pdf b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Singaleton/Singleton & Lazy Loading.pdf deleted file mode 100644 index a243b9a..0000000 Binary files a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Singaleton/Singleton & Lazy Loading.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Singaleton/Singleton.java b/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Singaleton/Singleton.java deleted file mode 100644 index 262a0b4..0000000 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Singaleton/Singleton.java +++ /dev/null @@ -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! - } - -} diff --git a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Factory_method.java b/Programmierung2/src/DesignPatterns/Factory_method.java similarity index 94% rename from Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Factory_method.java rename to Programmierung2/src/DesignPatterns/Factory_method.java index 8935c03..5c15a2f 100644 --- a/Programmierung2/src/DesignPatterns/Erzeugungsmuster_CreationalPatterns/Factory/Factory_method.java +++ b/Programmierung2/src/DesignPatterns/Factory_method.java @@ -1,75 +1,75 @@ -package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory; - -/* - Erzeugung neuer Objekte nicht im Konstruktor einer Klasse durchführen, sondern durch eine statische Methode - * - * Verwendung Eine Fabrikmethode: - * - erzeugt bei jedem Aufruf neue Objekte - * - unterbindet den direkten Zugriff auf die Konstruktoren einer Klasse - * - * Eigenschaften: - * - einem privaten Konstruktor - * - einer öffentlichen statischen Methode die den privaten Konstruktor nutzt - * - * - */ - -public class Factory_method { - - // Privater Konstruktor: Verhindert Instanziierung - private Factory_method() { - } - - // public statische Methode zum Erstellen neuer Objekt - public static Car createCar(String type) { - switch (type) { - case "Sedan": - return new SedanCar(); - case "Small": - return new SmallCar(); - case "Sport": - return new SportCar(); - default: - return null; - } - } - - public static void main(String[] args) { - - Car sedan = Factory_method.createCar("Sedan"); - Car small = Factory_method.createCar("Small"); - Car sport = Factory_method.createCar("Sport"); - - System.out.println("Price of Sedan Car: $" + sedan.getPrice()); - System.out.println("Price of Small Car: $" + small.getPrice()); - System.out.println("Price of Sport Car: $" + sport.getPrice()); - - } - -} - -// oder Interface -abstract class Car{ - public abstract int getPrice(); -} - -class SedanCar extends Car { - @Override - public int getPrice() { - return 100000; - } -} - -class SmallCar extends Car { - @Override - public int getPrice() { - return 50000; - } -} - -class SportCar extends Car { - @Override - public int getPrice() { - return 250000; - } -} - +package DesignPatterns; + +/* - Erzeugung neuer Objekte nicht im Konstruktor einer Klasse durchführen, sondern durch eine statische Methode + * + * Verwendung Eine Fabrikmethode: + * - erzeugt bei jedem Aufruf neue Objekte + * - unterbindet den direkten Zugriff auf die Konstruktoren einer Klasse + * + * Eigenschaften: + * - einem privaten Konstruktor + * - einer öffentlichen statischen Methode die den privaten Konstruktor nutzt + * + * + */ + +public class Factory_method { + + // Privater Konstruktor: Verhindert Instanziierung + private Factory_method() { + } + + // public statische Methode zum Erstellen neuer Objekt + public static Car createCar(String type) { + switch (type) { + case "Sedan": + return new SedanCar(); + case "Small": + return new SmallCar(); + case "Sport": + return new SportCar(); + default: + return null; + } + } + + public static void main(String[] args) { + + Car sedan = Factory_method.createCar("Sedan"); + Car small = Factory_method.createCar("Small"); + Car sport = Factory_method.createCar("Sport"); + + System.out.println("Price of Sedan Car: $" + sedan.getPrice()); + System.out.println("Price of Small Car: $" + small.getPrice()); + System.out.println("Price of Sport Car: $" + sport.getPrice()); + + } + +} + +// oder Interface +abstract class Car{ + public abstract int getPrice(); +} + +class SedanCar extends Car { + @Override + public int getPrice() { + return 100000; + } +} + +class SmallCar extends Car { + @Override + public int getPrice() { + return 50000; + } +} + +class SportCar extends Car { + @Override + public int getPrice() { + return 250000; + } +} + diff --git a/Programmierung2/src/DesignPatterns/SOLID_Principles/DependencyInversionPrinciple_DIP/Dependency Inversion Principle (DIP).pdf b/Programmierung2/src/DesignPatterns/SOLID_Principles/DependencyInversionPrinciple_DIP/Dependency Inversion Principle (DIP).pdf deleted file mode 100644 index 13cd289..0000000 Binary files a/Programmierung2/src/DesignPatterns/SOLID_Principles/DependencyInversionPrinciple_DIP/Dependency Inversion Principle (DIP).pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/SOLID_Principles/InterfaceSegregationPrinciple_ISP/Interface Segregation Principle (ISP).pdf b/Programmierung2/src/DesignPatterns/SOLID_Principles/InterfaceSegregationPrinciple_ISP/Interface Segregation Principle (ISP).pdf deleted file mode 100644 index 288e8fd..0000000 Binary files a/Programmierung2/src/DesignPatterns/SOLID_Principles/InterfaceSegregationPrinciple_ISP/Interface Segregation Principle (ISP).pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/SOLID_Principles/LiskovSubstitution_Principle_LSP/Beispiele für Verstöße gegen das LSP in der Java.pdf b/Programmierung2/src/DesignPatterns/SOLID_Principles/LiskovSubstitution_Principle_LSP/Beispiele für Verstöße gegen das LSP in der Java.pdf deleted file mode 100644 index 1303daa..0000000 Binary files a/Programmierung2/src/DesignPatterns/SOLID_Principles/LiskovSubstitution_Principle_LSP/Beispiele für Verstöße gegen das LSP in der Java.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/SOLID_Principles/LiskovSubstitution_Principle_LSP/Liskov Substitution Principle (LSP).pdf b/Programmierung2/src/DesignPatterns/SOLID_Principles/LiskovSubstitution_Principle_LSP/Liskov Substitution Principle (LSP).pdf deleted file mode 100644 index c8fe6b4..0000000 Binary files a/Programmierung2/src/DesignPatterns/SOLID_Principles/LiskovSubstitution_Principle_LSP/Liskov Substitution Principle (LSP).pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/SOLID_Principles/OpenClosed_Principle_OCP/Open_Closed Principle (OCP).pdf b/Programmierung2/src/DesignPatterns/SOLID_Principles/OpenClosed_Principle_OCP/Open_Closed Principle (OCP).pdf deleted file mode 100644 index e78979c..0000000 Binary files a/Programmierung2/src/DesignPatterns/SOLID_Principles/OpenClosed_Principle_OCP/Open_Closed Principle (OCP).pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/SOLID_Principles/SOLID-Prinzipien.pdf b/Programmierung2/src/DesignPatterns/SOLID_Principles/SOLID-Prinzipien.pdf deleted file mode 100644 index 6b5af12..0000000 Binary files a/Programmierung2/src/DesignPatterns/SOLID_Principles/SOLID-Prinzipien.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/SOLID_Principles/Single_Responsibility_Principle/Single Responsibility Principle.pdf b/Programmierung2/src/DesignPatterns/SOLID_Principles/Single_Responsibility_Principle/Single Responsibility Principle.pdf deleted file mode 100644 index 91e6709..0000000 Binary files a/Programmierung2/src/DesignPatterns/SOLID_Principles/Single_Responsibility_Principle/Single Responsibility Principle.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Kompositum-Entwurfsmuster (Composite).odt b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Kompositum-Entwurfsmuster (Composite).odt deleted file mode 100644 index b694652..0000000 Binary files a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Composite/Kompositum-Entwurfsmuster (Composite).odt and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/FacadePattern/Fassade.pdf b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/FacadePattern/Fassade.pdf deleted file mode 100644 index bf96d88..0000000 Binary files a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/FacadePattern/Fassade.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/FacadePattern/FassadeHummel.pdf b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/FacadePattern/FassadeHummel.pdf deleted file mode 100644 index 216347c..0000000 Binary files a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/FacadePattern/FassadeHummel.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Proxy_Pattern/BankkontoProxy.java b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Proxy_Pattern/BankkontoProxy.java deleted file mode 100644 index 24c9d17..0000000 --- a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Proxy_Pattern/BankkontoProxy.java +++ /dev/null @@ -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 - - } -} diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Proxy_Pattern/Proxy-Pattern.pdf b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Proxy_Pattern/Proxy-Pattern.pdf deleted file mode 100644 index 22b8193..0000000 Binary files a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/Proxy_Pattern/Proxy-Pattern.pdf and /dev/null differ diff --git a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/structural design patterns.pdf b/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/structural design patterns.pdf deleted file mode 100644 index 9effecd..0000000 Binary files a/Programmierung2/src/DesignPatterns/strukturellen_Entwurfsmustern/structural design patterns.pdf and /dev/null differ diff --git a/Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo2.java b/Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo2.java new file mode 100644 index 0000000..0b5b143 --- /dev/null +++ b/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(); + } + } + +} \ No newline at end of file diff --git a/Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo3.java b/Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo3.java new file mode 100644 index 0000000..a04d824 --- /dev/null +++ b/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 arr = new ArrayList<>(); + arr.add(2); + arr.add(3); + addTenNumbers(arr); + } + public static void addTenNumbers (List array) { + for (int i = 0; i < 10; i++) { + array.add(i); + } + } + +} \ No newline at end of file diff --git a/Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo4.java b/Programmierung2/src/GUIAnwendungen/Klausur/GuiDemo4.java new file mode 100644 index 0000000..9985431 --- /dev/null +++ b/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()); + } + + +} \ No newline at end of file diff --git a/Programmierung2/src/Klausur/Algorthmen.java b/Programmierung2/src/Klausur/Algorthmen.java new file mode 100644 index 0000000..3371db9 --- /dev/null +++ b/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> oddNumbers(int[] arr){ + + Map> gerade = new HashMap<>(); + Map> 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; + + + } + + +} diff --git a/Programmierung2/src/Klausur/Bauobjekt.java b/Programmierung2/src/Klausur/Bauobjekt.java new file mode 100644 index 0000000..7aae4bc --- /dev/null +++ b/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 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 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); + + } + +} diff --git a/Programmierung2/src/Klausur/Graph.java b/Programmierung2/src/Klausur/Graph.java new file mode 100644 index 0000000..3dd2155 --- /dev/null +++ b/Programmierung2/src/Klausur/Graph.java @@ -0,0 +1,133 @@ +package Klausur; + +import java.util.*; + +//Klasse für den Graphen mit Generics +class Graph { + + // Wir verwenden eine HashMap, um die Kanten im Graphen zu speichern + private Map> map = new HashMap<>(); + + // Diese Methode fügt einen neuen Knoten (Vertex) zum Graphen hinzu + public void knotenHinzufuegen(T s) { + map.put(s, new LinkedList()); + } + + // 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 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); + } +} \ No newline at end of file diff --git a/Programmierung2/src/Klausur/Lambda.java b/Programmierung2/src/Klausur/Lambda.java new file mode 100644 index 0000000..c6a0219 --- /dev/null +++ b/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 tage = Arrays.asList( + Wochentag.MITTWOCH, + Wochentag.FREITAG, + Wochentag.MONTAG, + Wochentag.SONNTAG + ); + + tage.stream().collect(Collectors.partitioningBy(null)); + } + } + +enum Wochentag implements Comparable { + MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG; + + +} \ No newline at end of file diff --git a/Programmierung2/src/Klausur/MyBaum.java b/Programmierung2/src/Klausur/MyBaum.java new file mode 100644 index 0000000..a0295b5 --- /dev/null +++ b/Programmierung2/src/Klausur/MyBaum.java @@ -0,0 +1,229 @@ + +package Klausur; + +import java.util.LinkedList; +import java.util.Queue; + +public class MyBaum> { + private Node wurzel; + private int size; + + public boolean add(T wert) { + + if (wurzel == null) { + this.wurzel = new Node(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> { + + Node links; + Node 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 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 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 findSmallest() { + if (links == null) { + return this; // Der kleinste Knoten ist der linkeste Knoten + } + return links.findSmallest(); + } + + + private Node 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 wurzel) { + + Queue> queue = new LinkedList<>(); + queue.add(wurzel); + + while (!queue.isEmpty()) { + Node temp = queue.poll(); + + if (temp.links != null) + queue.add(temp.links); + + if (temp.rechts != null) + queue.add(temp.rechts); + + System.out.print(temp.wert + " "); + + } + + } + + } +} diff --git a/Programmierung2/src/Klausur/MyGraph.java b/Programmierung2/src/Klausur/MyGraph.java new file mode 100644 index 0000000..238d761 --- /dev/null +++ b/Programmierung2/src/Klausur/MyGraph.java @@ -0,0 +1,31 @@ +package Klausur; + +import java.util.*; + +public class MyGraph { + + Map> 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); + } + + +} diff --git a/Programmierung2/src/Klausur/Navi/Navi.java b/Programmierung2/src/Klausur/Navi/Navi.java new file mode 100644 index 0000000..f4d0e38 --- /dev/null +++ b/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 orte = new HashMap<>(); + private static PriorityQueue 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 + +} diff --git a/Programmierung2/src/Klausur/Navi/Ort.java b/Programmierung2/src/Klausur/Navi/Ort.java new file mode 100644 index 0000000..c6fd527 --- /dev/null +++ b/Programmierung2/src/Klausur/Navi/Ort.java @@ -0,0 +1,60 @@ +package Klausur.Navi; + +import java.util.ArrayList; + +public class Ort implements Comparable { + private String name; + private ArrayList 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 getStrassen() { + return strassen; + } +} diff --git a/Programmierung2/src/Klausur/Navi/Strasse.java b/Programmierung2/src/Klausur/Navi/Strasse.java new file mode 100644 index 0000000..88a581e --- /dev/null +++ b/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; + } + +} diff --git a/Programmierung2/src/Klausur/Ort.java b/Programmierung2/src/Klausur/Ort.java new file mode 100644 index 0000000..9c9858d --- /dev/null +++ b/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 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); + } +} + + + + diff --git a/Programmierung2/src/Klausur/Person.java b/Programmierung2/src/Klausur/Person.java new file mode 100644 index 0000000..ecd07f8 --- /dev/null +++ b/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 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."); + } +} \ No newline at end of file diff --git a/Programmierung2/src/Klausur/TestBaum.java b/Programmierung2/src/Klausur/TestBaum.java new file mode 100644 index 0000000..17130e2 --- /dev/null +++ b/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 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)); + } + +} diff --git a/Programmierung2/src/Klausur/mensch/Mensch.java b/Programmierung2/src/Klausur/mensch/Mensch.java new file mode 100644 index 0000000..41d9ac0 --- /dev/null +++ b/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 + ")"; + } +} + diff --git a/Programmierung2/src/Klausur/stream/Main.java b/Programmierung2/src/Klausur/stream/Main.java new file mode 100644 index 0000000..4741e53 --- /dev/null +++ b/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 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 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 studenten = new ArrayList<>(); + studenten.add(new Student("Anna Müller", "Berlin", "Informatik", pruefungen1)); + studenten.add(new Student("Max Meier", "Hamburg", "Wirtschaftsinformatik", pruefungen2)); + + + Map> 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 pruefungen; + + public Student(String name, String wohnort, String studiengang, List 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 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 + + '}'; + } +} + diff --git a/Programmierung2/src/Thread/Deadlock.java b/Programmierung2/src/Thread/Deadlock.java new file mode 100644 index 0000000..7a3f705 --- /dev/null +++ b/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(); + } +} diff --git a/Programmierung2/src/Thread/MyRunnable.java b/Programmierung2/src/Thread/MyRunnable.java new file mode 100644 index 0000000..8de6a27 --- /dev/null +++ b/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(); + } + +} diff --git a/Programmierung2/src/Thread/Runner4.java b/Programmierung2/src/Thread/Runner4.java new file mode 100644 index 0000000..9f6c9ee --- /dev/null +++ b/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(); + } +} diff --git a/Programmierung2/src/Thread/SimpleHeapAndStack.java b/Programmierung2/src/Thread/SimpleHeapAndStack.java deleted file mode 100644 index 5eae700..0000000 --- a/Programmierung2/src/Thread/SimpleHeapAndStack.java +++ /dev/null @@ -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(); - } -} diff --git a/Programmierung2/src/oop/FileHandling/Echo.java b/Programmierung2/src/oop/FileHandling/Echo.java new file mode 100644 index 0000000..0d6ee11 --- /dev/null +++ b/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); + } + } +} diff --git a/Programmierung2/src/Übungen/Ponggame/Ball.java b/Programmierung2/src/Übungen/Ponggame/Ball.java index 0a7d616..1d692b3 100644 --- a/Programmierung2/src/Übungen/Ponggame/Ball.java +++ b/Programmierung2/src/Übungen/Ponggame/Ball.java @@ -1,49 +1,47 @@ -package Übungen.Ponggame; - -import java.awt.*; -import java.awt.*; -import java.awt.event.KeyEvent; -import java.util.Random; - -import javax.swing.*; - -public class Ball extends Rectangle { - - - - int yBewegung; - int xBewegung; - int speed = 4; - Random random = new Random(); - - Ball(int x, int y, int width, int height){ - super(x,y,width,height); - xBewegung = random.nextInt(10) -5; - if (xBewegung == 0) - xBewegung++; - xBewegung(xBewegung * speed); - - } - - public void draw(Graphics g) { - g.setColor(Color.green); - g.fillOval(x, y, width, height); - - } - - public void xBewegung(int x) { - xBewegung = x; - } - public void yBewegung(int y) { - yBewegung = y; - } - - public void move() { - x += xBewegung; - y += yBewegung; - - } - - - -} +package Übungen.Ponggame; + +import java.awt.*; +import java.awt.*; +import java.awt.event.KeyEvent; +import java.util.Random; + +import javax.swing.*; + +public class Ball extends Rectangle { + + int yBewegung; + int xBewegung; + int speed = 4; + Random random = new Random(); + + Ball(int x, int y, int width, int height){ + super(x,y,width,height); + xBewegung = random.nextInt(10) -5; + if (xBewegung == 0) + xBewegung++; + xBewegung(xBewegung * speed); + + } + + public void draw(Graphics g) { + g.setColor(Color.green); + g.fillOval(x, y, width, height); + + } + + public void xBewegung(int x) { + xBewegung = x; + } + public void yBewegung(int y) { + yBewegung = y; + } + + public void move() { + x += xBewegung; + y += yBewegung; + + } + + + +}