parkhaus

Programmierung2/src/GUIAnwendungen/StudentManagementSystem/VerwalteStudent.java

@@ -64,23 +64,17 @@ public class VerwalteStudent {
 	}
 	
 	public void showUser() {
-		String studentName = view.getEingabeNameZuSuchen().getText();
+		String idText = view.getEingabeIdZuLoeschen().getText();
-		student = findStudent(studentName);
+		int id = Integer.parseInt(idText);
+		student = findStudent(id);
 		if (student != null) {
-			String[] array = {student.getId()+"",student.getAdresse(),student.getEmail(),student.getGeburtstag(),student.getGeschlecht(),student.getName(),student.getTele()};
+			String[] array = {student.getId()+"",student.getName(),student.getVorname(),student.getGeburtstag(),student.getGeschlecht(),student.getTele(),student.getEmail(),student.getAdresse()};
 			view.getModel().addRow(array);
 			view.setEingabeNameZuSuchen("");
 		}else
 			view.showErrore("Der Student wurde nicht gefunden");
 	}
 	
-	private Student findStudent(String studentName) {
-		for (Student s : allStudents)
-			if (s.getName().equals(studentName))
-				return s;
-		
-		return null;
-	}
 	
 	public void restAlleInputs() {
 		view.setEingabeName("");;

Programmierung2/src/MyCollections/List/My_ArrayList.java

@@ -27,6 +27,7 @@ public class My_ArrayList <V> implements MyList<V> {
 		for (int i = 0; i < arr.length ; i++)
 			neuarr[i] = arr[i];
 		arr = neuarr;
+		neuarr = null;
 	}
 	
 	@Override

Programmierung2/src/MyCollections/List/Test.java

@@ -8,13 +8,27 @@ public class Test {
 		
 		ArrayList<Integer> test = new ArrayList<>();
 		
+		test.add(12);
+		test.add(13);
+		test.add(12);
+		test.add(13);
+		test.add(12);
+		test.add(13);
+		test.add(12);
+		test.add(13);
+		test.add(12);
+		test.add(13);
+		test.add(12);
+		test.add(13);
+		test.add(12);
+		test.add(13);
+		test.add(12);
+		test.add(13);
 		test.add(12);
 		test.add(13);
 		
 		System.out.println(test);
 		
-		test.add(0, 14);
-		System.out.println(test);
 	}
 
 }

Programmierung2/src/Parkhaus/Allgemeine_Test.java

@@ -0,0 +1,47 @@
+package Parkhaus;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.text.SimpleDateFormat;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class Allgemeine_Test {
+	
+	private Parkhaus system;
+    private SimpleDateFormat sdf;
+	
+	@BeforeEach
+	void setUp() throws Exception {
+		system = new Parkhaus();
+		sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+	}
+
+	@Test
+	void test_Parkhaus() throws Exception {
+		String kennzeichen = "MA-SH 4077";
+		String einfahrt = "01.10.2024, 14:30";
+		String ausfahrt = "01.10.2024, 14:50";
+		String GueltigeVISAKartennummer =  "4509472140549006";     
+		
+		// Einfahren: True => Beide assertTrue Tests.
+		String einfahren = system.einfahren(kennzeichen, einfahrt);
+		assertTrue(einfahren.contains(kennzeichen));
+		assertTrue(einfahren.contains(einfahrt));
+		assertEquals(179,system.getMaxPlaetze());
+		
+		// Parkgebühren berechnen: True => da nur eine Stunde
+		double betrag = system.berechneParkgebuehren(kennzeichen, ausfahrt);
+		assertEquals(1,betrag);
+		
+			//Parkgebühren sofort Bezahlen mit Visa-karte: True => Beide assertTrue Tests.
+			assertTrue(system.checkVisakarteNummer(GueltigeVISAKartennummer));
+			assertTrue(system.setBezahlt(kennzeichen));
+			
+		// Ausfahren: True => Beide assertTrue Tests.
+		assertTrue(system.ausfahren(kennzeichen, ausfahrt));
+		assertEquals(180,system.getMaxPlaetze());
+	}
+
+}

Programmierung2/src/Parkhaus/AutoNichtGefundenException.java

