Ende der Vorlesungen
3009594
parent
2314f35393
commit
af0dd7b63d
|
|
@ -1,13 +1,23 @@
|
|||
package Algorithmus;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
|
||||
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.).
|
||||
*/
|
||||
ArrayList<Mitarbeiter> arr = new ArrayList<>();
|
||||
|
||||
arr.add(new Manager());
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class Mitarbeiter{
|
||||
|
||||
}
|
||||
|
||||
class Manager extends Mitarbeiter{
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,6 @@
|
|||
package BinaryTree;
|
||||
|
||||
public class GenericBaum<T,G> {
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
|
@ -1,4 +1,4 @@
|
|||
package DesignPatterns.Erzeugungsmuster_CreationalPatterns.BuilderPatter;
|
||||
package DesignPatterns;
|
||||
|
||||
public class BuilderPattern {
|
||||
// Private Felder
|
||||
|
|
@ -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
|
||||
|
|
@ -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() + "€");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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";
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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";
|
||||
}
|
||||
}
|
||||
|
|
@ -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";
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
package DesignPatterns.Erzeugungsmuster_CreationalPatterns.Factory.Zoo.domain;
|
||||
|
||||
public class Zoo {
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -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!
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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
|
||||
*
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -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
|
||||
|
||||
}
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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());
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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 + " ");
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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
|
||||
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -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.");
|
||||
}
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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 + ")";
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -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 +
|
||||
'}';
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -9,8 +9,6 @@ import javax.swing.*;
|
|||
|
||||
public class Ball extends Rectangle {
|
||||
|
||||
|
||||
|
||||
int yBewegung;
|
||||
int xBewegung;
|
||||
int speed = 4;
|
||||
|
|
|
|||
Loading…
Reference in New Issue