Verbesserungen + Kommentare

KIchatgpt/prompt5.txt

@@ -0,0 +1,120 @@
+ich: die methode berechneGebuehren soll so angepasst werden, somit die folgende Funktion dabei ist: Zwischen 20 und
+6 Uhr kostet das Parken maximal 5 Euro. (Wenn ein Fahrzeug um 19:30 Uhr einfährt, tickt die Uhr 20:30, 21:30, 22:30,
+23:30 und 0:30 Uhr nochmal hoch und dann wieder um 6:30 Uhr.). Das heißt aber nicht, dass ab 20 uhr man direkt 5 euro
+bezahlenm muss, sondern nur wenn die Gebühren höher als 5 euro sind, in dieser Zeit muss man dann maximal 5 euro bezahlen.
+ hier meine methode dafür:
+ public double berechneGebuehren(String kennzeichen, Date ausfahrt) {
+             long parkdauer = berechneParkdauer(kennzeichen, ausfahrt);
+             double gebuehr = 0;
+
+             // Falls die Parkdauer 15 Minuten oder weniger beträgt, ist das Parken kostenlos
+             if (parkdauer <= 15) {
+                 parkdauer = 0;
+                 gebuehr = 0;
+             }
+
+             // Parkdauer nach den 15 Minuten
+             long parkdauerOhneFreiminuten = parkdauer - 15;
+
+             // Tageslimit: Maximal 15 Euro pro Tag
+             if (parkdauerOhneFreiminuten == 1440) {
+                 gebuehr = 1500;
+                 parkdauerOhneFreiminuten = 0;
+             }
+
+             // 1 Euro pro angefangene Stunde
+             if (parkdauerOhneFreiminuten > 0 && parkdauerOhneFreiminuten < 1440) {
+                 while (parkdauerOhneFreiminuten > 0) {
+                     gebuehr += 100;
+                     parkdauerOhneFreiminuten -= 60;
+                 }
+             }
+
+             // Prüfe, ob es sich um ein E-Auto handelt (Kennzeichen endet mit "E")
+             if (kennzeichen.endsWith("E")) {
+                 gebuehr *= 0.8; // 20% Rabatt für E-Autos
+             }
+             return gebuehr;
+         }
+
+ KI: Um die Gebührenberechnung korrekt an die Regel "Zwischen 20 und 6 Uhr kostet das Parken maximal 5 Euro" anzupassen,
+  müssen wir zusätzlich die Parkzeiten in diesem Zeitfenster explizit überprüfen. Das bedeutet, dass in der Zeit von
+   20:00 Uhr bis 6:00 Uhr die Gebühren, wenn sie höher als 5 Euro wären, auf 5 Euro begrenzt werden.
+
+     Hier ist die angepasste Version deiner Methode, die diese Funktion berücksichtigt:
+
+     import java.text.SimpleDateFormat;
+     import java.util.Calendar;
+     import java.util.Date;
+
+     public double berechneGebuehren(String kennzeichen, Date ausfahrt) {
+         long parkdauer = berechneParkdauer(kennzeichen, ausfahrt);
+         double gebuehr = 0;
+
+         // Falls die Parkdauer 15 Minuten oder weniger beträgt, ist das Parken kostenlos
+         if (parkdauer <= 15) {
+             return 0; // Kostenlos
+         }
+
+         // Parkdauer nach den 15 Minuten
+         long parkdauerOhneFreiminuten = parkdauer - 15;
+
+         // Tageslimit: Maximal 15 Euro pro Tag
+         if (parkdauerOhneFreiminuten >= 1440) {  // 1440 Minuten = 24 Stunden
+             gebuehr = 1500;
+             return gebuehr;  // Direkt zurück, da Tageslimit erreicht
+         }
+
+         // 1 Euro pro angefangene Stunde
+         if (parkdauerOhneFreiminuten > 0) {
+             while (parkdauerOhneFreiminuten > 0) {
+                 gebuehr += 100;  // 1 Euro pro Stunde
+                 parkdauerOhneFreiminuten -= 60;
+             }
+         }
+
+         // Maximale Gebühren in der Nacht von 20 Uhr bis 6 Uhr
+         gebuehr = berechneNachttarif(kennzeichen, gebuehr, ausfahrt);
+
+         // Prüfe, ob es sich um ein E-Auto handelt (Kennzeichen endet mit "E")
+         if (kennzeichen.endsWith("E")) {
+             gebuehr *= 0.8;  // 20% Rabatt für E-Autos
+         }
+
+         return gebuehr;
+     }
+
+     private double berechneNachttarif(String kennzeichen, double gebuehr, Date ausfahrt) {
+         Calendar cal = Calendar.getInstance();
+         cal.setTime(ausfahrt);
+
+         // Bestimme die Einfahrtszeit des Fahrzeugs
+         Date einfahrt = findeEinfahrtZeit(kennzeichen);  // Methode zum Finden der Einfahrtszeit
+         Calendar einfahrtsCal = Calendar.getInstance();
+         einfahrtsCal.setTime(einfahrt);
+
+         // Prüfe, ob sich ein Teil der Parkdauer im Zeitraum von 20:00 bis 6:00 Uhr befindet
+         while (einfahrtsCal.before(cal)) {
+             int stunde = einfahrtsCal.get(Calendar.HOUR_OF_DAY);
+             if (stunde >= 20 || stunde < 6) {
+                 // Die Gebühren für jede angefangene Stunde in diesem Zeitraum dürfen maximal 5 Euro sein
+                 if (gebuehr > 500) {
+                     gebuehr = 500;  // Maximal 5 Euro während der Nachtzeit
+                 }
+             }
+
+             // Erhöhe die Zeit um eine Stunde, um jede Stunde zu prüfen
+             einfahrtsCal.add(Calendar.HOUR_OF_DAY, 1);
+         }
+
+         return gebuehr;
+     }
+
+     private Date findeEinfahrtZeit(String kennzeichen) {
+         for (PKW pkw : parkendePkws) {
+             if (pkw.getKennzeichen().equals(kennzeichen)) {
+                 return pkw.getEinfahrt();
+             }
+         }
+         return new Date();  // Falls kein PKW gefunden wurde, aktuelles Datum als Fallback
+     }