@@ -0,0 +1,9 @@
+package Parkhaus;
+
+public class AutoNichtGefundenException extends Exception {
+	
+	AutoNichtGefundenException(String autoNichtGefunden){
+		super(autoNichtGefunden);
+	}
+
+}

Programmierung2/src/Parkhaus/Fahrzeug.java

@@ -0,0 +1,93 @@
+package Parkhaus;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/* Jedes Fahrzeug hat ihr eigene: 
+ * 	- Kennzeichen
+ *  - Einfahrtzeit sowie Ausfahrtzeit
+ *  - Betrag
+ *  
+ *	- Ich gehe davon aus, dass das Fahrzeug automatisch als nicht bezahlt gilt, wenn es in das Parkhaus einfährt.
+ * 
+ */
+public class Fahrzeug {
+
+	private String kennzeichen;
+	private Date einfahrt;
+	private Date ausfahrt;
+	private boolean istBezahlt;
+	private boolean istVerschuldet;
+	private double betrag;
+
+	Fahrzeug() {
+		this(kennzeichenzufaelliggenerieren.kennzeichengenerieren(), new Date());
+	}
+
+	Fahrzeug(String kennzeichen) {
+		this(kennzeichen, new Date());
+	}
+
+	Fahrzeug(Date einfahrt) {
+		this(kennzeichenzufaelliggenerieren.kennzeichengenerieren(), einfahrt);
+	}
+
+	Fahrzeug(String kennzeichen, Date einfahrt) {
+		this.kennzeichen = kennzeichen;
+		this.einfahrt = einfahrt;
+		this.betrag = 0.0;
+		this.istBezahlt = false;
+		this.istVerschuldet = false;
+	}
+
+	public String getKennzeichen() {
+		return kennzeichen;
+	}
+
+	// Diese Methode hilft mir, die Zeit in der Console formatted auszugeben
+	public String getEinfahrtFormatted() {
+		SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+		return sdf.format(einfahrt);
+	}
+
+	public Date getEinfahrt() {
+		return einfahrt;
+	}
+
+	public void setEinfahrt(Date einfahrt) {
+		this.einfahrt = einfahrt;
+	}
+
+	public Date getAusfahrt() {
+		return ausfahrt;
+	}
+
+	public void setAusfahrt(Date ausfahrt) {
+		this.ausfahrt = ausfahrt;
+	}
+
+	public boolean isBezahlt() {
+		return istBezahlt;
+	}
+
+	public void setBezahlt(boolean bezahlt) {
+		this.istBezahlt = bezahlt;
+	}
+
+	public double getBetrag() {
+		return betrag;
+	}
+
+	public void setBetrag(double betrag) {
+		this.betrag += betrag;
+	}
+
+	public boolean IstVerschuldet() {
+		return istVerschuldet;
+	}
+
+	public void setIstVerschuldet(boolean istVerschuldet) {
+		this.istVerschuldet = istVerschuldet;
+	}
+
+}

Programmierung2/src/Parkhaus/JTest_AutoMitSchulden.java

@@ -0,0 +1,52 @@
+package Parkhaus;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class JTest_AutoMitSchulden {
+
+	private Parkhaus parkhaus;
+    private SimpleDateFormat sdf;
+    
+	@BeforeEach
+	void start() throws ParseException {
+		parkhaus = new Parkhaus();
+		sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+	}
+	
+
+	@Test
+	public void test_AutoMitSchulden() throws Exception {
+
+		String kennzeichen = "MA-SH 4077";
+		String einfahrt = "01.10.2024, 12:30";
+		String ausfahrt = "01.10.2024, 13:00";
+		
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt);
+		parkhaus.setVerschuldet(kennzeichen);
+		parkhaus.ausfahren(kennzeichen, ausfahrt);
+
+		einfahrt = "01.10.2024, 13:30";
+		ausfahrt = "01.10.2024, 14:00";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt);
+		parkhaus.setVerschuldet(kennzeichen);
+		parkhaus.ausfahren(kennzeichen, ausfahrt);
+		
+		einfahrt = "01.10.2024, 14:30";
+		ausfahrt = "01.10.2024, 16:00";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt);
+		parkhaus.setVerschuldet(kennzeichen);
+		parkhaus.ausfahren(kennzeichen, ausfahrt);
+		
+		
+	}
+
+}

Programmierung2/src/Parkhaus/JTest_Einfahren.java

@@ -0,0 +1,32 @@
+package Parkhaus;
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.*;
+import java.text.ParseException;
+
+class JTest_Einfahren {
+	  private Parkhaus parkhaus; 
+	  
+	@BeforeEach
+	void start() {
+		parkhaus = new Parkhaus();
+	}
+	
+	   @Test
+	    public void testEinfahrenOhneEingabe() throws ParseException {
+		   
+		   parkhaus.einfahren("", "");
+		   assertEquals(179, parkhaus.getMaxPlaetze());
+	   }
+	   
+	   @Test
+	    public void testEinfahrenMitEingabe() throws ParseException {
+		   String kennzeichen = "MA-SH 4077";
+	       String einfahrtzeit = "01.10.2024, 14:30";
+		   String test = parkhaus.einfahren(kennzeichen, einfahrtzeit);
+		   assertTrue(test.contains(kennzeichen));
+		   assertTrue(test.contains(einfahrtzeit));
+		   assertEquals(179, parkhaus.getMaxPlaetze());
+		   
+	   }
+}

Programmierung2/src/Parkhaus/JTest_ausfahren.java

@@ -0,0 +1,39 @@
+package Parkhaus;
+
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+class JTest_ausfahren {
+	private Parkhaus parkhaus;
+    private SimpleDateFormat sdf;
+	@BeforeEach
+	void start() throws ParseException {
+		parkhaus = new Parkhaus();
+		sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+	}
+	
+	@Test
+	public void test_ausfahren() throws Exception {
+		String kennzeichen = "MA-SH 4077";
+		String einfahrt = "01.10.2024, 14:30";
+		String ausfahrt = "01.10.2024, 15:30";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		
+		parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt);
+		
+		
+		assertTrue(parkhaus.checkVisakarteNummer("9823192757222993"));
+		assertTrue(parkhaus.setBezahlt(kennzeichen));
+		assertTrue(parkhaus.gebuerenNehmen(1));
+	
+	}
+
+}

Programmierung2/src/Parkhaus/JTest_berechneParkgebuehren.java

@@ -0,0 +1,86 @@
+package Parkhaus;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+class JTest_berechneParkgebuehren {
+
+	private Parkhaus parkhaus;
+    private SimpleDateFormat sdf;
+	@BeforeEach
+	void start() throws ParseException {
+		parkhaus = new Parkhaus();
+		sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+	}
+	
+	@Test
+	public void test_EautoBetrag() throws ParseException, AutoNichtGefundenException {
+		String kennzeichen = "MA-SH 4077E";
+		String einfahrt = "01.10.2024, 14:30";
+		String ausfahrt = "01.10.2024, 14:45";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		
+		// 15 Minuten => True
+		assertEquals(0,parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt)); 
+		
+		// 16 Minuten => True
+		einfahrt = "01.10.2024, 14:30";
+		ausfahrt = "01.10.2024, 14:50";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		assertEquals(0.8,parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt)); 
+		
+		
+	}
+	
+	@Disabled
+	public void test_berechneParkgebuehren() throws ParseException, AutoNichtGefundenException {
+		String kennzeichen = "MA-SH 4077";
+		String einfahrt = "01.10.2024, 14:30";
+		String ausfahrt = "01.10.2024, 14:45";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		
+		// 15 Minuten => True
+		assertEquals(0,parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt)); 
+		
+		// 16 Minuten => True
+		einfahrt = "01.10.2024, 14:30";
+		ausfahrt = "01.10.2024, 14:46";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		assertEquals(1,parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt)); 
+		
+		// 1 Stunde => True
+		einfahrt = "01.10.2024, 14:30";
+		ausfahrt = "01.10.2024, 15:30";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		assertEquals(1, parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt));
+		
+
+		// 2 Stunden => True
+		einfahrt = "01.10.2024, 14:00";
+		ausfahrt = "01.10.2024, 16:00";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		assertEquals(2, parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt));
+
+		// Zwischen 20 bis 6 Uhr => True
+		einfahrt = "01.10.2024, 22:00";
+		ausfahrt = "02.10.2024, 04:00";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		assertEquals(5, parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt));
+
+		// 24 Stunden
+		einfahrt = "01.10.2024, 14:00";
+		ausfahrt = "02.10.2024, 14:00";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		assertEquals(15, parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt));
+	}
+	
+	
+
+}