QualifierTeil2/Main.java

@@ -46,6 +46,7 @@ public class Main {
 
                 case 5:
                     System.out.println("Programm beendet.");
+                    scanner.close();
                     return;
 
                 default:

QualifierTeil2/PKW.java

@@ -6,10 +6,13 @@ import java.util.Random;
 
 public class PKW {
     private String kennzeichen;
+    private Date einfahrt;
     double gebuehrenkonto;
 
-    public PKW() {
-        this.kennzeichen = "HD-MA 1967";
+
+    public PKW(String kennzeichen) {
+        this.kennzeichen = kennzeichen;
+        this.einfahrt = new Date();
         this.gebuehrenkonto = 0.0;
     }
 
@@ -18,6 +21,9 @@ public class PKW {
     }
 
 
+    public Date getEinfahrt() {
+        return einfahrt;
+    }
 
     public double getGebuehrenkonto() {
         return gebuehrenkonto;
@@ -27,34 +33,6 @@ public class PKW {
         this.gebuehrenkonto += gebuehrenkonto;
     }
 
-
-    public String generiereKennzeichen() {
-        Random random = new Random();
-
-        // 2 bis 3 Buchstaben für Stadt/Region
-        String stadtRegion = randomString(random, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", random.nextInt(2) + 2);
-
-        // 1 bis 2 Buchstaben für Fahrzeugklasse
-        String fahrzeugKlasse = randomString(random, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", random.nextInt(2) + 1);
-
-        // 1 bis 4 Ziffern für die Nummer
-        String nummer = randomString(random, "0123456789", random.nextInt(4) + 1);
-
-        // Optional ein "E" für Elektrofahrzeuge
-        String elektro = random.nextBoolean() ? "E" : "";
-
-        // Zusammenfügen des Kennzeichens
-        return stadtRegion + "-" + fahrzeugKlasse + " " + nummer + elektro;
-    }
-
-    // Hilfsmethode zur Erzeugung einer zufälligen Zeichenkette
-    private static String randomString(Random random, String zeichen, int laenge) {
-        StringBuilder sb = new StringBuilder(laenge);
-        for (int i = 0; i < laenge; i++) {
-            sb.append(zeichen.charAt(random.nextInt(zeichen.length())));
-        }
-        return sb.toString();
-    }
 }
 
 

QualifierTeil2/Parkhaus.java

@@ -1,87 +1,56 @@
 package QualifierTeil2;
 
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
 import java.util.*;
 
 public class Parkhaus {
     private List<PKW> parkendePkws;
-    int kapazitaet;
+    int kapazitaetVerfuegbar;
     int belegt;
+    int maxKapazitaet;
 
     public Parkhaus() {
         this.parkendePkws = new ArrayList<>();
-        this.kapazitaet = randomAnzahlParkplätze();
+        this.maxKapazitaet = randomAnzahlParkplätze();
+        this.kapazitaetVerfuegbar = maxKapazitaet;
         this.belegt = 0;
     }
 
-    public List<PKW> getParkendePkws() {
-        return parkendePkws;
-    }
-
-    public static int randomAnzahlParkplätze() {
-        return (int) (Math.random() * 200) + 1;
-    }
 
     // Methode zum Einfahren eines PKWs
     public void einfahren(String kennzeichen) {
         PKW existierenderPKW = null;
 
-        // Überprüfen, ob das Auto mit demselben Kennzeichen bereits existiert (Schulden hat)
+        // Überprüfen, ob das Auto mit demselben Kennzeichen bereits existiert
         for (PKW pkw : parkendePkws) {
             if (pkw.getKennzeichen().equals(kennzeichen)) {
                 existierenderPKW = pkw;
                 break;
             }
         }
+
+        // Falls angegebenen PKW sich schon im Parkhaus befindet oder schonmal da war und Schulden hat
         if (existierenderPKW != null) {
-            System.out.println("Der PKW mit dem Kennzeichen " + kennzeichen + " hat noch Schulden von " + existierenderPKW.getGebuehrenkonto() + " Cent.");
-            this.kapazitaet--;
-            this.belegt++;
+            System.out.println("Der PKW mit dem Kennzeichen " + kennzeichen + " hat noch Schulden in Höhe von " + existierenderPKW.getGebuehrenkonto() + " Cent.");
         } else {
             // Neuen PKW erstellen und Schulden übernehmen, falls vorhanden
-            PKW neuerPKW = new PKW();
+            PKW neuerPKW = new PKW(kennzeichen);
             double schulden = sucheSchulden(kennzeichen);  // Funktion, die die alten Schulden findet (falls vorhanden)
             neuerPKW.setGebuehrenkonto(schulden);  // Vorherige Schulden hinzufügen
             parkendePkws.add(neuerPKW);
-            this.kapazitaet--;
+            this.kapazitaetVerfuegbar--;
             this.belegt++;
-            System.out.println("Neuer PKW mit Kennzeichen " + kennzeichen + " eingefahren. Schulden: " + schulden + " Euro.");
+            System.out.println("Neuer PKW mit Kennzeichen " + kennzeichen + " eingefahren. Schulden: " + schulden + " Cent.");
         }
 
 
-        /*if (parkendePkws.size() < kapazitaet) {
-            parkendePkws.add(pkw);
-            this.kapazitaet--;
-            this.belegt++;
-            System.out.println("PKW mit Kennzeichen " + pkw.getKennzeichen() + " ist eingefahren.");
-        } else {
-            System.out.println("Parkhaus voll.");
-        }*/
-
-    }
-
-    public double sucheSchulden(String kennzeichen) {
-        // Durchsuche die Liste oder Datenbank nach alten Schulden
-        // Beispiel: Wenn der PKW schon einmal ausgefahren ist, seine Schulden zurückgeben
-        for (PKW pkw : parkendePkws) {
-            if (pkw.getKennzeichen().equals(kennzeichen)) {
-                return pkw.getGebuehrenkonto();  // Alte Schulden finden
-            }
-        }
-        return 0.0;  // Keine Schulden gefunden
-    }
-
-
-    // Methode zum Prüfen, ob das Parkhaus voll ist
-    public boolean istVoll() {
-        return parkendePkws.size() >= kapazitaet;
     }
 
 
     // Methode zum Ausfahren eines PKWs anhand des Kennzeichens
     public void ausfahren(String kennzeichen) {
-        PKW zuEntfernen = null;
+        PKW zuEntfernen = null; //PKW, der rausfahren will
+
+        // Überprüfen, ob das Auto mit demselben Kennzeichen bereits existiert und setze das als zuEntfernen
         for (PKW pkw : parkendePkws) {
             if (pkw.getKennzeichen().equals(kennzeichen)) {
                 zuEntfernen = pkw;
@@ -89,6 +58,7 @@ public class Parkhaus {
             }
         }
 
+        // Falls Auto zum Entfernen gibt
         if (zuEntfernen != null) {
             // Berechnung der Gebühren
             double gebuehren = berechneGebuehren(kennzeichen, new Date());  // Nimmt die aktuelle Zeit an
@@ -96,9 +66,10 @@ public class Parkhaus {
             // Gebührenkonto aktualisieren
             zuEntfernen.setGebuehrenkonto(gebuehren); // Schulden für unbezahlte Gebühren hinzufügen
 
+            // Falls Gebühren vorhanden sind
             if (gebuehren > 0) {
 
-                Date ausfahrt = new Date();
+                Date ausfahrt = new Date(); //aktuelle Zeit für Ausfahrt
                 System.out.println("Parkdauer in Minuten: " + berechneParkdauer(kennzeichen, ausfahrt));
                 System.out.println("Parkgebühren in Cent: " + zuEntfernen.getGebuehrenkonto());
 
@@ -110,20 +81,24 @@ public class Parkhaus {
                 if (pruefeKreditkarte(kreditkartenNummer)) {
                     System.out.println("Zahlung erfolgreich. Sie dürfen ausfahren.");
                     zuEntfernen.setGebuehrenkonto(0);  // Gebühren auf 0 setzen
-                    System.out.println("Gebührenkonto: " + zuEntfernen.getGebuehrenkonto());
+                    System.out.println("Bezahlte Summe: " + zuEntfernen.getGebuehrenkonto());
+                    // PKW aus der Liste entfernen
+                    parkendePkws.remove(zuEntfernen);  // Hier wird der PKW endgültig entfernt
                     System.out.println("PKW mit Kennzeichen " + kennzeichen + " hat die Gebühren bezahlt und darf rausfahren.\n");
                 } else {
                     System.out.println("Ungültige Kreditkartennummer. Zahlung fehlgeschlagen.");
-                    System.out.println("Gebührenkonto: " + zuEntfernen.getGebuehrenkonto());
+                    System.out.println("Offenes Gebührenkonto: " + zuEntfernen.getGebuehrenkonto());
                 }
             } else {
                 // Gebührenfrei (unter 15 Minuten oder andere Ausnahme)
-                System.out.println("PKW mit Kennzeichen " + kennzeichen + " darf gebührenfrei ausfahren.\n");
+                Date ausfahrt = new Date();
+                System.out.println("Parkdauer in Minuten: " + berechneParkdauer(kennzeichen, ausfahrt));
+                System.out.println("Parkgebühren in Cent: " + zuEntfernen.getGebuehrenkonto());
+                System.out.println("PKW mit Kennzeichen " + kennzeichen + " darf gebührenfrei ausfahren.");
             }
 
-            // PKW aus der Liste entfernen und Kapazität aktualisieren
-            //parkendePkws.remove(zuEntfernen);
-            this.kapazitaet++;
+            // PKW aus der Liste nicht entfernen und Kapazität aktualisieren
+            this.kapazitaetVerfuegbar++;
             this.belegt--;
             System.out.println("PKW mit Kennzeichen " + kennzeichen + " hat die Ausfahrt durchgeführt.\n");
 
@@ -134,33 +109,31 @@ public class Parkhaus {
 
 
     public long berechneParkdauer(String kennzeichen, Date ausfahrt) {
-        //long minDiff = 0;
+        long minDiff = 0;
 
-        /*for (PKW pkw : parkendePkws) {
-            if (pkw.getKennzeichen().equals(kennzeichen) && !pkw.hatBezahlt()) {
-                minDiff = (ausfahrt.getTime() - pkw.einfahrt.getTime()) / 60000;
+        // Berechnung der parkdauer des PKWs anhand des Kennzeichens
+        for (PKW pkw : parkendePkws) {
+            if (pkw.getKennzeichen().equals(kennzeichen)) {
+                minDiff = (ausfahrt.getTime() - pkw.getEinfahrt().getTime()) / 60000;
             }
         }
-        return minDiff;*/
+        return minDiff;
 
         //Debugging mit selbst ausgewählten Zeiten
-        var sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
 
-        Date d1 = null;
+        /*SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+        Date einfahrtszeit = null;
         try {
-            d1 = sdf.parse("01.10.2024, 10:00");
+            // Beispiel für manuelle Eingabe, kann angepasst werden
+            einfahrtszeit = sdf.parse("01.10.2024, 20:00");
+            ausfahrt = sdf.parse("02.10.2024, 02:00");
         } catch (ParseException e) {
             throw new RuntimeException(e);
         }
-        Date d2 = null;
-        try {
-            d2 = sdf.parse("01.10.2024, 11:00");
-        } catch (ParseException e) {
-            throw new RuntimeException(e);
-        }
-        long minDiff = (d2.getTime() - d1.getTime()) / 60000;
 
-        return minDiff;
+        minDiff = (ausfahrt.getTime() - einfahrtszeit.getTime()) / 60000;
+
+        return minDiff;*/
     }
 
     public double berechneGebuehren(String kennzeichen, Date ausfahrt) {
@@ -180,7 +153,6 @@ public class Parkhaus {
         if (parkdauerOhneFreiminuten == 1440) {
             gebuehr = 1500;
             parkdauerOhneFreiminuten = 0;
-
         }
 
         // 1 Euro pro angefangene Stunde
@@ -191,6 +163,9 @@ public class Parkhaus {
             }
         }
 
+        // Maximale Gebühren in der Nacht von 20 Uhr bis 6 Uhr
+        gebuehr = berechneNachttarif(kennzeichen, gebuehr, ausfahrt);
+
         // Prüfe, ob es sich um ein E-Auto handelt (Kennzeichen endet mit "E")
         if (kennzeichen.endsWith("E")) {
             gebuehr *= 0.8; // 20% Rabatt für E-Autos
@@ -203,6 +178,8 @@ public class Parkhaus {
         if (kreditkartenNummer.length() != 16 || !kreditkartenNummer.startsWith("4")) {
             return false;  // Ungültige Karte
         }
+
+        //Luhn-Algorithmus
         int sum = 0;
         boolean alternate = false;
         for (int i = kreditkartenNummer.length() - 1; i >= 0; i--) {
@@ -218,6 +195,109 @@ public class Parkhaus {
         }
         return (sum % 10 == 0);
     }
+
+    //-------------------------------Hilfsmethoden-------------------------------------------
+
+    // Methode zum Generieren einer zufälligen Zahl für die Anzahl der Parkplätze
+    private static int randomAnzahlParkplätze() {
+        return (int) (Math.random() * 200) + 1;
+    }
+
+    // Methode zum Durchsuchen der Liste nach alten Schulden
+    private double sucheSchulden(String kennzeichen) {
+
+        // Beispiel: Wenn der PKW schon einmal ausgefahren ist, seine Schulden zurückgeben
+        for (PKW pkw : parkendePkws) {
+            if (pkw.getKennzeichen().equals(kennzeichen)) {
+                return pkw.getGebuehrenkonto();  // Alte Schulden finden
+            }
+        }
+        return 0.0;  // Keine Schulden gefunden
+    }
+
+
+    // Methode zum Prüfen, ob das Parkhaus voll ist
+    public boolean istVoll() {
+        return parkendePkws.size() >= this.maxKapazitaet;
+    }
+
+    // Methode zur Berechnung der Sonderregel für in der Nacht von 20 Uhr bis 6 Uhr
+    private double berechneNachttarif(String kennzeichen, double gebuehr, Date ausfahrt) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(ausfahrt);
+
+        //Debugging
+        /*SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
+        Date einfahrtszeit = null;
+        try {
+            // Beispiel für manuelle Eingabe, kann angepasst werden
+            einfahrtszeit = sdf.parse("01.10.2024, 20:00");
+            ausfahrt = sdf.parse("02.10.2024, 02:00");
+        } catch (ParseException e) {
+            throw new RuntimeException(e);
+        }*/
+
+        // Bestimme die Einfahrtszeit des Fahrzeugs
+        Date einfahrt = findeEinfahrtZeit(kennzeichen); // =einfahrt für Debugging // Methode zum Finden der Einfahrtszeit
+        Calendar einfahrtsCal = Calendar.getInstance();
+        einfahrtsCal.setTime(einfahrt);
+
+        // Prüfe, ob sich ein Teil der Parkdauer im Zeitraum von 20:00 bis 6:00 Uhr befindet
+        while (einfahrtsCal.before(cal)) {
+            int stunde = einfahrtsCal.get(Calendar.HOUR_OF_DAY);
+            if (stunde >= 20 || stunde < 6) {
+                // Die Gebühren für jede angefangene Stunde in diesem Zeitraum dürfen maximal 5 Euro sein
+                if (gebuehr > 500) {
+                    gebuehr = 500;  // Maximal 5 Euro während der Nachtzeit
+                }
+            }
+
+            // Erhöhe die Zeit um eine Stunde, um jede Stunde zu prüfen
+            einfahrtsCal.add(Calendar.HOUR_OF_DAY, 1);
+        }
+        return gebuehr;
+    }
+
+    // Methode zum Finden der Einfahrtszeit des PKWs nach Kennzeichen
+    private Date findeEinfahrtZeit(String kennzeichen) {
+        for (PKW pkw : parkendePkws) {
+            if (pkw.getKennzeichen().equals(kennzeichen)) {
+                return pkw.getEinfahrt();
+            }
+        }
+        return new Date();  // Falls kein PKW gefunden wurde, aktuelles Datum als Fallback
+    }
+
+
+    // Methode zum Generieren eines zufälligen Kennzeichens
+    public String generiereKennzeichen() {
+        Random random = new Random();
+
+        // 2 bis 3 Buchstaben für Stadt/Region
+        String stadtRegion = randomString(random, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", random.nextInt(2) + 2);
+
+        // 1 bis 2 Buchstaben für Fahrzeugklasse
+        String fahrzeugKlasse = randomString(random, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", random.nextInt(2) + 1);
+
+        // 1 bis 4 Ziffern für die Nummer
+        String nummer = randomString(random, "0123456789", random.nextInt(4) + 1);
+
+        // Optional ein "E" für Elektrofahrzeuge
+        String elektro = random.nextBoolean() ? "E" : "";
+
+        // Zusammenfügen des Kennzeichens
+        return stadtRegion + "-" + fahrzeugKlasse + " " + nummer + elektro;
+    }
+
+
+    // Hilfsmethode zur Erzeugung einer zufälligen Zeichenkette
+    private static String randomString(Random random, String zeichen, int laenge) {
+        StringBuilder sb = new StringBuilder(laenge);
+        for (int i = 0; i < laenge; i++) {
+            sb.append(zeichen.charAt(random.nextInt(zeichen.length())));
+        }
+        return sb.toString();
+    }
 }
 
 

QualifierTeil2/UI.java

@@ -12,11 +12,28 @@ public class UI {
     // Methode für die Einfahrt eines PKWs
     public void einfahrtPKW() {
 
-        System.out.println("Bitte geben Sie das Kennzeichen ein:");
+        // Überprüfen, ob das Parkhaus voll ist
+        if (parkhaus1.istVoll()) {
+            System.out.println("Das Parkhaus ist voll. Keine weiteren Einfahrten möglich.");
+            return;  // Methode beenden, wenn keine Parkplätze mehr verfügbar sind
+        }
+
+        // Eingabe von Kennzeichen; wenn leer, Kennzeichen wird automatisch generiert
+        System.out.println("Bitte geben Sie das Kennzeichen ein (leer lassen, um ein Kennzeichen zu generieren):");
         String kennzeichen = scan.nextLine();
-        System.out.println("Aktuell verfügbare Parkplätze: " + parkhaus1.kapazitaet);
+        if (kennzeichen.isEmpty()) {
+            kennzeichen = parkhaus1.generiereKennzeichen();
+            System.out.println("Generiertes Kennzeichen: " + kennzeichen);
+        }
+
+        System.out.println("Aktuell verfügbare Parkplätze: " + parkhaus1.kapazitaetVerfuegbar);
+
+        // Methodenaufruf vom Parkhaus für die Einfahrt
         parkhaus1.einfahren(kennzeichen);
-        System.out.println("weitere verfügbare Parkplätze: " + parkhaus1.kapazitaet);
+
+        System.out.println("weitere verfügbare Parkplätze: " + parkhaus1.kapazitaetVerfuegbar);
+
+        // Ausgabe aktuelle Zeit als Einfahrtszeit
         var einfahrt = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
         System.out.println("Einfahrt: " + einfahrt.format(new Date()));
 
@@ -27,36 +44,38 @@ public class UI {
 
     // Methode für die Einfahrt von mehreren PKWs
     public void mehrereEinfahrten() {
-
         while (true) {
             if (parkhaus1.istVoll()) {
                 System.out.println("Das Parkhaus ist voll. Keine weiteren Einfahrten möglich.");
                 break;
             }
 
+            // PKW einfahren
+            einfahrtPKW();
+
+            // Frage, ob der Benutzer weitere PKWs einfahren lassen möchte
             System.out.println("Möchten Sie einen weiteren PKW einfahren lassen? (j/n)");
             String weiter = scan.nextLine();
+
+            // Wenn der Benutzer "n" eingibt, wird die Schleife beendet
             if (!weiter.equalsIgnoreCase("j")) {
                 break;
             }
-
-            // PKW einfahren
-            einfahrtPKW();
         }
     }
 
     // Methode zum Anzeigen der verfügbaren Plätze
     public void zeigeVerfügbarePlätze() {
-        System.out.println("Verfügbare Plätze: " + parkhaus1.kapazitaet);
+        System.out.println("Verfügbare Plätze: " + parkhaus1.kapazitaetVerfuegbar);
         System.out.println(" ");
     }
 
     // Methode für die Ausfahrt und Bezahlung
     public void ausfahrtPKW() {
-
         System.out.println("Geben Sie das Kennzeichen des ausfahrenden PKWs ein: ");
         String kennzeichen = scan.nextLine().toUpperCase();
 
+        //Methodenaufruf vom Parkhaus für die Ausfahrt
         parkhaus1.ausfahren(kennzeichen);
 
 

QualifierTeil2/visanummer.txt

@@ -0,0 +1,2 @@
+Gültige VISA-Nummer:
+4539148803436467