Programmierung2/src/Parkhaus/JTest_checkVisakarte.java

@@ -0,0 +1,46 @@
+package Parkhaus;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+class JTest_checkVisakarte {
+	
+	private Parkhaus parkhaus;
+    private SimpleDateFormat sdf;
+    
+	@BeforeEach
+	void start() throws ParseException {
+		parkhaus = new Parkhaus();
+		sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+	}
+	
+	
+	@Test
+	public void test_visakarteNummer() throws Exception{
+		String kennzeichen = "MA-SH 4077";
+		String einfahrt = "01.10.2024, 14:30";
+		String ausfahrt = "01.10.2024, 14:50";
+		parkhaus.einfahren(kennzeichen, einfahrt);
+		parkhaus.berechneParkgebuehren(kennzeichen, ausfahrt);
+
+		String GueltigeVISAKartennummer =  "4509472140549006";   
+		// Gültige Nummer => True
+		assertTrue(parkhaus.checkVisakarteNummer(GueltigeVISAKartennummer));
+		assertTrue(parkhaus.setBezahlt(kennzeichen));
+		
+		// Ungültige Nummer => True (da der Test False testet)
+		String ungueltigeVISAKartennummer = "4509472140549002";
+		assertFalse(parkhaus.checkVisakarteNummer(ungueltigeVISAKartennummer));
+	}
+	
+	
+	
+	
+
+}

Programmierung2/src/Parkhaus/Main.java

@@ -0,0 +1,14 @@
+package Parkhaus;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+public class Main {
+
+	public static void main(String[] args) throws ParseException, AutoNichtGefundenException, Exception {
+		
+		new TextUI();
+		
+	}
+
+}

Programmierung2/src/Parkhaus/Parkhaus.java

@@ -0,0 +1,226 @@
+package Parkhaus;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+/* Parkhaus klasse
+ *  - Extern klasse dient als System
+ *  - mit diseser Kalsse integriert der User (Autofahrer)
+ * 
+ */
+public class Parkhaus {
+	private ArrayList<Fahrzeug> fahrzeuge;
+	private Set<Fahrzeug> fahrzeugeMitSchulden;
+	private int maxPlaetze;
+	private SimpleDateFormat sdf;
+	private Fahrzeug fahrzeug;
+	private double betragAktuellesAuto;
+
+	Parkhaus() {
+		this.fahrzeuge = new ArrayList<>();
+		this.fahrzeugeMitSchulden = new HashSet<>();
+		this.maxPlaetze = 180;
+		this.sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+	}
+
+	public String einfahren(String kennzeichen, String einfahrtzeit) throws ParseException {
+		Date einfahrt;
+		
+		if (kennzeichen.isEmpty() && einfahrtzeit.isEmpty())
+			fahrzeug = new Fahrzeug();
+		else if (kennzeichen.isEmpty())
+			fahrzeug = new Fahrzeug(einfahrtzeit);
+		else if (einfahrtzeit.isEmpty())
+			fahrzeug = new Fahrzeug(kennzeichen);
+		else {
+			einfahrt = sdf.parse(einfahrtzeit);
+			fahrzeug = new Fahrzeug(kennzeichen, einfahrt);
+		}
+		fahrzeuge.add(fahrzeug);
+
+		// reduziere ich die Anzahl der verfügbare Parkplätze im Parkhaus
+		maxPlaetze--;
+		return "Das Fahrzeug mit dem Kennzeichen: " + fahrzeug.getKennzeichen() + "\n" + "wurde um: "
+				+ fahrzeug.getEinfahrtFormatted() + " im Parkhaus eingefahren.";
+	}
+
+	public double berechneParkgebuehren(String kennzeichen, String ausfahrtzeit)
+			throws AutoNichtGefundenException, ParseException {
+		if (kennzeichen.isEmpty())
+			throw new AutoNichtGefundenException("Sie müssen bitte das Kennzeichen Ihres Autos eingeben.");
+		
+		boolean isEauto = false;
+		if (kennzeichen.endsWith("E"))
+			isEauto = true;
+
+		fahrzeug = findeFahrzeug(kennzeichen);
+		Date einfahrt = fahrzeug.getEinfahrt();
+		Date ausfahrt;
+
+		if (ausfahrtzeit.isEmpty()) {
+			String aktuelleZeitString = sdf.format(new Date());
+			ausfahrt = sdf.parse(aktuelleZeitString);
+		} else
+			ausfahrt = sdf.parse(ausfahrtzeit);
+
+		double inMinuten = (ausfahrt.getTime() - einfahrt.getTime()) / 1000.0 / 60.0;
+		int inStunden = (int) Math.ceil(inMinuten / 60.0);
+		int maxNachtBetrag = 5;
+		int maxTagBetrag = 15;
+		betragAktuellesAuto = 0;
+
+		//gibt eine Kalenderinstanz zurück, die auf das aktuelle Datum und die Uhrzeit eingestellt ist
+		Calendar calEinfahrt = Calendar.getInstance();
+		
+		calEinfahrt.setTime(einfahrt);
+
+		Calendar calAusfahrt = Calendar.getInstance();
+		calAusfahrt.setTime(ausfahrt);
+
+		int einfahrtStunde = calEinfahrt.get(Calendar.HOUR_OF_DAY);
+		int ausfahrtStunde = calAusfahrt.get(Calendar.HOUR_OF_DAY);
+
+		if (inMinuten <= 15)
+			betragAktuellesAuto = 0;
+
+		else if ((einfahrtStunde < 6 || einfahrtStunde >= 20) || (ausfahrtStunde < 6 || ausfahrtStunde >= 20))
+			betragAktuellesAuto = (inStunden <= maxNachtBetrag) ? inStunden : maxNachtBetrag;
+
+		else {
+			betragAktuellesAuto = inStunden;
+			if (betragAktuellesAuto > maxTagBetrag) {
+				betragAktuellesAuto = maxTagBetrag;
+			}
+		}
+		if (isEauto)
+			betragAktuellesAuto -= rabattFuerEauto(betragAktuellesAuto);
+		
+		betragAktuellesAuto += sendSchulden(kennzeichen);
+		fahrzeug.setBetrag(betragAktuellesAuto);
+		
+		return fahrzeug.getBetrag();
+	}
+
+	public boolean ausfahren(String kennzeichen, String ausfahrtzeit)
+			throws AutoNichtGefundenException, ParseException {
+		if (kennzeichen.isEmpty())
+			throw new AutoNichtGefundenException("Sie müssen bitte das Kennzeichen Ihres Autos eingeben.");
+
+		fahrzeug = findeFahrzeug(kennzeichen);
+		Date ausfahrt;
+		if (ausfahrtzeit.isEmpty()) {
+			String aktuelleZeitString = sdf.format(new Date());
+			ausfahrt = sdf.parse(aktuelleZeitString);
+		} else
+			ausfahrt = sdf.parse(ausfahrtzeit);
+
+		if (fahrzeug.isBezahlt() == true || fahrzeug.IstVerschuldet() == true) {
+			fahrzeuge.remove(fahrzeug);
+			maxPlaetze++;
+			return true;
+		}
+
+		return false;
+	}
+	
+	public String getkennzeichenAktuellesAuto() {
+		return this.fahrzeug.getKennzeichen();
+	}
+
+	public boolean setBezahlt(String kennzeichen) throws AutoNichtGefundenException {
+		fahrzeug = findeFahrzeug(kennzeichen);
+		fahrzeug.setBezahlt(true);
+		fahrzeug.setIstVerschuldet(false);
+		for (Fahrzeug f : fahrzeugeMitSchulden) 
+			if (f.getKennzeichen().equalsIgnoreCase(kennzeichen)) {
+				fahrzeugeMitSchulden.remove(fahrzeug);
+				break; 
+			}
+		
+		return fahrzeug.isBezahlt();
+	}
+
+	public boolean setVerschuldet(String kennzeichen) throws AutoNichtGefundenException {
+		/* - Speichere das Auto, welches Schulden hat
+		 * - Wenn das Auto nochmal Schuldne hat,
+		 *   lösche das alte Objekt und speichere das neue mit dem neuen Betrag
+		 * 
+		 */
+		fahrzeug = findeFahrzeug(kennzeichen);
+		fahrzeug.setIstVerschuldet(true); 
+		fahrzeug.setBezahlt(false); 
+		
+		Fahrzeug zuEntfernendesFahrzeug = null;
+		
+		
+		for (Fahrzeug f : fahrzeugeMitSchulden) 
+			if (f.getKennzeichen().equalsIgnoreCase(kennzeichen)) {
+				//Markiere das Auto, das wir löschen wollen
+				zuEntfernendesFahrzeug = f; 
+				break; 
+			}
+		
+		if (zuEntfernendesFahrzeug != null) 
+			fahrzeugeMitSchulden.remove(zuEntfernendesFahrzeug);
+		
+
+		fahrzeugeMitSchulden.add(fahrzeug);
+		System.out.println("Betrag: " + fahrzeug.getBetrag());
+
+		return fahrzeug.IstVerschuldet();
+	}
+
+
+	public boolean gebuerenNehmen(double betrag) {
+
+		return betragAktuellesAuto == betrag;
+	}
+
+	public boolean checkVisakarteNummer(String visakarteNummer) throws Exception {
+		return Zahlung.checkVisaKarte(visakarteNummer);
+	}
+
+	public boolean checkParkplatze() {
+		return maxPlaetze > 0;
+	}
+
+	private Fahrzeug findeFahrzeug(String kennzeichen) throws AutoNichtGefundenException {
+
+		for (Fahrzeug auto : fahrzeuge)
+			if (auto.getKennzeichen().equals(kennzeichen))
+				return auto;
+
+		throw new AutoNichtGefundenException("Ihr Auto wurde nicht gefunden. Bitte wenden Sie sich an den Support");
+
+	}
+
+	private double rabattFuerEauto(double betrag) {
+		return betrag * 0.2;
+	}
+
+	public boolean checkSchulden(String kennzeichen) {
+		for (Fahrzeug sc : fahrzeugeMitSchulden)
+			if (sc.getKennzeichen().equals(kennzeichen))
+				return true;
+
+		return false;
+	}
+
+	private double sendSchulden(String kennzeichen) {
+		for (Fahrzeug sc : fahrzeugeMitSchulden)
+			if (sc.getKennzeichen().equals(kennzeichen)) {
+				return sc.getBetrag();
+			}
+		return 0.0;
+	}
+
+	public int getMaxPlaetze() {
+		return maxPlaetze;
+	}
+
+}

Programmierung2/src/Parkhaus/TextUI.java

@@ -0,0 +1,116 @@
+package Parkhaus;
+
+import java.text.ParseException;
+import java.util.Scanner;
+
+public class TextUI {
+	private Parkhaus system;
+
+	TextUI() throws ParseException, AutoNichtGefundenException, Exception {
+		system = new Parkhaus();
+		startprogramm();
+	}
+
+	private void startprogramm() throws Exception {
+		Scanner eingabe = new Scanner(System.in);
+		boolean aktiv = true;
+
+		System.out.println("<<Willkommen im parkhaus 'kiss and ride'>> ");
+		while (aktiv) {
+			System.out.println();
+			System.out.println("Bitte Wählen Sie ein Option ein: ");
+			System.out.println("1.Einfahren");
+			System.out.println("2.Parkgebühren berechnen lassen");
+			System.out.println("3.Ausfahren");
+			System.out.println("4.Beenden");
+
+			System.out.print("> ");
+			String auswhal = eingabe.nextLine();
+			String kennzeichen;
+			String einfahrtzeit;
+			String ausfahrtzeit;
+			double betrag;
+			String visaKarteNummer;
+
+			switch (auswhal) {
+			case "1": // Einfahren
+				if (!system.checkParkplatze())
+					System.out.println("Es gibt im Parkhaus keine Parkplätze");
+				else {
+					System.out.println("geben Sie bitte das Kennzeichen Ihres Autos ein (optional): ");
+					System.out.print("> ");
+					kennzeichen = eingabe.nextLine();
+					if (system.checkSchulden(kennzeichen))
+						System.err.println("Das Auto mit dem Kennzeichen: " + system.getkennzeichenAktuellesAuto() + " ist im Parkhaus mit Schulden eingefahren!");
+					System.out.println("geben Sie nun bitte die Einfahrtszeit ein (oder lassen Sie das für das System):");
+					System.out.print("> ");
+					einfahrtzeit = eingabe.nextLine();
+					System.out.println(system.einfahren(kennzeichen, einfahrtzeit));
+				}
+				break;
+
+			case "2": // Parkgebühren berechnen lassen
+				System.out.println("Geben Sie erneut das Kennzeichnes Ihres Autos an");
+				System.out.print("> ");
+				kennzeichen = eingabe.nextLine();
+				System.out.println("Geben Sie bitte die Ausfahrtzeit ein (oder lassen Sie das für das System)");
+				System.out.print("> ");
+				ausfahrtzeit = eingabe.nextLine();
+				betrag = system.berechneParkgebuehren(kennzeichen, ausfahrtzeit);
+				System.out.println("Ihr Betrag ist: " + betrag + "€");
+				if (betrag > 0.0) {
+					String zahlungsOptions;
+					System.out.println("Bitte wählen Sie ein Option aus, was Sie mit dem Ihrem Betrag machen möchten: ");
+					System.out.println("1.Sofort bezahlen");
+					System.out.println("2.Betrag als Schulden hinterlassen");
+					System.out.print(">");
+					zahlungsOptions = eingabe.nextLine();
+					switch (zahlungsOptions) {
+					case "1":
+						System.out.println("Geben Sie bitte Ihre 16-stellige Visa-karte Nummer ein: ");
+						System.out.print(">");
+						visaKarteNummer = eingabe.nextLine().trim();
+						// Also wenn die Visakarte korrekt ist, markiert das System das Auto mit dem
+						// Kennzeichen als Bezahlt
+						if (system.checkVisakarteNummer(visaKarteNummer))
+							if (system.gebuerenNehmen(betrag)) {
+								system.setBezahlt(kennzeichen);
+								System.out.println("Ihre Auszahlung war erfolgreich");
+							} else
+								System.out.println("Die eingegebene Visa-Kartennummer ist ungültig.");
+
+						break;
+
+					case "2":
+						// System markiert das Auto als verschuldet und speichert es dann im System
+						system.setVerschuldet(kennzeichen);
+						System.out.println("Der Betrag wurde als Schulden gespeichert");
+						break;
+					default:
+						System.out.println("Das war leider keine gültige Eingabe");
+					}
+
+				}
+				break;
+			case "3": // Ausfahren
+				System.out.println("Um ausfahren zu können, sollen Sie das Kennzeichen Ihres Auto sowie die Ausfahrtzeit eingeben");
+				System.out.print(">");
+				kennzeichen = eingabe.nextLine();
+				System.out.println("Geben Sie nun die Ausfahrtzeit an: ");
+				System.out.print(">");
+				ausfahrtzeit = eingabe.nextLine();
+				if (!system.ausfahren(kennzeichen, ausfahrtzeit))
+					System.err.println("Das Auto mit dem Kennzeichen: " + system.getkennzeichenAktuellesAuto()  +  " fährt ohne Zahlung aus");
+				break;
+			case "4":
+				 System.out.println("Das Programm wird beendet.");
+				aktiv = false;
+				eingabe.close();
+				break;
+			default:
+				System.out.println("Das war leider keine gültige Eingabe");
+
+			}
+		}
+	}
+}

Programmierung2/src/Parkhaus/Zahlung.java

@@ -0,0 +1,43 @@
+package Parkhaus;
+
+public class Zahlung {
+
+	public static boolean checkVisaKarte(String visakarteNummer) throws Exception {
+		if (visakarteNummer.length() != 16)
+			throw new Exception("Die Nummer Ihre Visakart ist falsch");
+
+		char[] arr = visakarteNummer.toCharArray();
+
+		int index = 0;
+		int summe = 0;
+		int faktor = 2;
+		int Differenz = 10;
+		String letzteZiffer = visakarteNummer.substring(visakarteNummer.length() - 1, visakarteNummer.length());
+		int p = Integer.parseInt(letzteZiffer);
+		// Umwandle jede charZiffer alse integer Ziffer
+		// Verdopple jede zweite Ziffer
+		for (int i = arr.length - 2; i >= 0; i--) {
+			arr[i] -= '0';
+
+			if (index == 0) {
+				index++;
+				arr[i] *= faktor;
+				// Wenn ziffer > 9, ziehe 9 einfach ab (Quersumme)
+				if (arr[i] > 9)
+					arr[i] -= 9;
+			}
+
+			else
+				index--;
+
+			summe += arr[i];
+		}
+
+		summe %= 10;
+		summe = Differenz - summe;
+
+		return summe == p;
+
+	}
+
+}

Programmierung2/src/Parkhaus/kennzeichenzufaelliggenerieren.java

@@ -0,0 +1,46 @@
+package Parkhaus;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Random;
+import java.util.Set;
+
+/*kennzeichenzufaelliggenerieren:
+ * 
+ *  - Diese Klasse hat nur die Aufgabe, zufällige Kennzeichen zu generieren
+ *  - immer wenn diese Klasse ein zufälliges Kennzeichen generiert,
+ *  - Hashset verwenden, damit das System nicht für mehrere Autos dasselbe Kennzeichen generiert
+
+ */
+public class kennzeichenzufaelliggenerieren {
+	// Keine Duplikate
+	private static  Set<String> speichereEindutigeNummern = new HashSet<>();
+	private static final String[] ersteZweiZeichen = { "MA", "HD", "KA", "FF", "ROK", "BW", "HH", "B", "D" };
+	private static final String[] zweiteZweizeichen = { "ME", "SH", "DF", "KC", "FT", "GH", "OM", "KL", "CV" };
+	private static String eindutigeZahlen = "";
+	private static Random random = new Random();
+
+	public static String kennzeichengenerieren() {
+		String zufaelligeKennzeichen;
+
+		zufaelligeKennzeichen = ersteZweiZeichen[random.nextInt(ersteZweiZeichen.length)];
+		zufaelligeKennzeichen += "-" + zweiteZweizeichen[random.nextInt(zweiteZweizeichen.length)] + " ";
+
+		do {
+			eindutigeZahlen = "";
+			for (int i = 1; i <= 4; i++)
+				eindutigeZahlen += random.nextInt(10);
+
+		} while (speichereEindutigeNummern.contains(eindutigeZahlen));
+	
+		speichereEindutigeNummern.add(eindutigeZahlen);
+		zufaelligeKennzeichen += eindutigeZahlen;
+
+		if (random.nextBoolean())
+			zufaelligeKennzeichen += "E";
+
+		return zufaelligeKennzeichen;
+
+	}
+
+}

Programmierung2/src/VorlesungsFolien/Verebung/Main.java

@@ -2,15 +2,9 @@ package VorlesungsFolien.Verebung;
 
 public class Main {
 	public static void main(String[] args) {
-		Mitarbeiter mi = new Mitarbeiter("Müller", "27.10.1972");
-		System.out.println(mi.toString());		// nutzt die von Object geerbte Methode
-		System.out.println(mi.getDetails());
 		
-		System.out.println();
+		Mitarbeiter ai = new Manager("Herr Muller" , "01.02.2011");
-		
+		System.out.println(ai.getDetails());
-		Manager ma = new Manager("Stromberg", "01.02.1970");
-		System.out.println(ma.toString());		// wieder die Methode von Object
-		System.out.println(ma.getDetails());
 	}
 }
 
@@ -41,6 +35,7 @@ class Manager extends Mitarbeiter {
 		super(name, 65000, geburtsdatum);	// das MUSS gemacht werden!
 	}
 	
+	@Override
 	public String getDetails() {
 		return super.getDetails() + " " + abteilung;
 	}

Programmierung2/src/oop/Verebung/Mitarbeiter.java

@@ -0,0 +1,52 @@
+package oop.Verebung;
+
+public class Mitarbeiter {
+	
+	private String name;
+	
+	
+	
+	public Mitarbeiter(String name) {
+		super();
+		this.name = name;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public void printName() {
+		System.out.println("Mitarbeiter: " + name);
+	}
+	
+	public static void main(String[] args) {
+		Mitarbeiter m1 = new Manager("obai");
+		m1.printName();
+		Manager m;
+		if (m1 instanceof Manager) {
+			m = (Manager) m1;
+			m1.printName();
+		}
+			
+	}
+}
+
+class Manager extends Mitarbeiter{
+
+	public Manager(String name) {
+		super(name);
+	}
+	
+	@Override
+	public void printName() {	
+		System.out.println("Manager" + super.getName());
+		
+	}
+	
+	
+	
+}