Methoden

PR2GIT/src/Parkhaus3.java

@@ -1,12 +1,13 @@
-
+ 
  import java.text.ParseException;
 import java.text.SimpleDateFormat;
+import java.util.Calendar;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Random;
 import java.util.Scanner;
 
-public class ParkhausSystem {
+public class Parkhaus3 {
     private String[] kennzeichenArray; // Array zur Speicherung der Kennzeichen
     private Date[] parkzeitArray; // Array zur Speicherung der Parkzeiten
     private int maxPlatz = 180; // Maximale Anzahl der Parkplätze
@@ -17,11 +18,11 @@ public class ParkhausSystem {
     SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm"); //Z.101
  
     public static void main(String[] args) {
-        ParkhausSystem parkhausSystem = new ParkhausSystem(); // objekt erstellung
+        Parkhaus3 parkhausSystem = new Parkhaus3(); // objekt erstellung
         parkhausSystem.showMenu();
     }
 
-    public ParkhausSystem() {
+    public Parkhaus3() {
         kennzeichenArray = new String[maxPlatz]; //  Array für Kennzeichen
         parkzeitArray = new Date[maxPlatz]; // Array für Parkzeiten
         schuldenMap = new HashMap<>(); // die Map für Schulden
@@ -123,19 +124,25 @@ public class ParkhausSystem {
 
         // Suche das Kennzeichen im Array
         for (int i = 0; i < aktuellerPlatz; i++) {
-            if (kennzeichenArray[i] != null && kennzeichenArray[i].equals(kennzeichen)) {
+            if (kennzeichenArray[i] != null && kennzeichenArray[i].equals(kennzeichen)) {//Es wird geprüft, ob das aktuelle Element im kennzeichenArray nicht null ist (d.h. ob der Parkplatz tatsächlich belegt ist) und ob es mit dem übergebenen kennzeichen übereinstimmt.
-                // Berechnung der Parkdauer
+               
+            	
+            	// Berechnung der Parkdauer
                 Date parkzeit = parkzeitArray[i];
-                Date ausfahrtszeit = new Date(); // Aktuelle Zeit
+                Date ausfahrtszeit = new Date(); // Aktuelle Zeit wird mit dem Konstruktor new Date() gesetzt
-                long secDiff = (ausfahrtszeit.getTime() - parkzeit.getTime()) / 1000; // Zeitdifferenz in Sekunden
+                long secDiff = (ausfahrtszeit.getTime() - parkzeit.getTime()) / 1000; // Zeitdifferenz in Millisek daher / 1000 
-                long stunden = secDiff / 3600;
+                long stunden = secDiff / 3600; // umrechnung in sek. und speichern in die Variable stunden
                 System.out.println("Fahrzeug mit Kennzeichen " + kennzeichen + " hat das Parkhaus verlassen.");
                 System.out.println("Parkdauer: " + stunden + " Stunden.");
 
-                double gebuehren = berechneGebuehren(parkzeit, ausfahrtszeit);
+                // Prüfen, ob das Fahrzeug ein E-Auto ist
+                boolean istEAuto = kennzeichen.endsWith("E");
+                
+                // Parkgebühren berechnen
+                double gebuehren = berechneGebuehren(parkzeit, ausfahrtszeit, istEAuto); 
                 System.out.println("Die Parkgebühren betragen: " + gebuehren + " Euro.");
 
-                // Prüfen, ob die Zahlung erfolgt ist
+                // Prüfen auf Zahlung und Schuldenverwaltung
                 if (!schuldenMap.containsKey(kennzeichen)) {
                     System.out.println("Das Fahrzeug hat nicht bezahlt. Schulden werden gespeichert.");
                     schuldenMap.put(kennzeichen, gebuehren);
@@ -159,29 +166,25 @@ public class ParkhausSystem {
 
         // Suche das Kennzeichen im Array
         for (int i = 0; i < aktuellerPlatz; i++) {
-            if (kennzeichenArray[i] != null && kennzeichenArray[i].equals(kennzeichen)) {
+            if (kennzeichenArray[i] != null && kennzeichenArray[i].equals(kennzeichen)) { // suchen des kennzeichens, wenn nicht null Parkplatz ist belegt
                 // Berechne die Gebühren
-                Date parkzeit = parkzeitArray[i];
+                Date parkzeit = parkzeitArray[i];//Die Parkzeit des Fahrzeugs wird aus dem parkzeitArray abgerufen
-                Date ausfahrtszeit = new Date(); // Aktuelle Zeit als Ausfahrtszeit
+                Date ausfahrtszeit = new Date(); // Eine neue Date-Instanz wird erstellt, um die aktuelle Zeit als Ausfahrtszeit zu speichern
-                double gebuehren = berechneGebuehren(parkzeit, ausfahrtszeit);
+                boolean istEAuto = kennzeichen.endsWith("E");
+                double gebuehren = berechneGebuehren(parkzeit, ausfahrtszeit, istEAuto); 
 
                 // Hinzufügen der vorherigen Schulden zur neuen Gebühr, falls vorhanden
                 if (schuldenMap.containsKey(kennzeichen)) {
                     double offeneSchulden = schuldenMap.get(kennzeichen);
                     System.out.println("Offene Schulden von " + offeneSchulden + " Euro werden zur Gebühr hinzugefügt.");
-                    gebuehren += offeneSchulden;
+                    gebuehren += offeneSchulden; // offene Schulden werden zu den berechneten Gebühren aufaddiert
                     schuldenMap.remove(kennzeichen); // Schulden löschen, da sie bezahlt werden
                 }
 
-                System.out.printf("Das Fahrzeug mit Kennzeichen %s hat %,.2f Euro zu zahlen.%n", kennzeichen, gebuehren);
+                System.out.printf("Das Fahrzeug mit Kennzeichen %s hat %,.2f Euro zu zahlen.%n", kennzeichen, gebuehren); // %,.2 sorgt das Betrag als Fließkommazahl mit zwei Dezimalstellen angezeigt wird
-
+                                                                                                                          //%n Platzhalter
-                // Abfrage, ob es sich um ein E-Auto handelt
+                // Rabatt für E-Auto anwenden, falls das Kennzeichen mit "E" endet
-                System.out.print("Ist das Fahrzeug ein E-Auto? (ja/nein): ");
+                if (istEAuto) {
-                String istEAuto = scanner.nextLine().trim().toLowerCase();
-                boolean eAuto = istEAuto.equals("ja");
-
-                // Rabatt für E-Auto anwenden
-                if (eAuto) {
                     gebuehren *= 0.8; // 20 % Rabatt
                     System.out.printf("20%% Rabatt für E-Autos angewendet. Neue Gebühr: %,.2f Euro.%n", gebuehren);
                 }
@@ -200,24 +203,101 @@ public class ParkhausSystem {
     }
 
     public boolean kreditkartenZahlung(double betrag) {
-        // Hier kann die Implementierung der Kreditkarten-Zahlung erfolgen
+        System.out.printf("Bitte bezahlen Sie %,.2f Euro mit Ihrer 16-stelligen VISA-Kreditkarte.%n", betrag);
-        System.out.printf("Bitte bezahlen Sie %,.2f Euro mit Ihrer Kreditkarte.%n", betrag);
+        System.out.print("Geben Sie die Kreditkartennummer ein: ");
-        return true; // Simuliere eine erfolgreiche Zahlung
+        String kreditkartenNummer = scanner.nextLine().trim();
+
+        if (validitaetKreditkartennummer(kreditkartenNummer)) {
+            System.out.println("Kreditkarte gültig.");
+            return true;
+        } else {
+            System.out.println("Ungültige Kreditkartennummer.");
+            return false;
+        }
     }
 
-    public double berechneGebuehren(Date parkzeit, Date ausfahrtszeit) {
+    private boolean validitaetKreditkartennummer(String eingabe) {
-        long diffInHours = (ausfahrtszeit.getTime() - parkzeit.getTime()) / (1000 * 60 * 60);
+        if (eingabe.length() != 16 || !eingabe.matches("\\d{16}")) {
-        double gebuehren = diffInHours * 2.0; // Beispiel: 2 Euro pro Stunde
+            return false; // Gültigkeit nur für 16-stellige VISA-Nummern
+        }
+
+        int[] kreditkarteInt = new int[eingabe.length()];
+        for (int i = 0; i < eingabe.length(); i++) {
+            kreditkarteInt[i] = Integer.parseInt(eingabe.substring(i, i + 1));
+        }
+
+        for (int i = kreditkarteInt.length - 2; i >= 0; i -= 2) {
+            int wert = kreditkarteInt[i] * 2;
+            if (wert > 9) {
+                wert = wert % 10 + 1;
+            }
+            kreditkarteInt[i] = wert;
+        }
+
+        int total = 0;
+        for (int i : kreditkarteInt) {
+            total += i;
+        }
+
+        return total % 10 == 0;
+    }
+ 
+    public double berechneGebuehren(Date parkzeit, Date ausfahrtszeit, boolean istEAuto) {
+        long diffInMillis = ausfahrtszeit.getTime() - parkzeit.getTime();
+        long diffInMinutes = diffInMillis / (1000 * 60);
+
+        // Ersten 15 Minuten kostenlos
+        if (diffInMinutes <= 15) {
+            return 0.0;
+        }
+
+        // Ziehe die 15 kostenlosen Minuten von der Parkdauer ab
+        diffInMinutes -= 15;
+
+        double gebuehren = 0.0;
+
+        // Initialisiere Kalenderobjekte für die Parkzeit
+        Calendar calEin = Calendar.getInstance();
+        calEin.setTime(parkzeit);
+
+        // Berechne die Gebühren für die Parkzeit
+        while (diffInMinutes > 0) {
+            int stunde = calEin.get(Calendar.HOUR_OF_DAY);
+
+            // Wenn die Stunde zwischen 20 und 6 liegt, max. 5 Euro pro Stunde
+            if (stunde >= 20 || stunde < 6) {
+                gebuehren += 5.0; // Maximale Gebühr
+                diffInMinutes -= 60; // Eine Stunde abziehen
+            } else {
+                gebuehren += 1.0; // 1 Euro pro angefangener Stunde
+                diffInMinutes -= 60; // Eine Stunde abziehen
+            }
+
+            // Gehe zur nächsten vollen Stunde
+            calEin.add(Calendar.HOUR_OF_DAY, 1);
+        }
+
+        // Maximal 15 Euro pro Tag
+        long tage = (ausfahrtszeit.getTime() - parkzeit.getTime()) / (1000 * 60 * 60 * 24);
+        gebuehren = Math.min(gebuehren, 15 * (tage + 1)); // Deckelung auf 15 Euro pro Tag
+
+        // 20% Rabatt für E-Autos
+        if (istEAuto) {
+            gebuehren *= 0.8;
+        }
+
         return gebuehren;
     }
 
+
     // Einfache Methode zur Generierung eines zufälligen Kennzeichens
     public String generiereKennzeichen() {
-        String[] buchstaben = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"};
+        String[] buchstaben = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"}; //Array
-        Random rand = new Random();
+        Random rand = new Random(); //Mithilfe eines Random-Objekts werden  zufällige Buchstaben aus diesem Array ausgewählt.
-        String kennzeichen = buchstaben[rand.nextInt(buchstaben.length)] +
+        
+        String kennzeichen = buchstaben[rand.nextInt(buchstaben.length)] +     //rand.nextInt(buchstaben.length)= zufällige Buchstaben aus dem Array auswählen
                 buchstaben[rand.nextInt(buchstaben.length)] +
-                buchstaben[rand.nextInt(buchstaben.length)] + "-" +
+                buchstaben[rand.nextInt(buchstaben.length)] + "-" +    // Bindestrich hinzufügen
                 (rand.nextInt(900) + 100); // Zahl zwischen 100 und 999
         return kennzeichen;
     }
@@ -226,4 +306,5 @@ public class ParkhausSystem {
     public boolean istKennzeichenGueltig(String kennzeichen) {
         return kennzeichen.matches( "[A-Z]{2,3}-[A-Z]{2,3} \\d{3,4}(E)?");
     }
-}
+}                           // A-Z 2 als auch 3 Buchstaben in den beiden Segmenten vor dem BindeStrich
+                           //    \\d steht für eine Ziffer von 0 -9   , {3,4} bedeutet, dass diese Ziffer mindestens 3 und maximal 4 Mal wiederholt werden darf

Qualifier/src/ParkhausSystem2.java

@@ -0,0 +1,310 @@
+
+  import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Random;
+import java.util.Scanner;
+
+public class ParkhausSystem2 {
+    private String[] kennzeichenArray; // Array zur Speicherung der Kennzeichen
+    private Date[] parkzeitArray; // Array zur Speicherung der Parkzeiten
+    private int maxPlatz = 180; // Maximale Anzahl der Parkplätze
+    private int aktuellerPlatz = 0; // Aktuell belegte Plätze
+    private HashMap<String, Double> schuldenMap; // Map zur Speicherung der Schulden
+
+    Scanner scanner = new Scanner(System.in);
+    SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm"); //Z.101
+ 
+    public static void main(String[] args) {
+        ParkhausSystemNEU parkhausSystem = new ParkhausSystemNEU(); // objekt erstellung
+        parkhausSystem.showMenu();
+    }
+
+    public ParkhausSystem2() {
+        kennzeichenArray = new String[maxPlatz]; //  Array für Kennzeichen
+        parkzeitArray = new Date[maxPlatz]; // Array für Parkzeiten
+        schuldenMap = new HashMap<>(); // die Map für Schulden
+    }
+
+    public void showMenu() { //Benutzeroberfläche
+        while (true) {
+            System.out.println("Hauptmenü:");
+            System.out.println("1. Einfahrt");
+            System.out.println("2. Ausfahrt");
+            System.out.println("3. Zahlung");
+            System.out.println("4. Beenden");
+            System.out.println("Aktuell verfügbare Plätze: " + (maxPlatz - aktuellerPlatz));
+            System.out.print("Bitte Auswahl treffen: ");
+            int auswahl = scanner.nextInt();
+            scanner.nextLine(); // Zeilenumbruch konsumieren
+
+            switch (auswahl) { // Auswahl des benutzers an die switch-Anwesoung übergeben
+                case 1:
+                    einfahrt();
+                    break;
+
+                case 2:
+                    ausfahrt();
+                    break;
+
+                case 3:
+                    zahlung();
+                    break;
+
+                case 4:
+                    System.out.println("Programm beendet.");
+                    return; // Beende die Methode und somit das Programm
+
+                default:
+                    System.out.println("Ungültige Auswahl.");
+            }
+        }
+    }
+
+    public void einfahrt() {
+        if (aktuellerPlatz < maxPlatz) {
+            System.out.println("Bitte geben Sie Ihr Kennzeichen ein (oder leer lassen für zufällig generiert):");
+            String kennzeichen = scanner.nextLine().toUpperCase().trim(); // toUpperCase - Konvertierung der Eing in Großbuch. unabhängig vom bennutzer
+  // trim - um versehentlich eingegebene Leerzeichen zu entfernen und so sicherzustellen, dass nur der eigentliche Inhalt der Benutzereingabe verarbeitet wird
+            
+            // Zufälliges Kennzeichen generieren, wenn Benutzer kein Kennzeichen eingibt
+            if (kennzeichen.isEmpty()) { // Prüft, ob die Eingabe des Kennzeichens leer ist
+                kennzeichen = generiereKennzeichen();
+            
+            } else {
+                // Validierung des Kennzeichens
+                if (!istKennzeichenGueltig(kennzeichen)) { //Methode überprüft, ob das Kennzeichen dem geforderten Format entspricht.
+                    System.out.println("Ungültiges Kennzeichen. Bitte überprüfen Sie das Format.");
+                    return;
+                }
+            }
+
+            // Überprüfen, ob das Fahrzeug Schulden hat
+            
+          
+            if (schuldenMap.containsKey(kennzeichen)) { //prüft, ob das Fahrzeugkennzeichen in der schuldenMap vorhanden
+                System.out.println("Achtung: Das Fahrzeug mit Kennzeichen " + kennzeichen + " hat noch offene Schulden in Höhe von "
+                        + schuldenMap.get(kennzeichen) + " Euro. Diese werden zur neuen Rechnung hinzugefügt.");
+            }
+
+            // Aktueller Zeitstempel
+            System.out.print(
+                    "Bitte geben Sie die Parkzeit ein (Format: dd.MM.yyyy, HH:mm) oder leer lassen für aktuelle Zeit: ");
+            String zeitEingabe = scanner.nextLine();
+           //Überprüfung der Eingabe
+            
+            Date parkzeit; //parkzeit als Date objekt festgelegt
+            try {
+                if (zeitEingabe.isEmpty()) {
+                    parkzeit = new Date(); // setzt die Parkzeit des Fahrzeugs auf den aktuellen Zeitstempel, 
+                } else {
+                    parkzeit = sdf.parse(zeitEingabe); //Wenn der Benutzer eine gültige Zeit im richtigen Format eingegeben hat, wird die Eingabe mithilfe von SimpleDateFormat.parse()Z.17 in ein Date-Objekt umgewandelt.
+                }
+            } catch (ParseException e) { // stellt sicher, dass das Programm nicht abstürzt, wenn ein Fehler beim Parsen(String in ein Datum Date) eines Datums auftritt.
+                System.out.println("Ungültiges Zeitformat. Verwenden Sie das Format dd.MM.yyyy, HH:mm.");
+                return; //Prozess wird abgebrochen
+            }
+
+            // Speichere das Kennzeichen und die Parkzeit im Array
+            kennzeichenArray[aktuellerPlatz] = kennzeichen;
+            parkzeitArray[aktuellerPlatz] = parkzeit;
+            aktuellerPlatz++; // Erhöhe den belegten Platz
+            System.out.println(
+                    "Fahrzeug mit Kennzeichen " + kennzeichen + " eingeparkt um " + sdf.format(parkzeit) + ".");
+        } else {
+            System.out.println("Das Parkhaus ist voll.");
+        }
+    }
+
+    public void ausfahrt() {
+        System.out.print("Bitte geben Sie das Kennzeichen zur Ausfahrt ein: ");
+        String kennzeichen = scanner.nextLine().toUpperCase().trim();
+
+        // Suche das Kennzeichen im Array
+        for (int i = 0; i < aktuellerPlatz; i++) {
+            if (kennzeichenArray[i] != null && kennzeichenArray[i].equals(kennzeichen)) {//Es wird geprüft, ob das aktuelle Element im kennzeichenArray nicht null ist (d.h. ob der Parkplatz tatsächlich belegt ist) und ob es mit dem übergebenen kennzeichen übereinstimmt.
+               
+            	
+            	// Berechnung der Parkdauer
+                Date parkzeit = parkzeitArray[i];
+                Date ausfahrtszeit = new Date(); // Aktuelle Zeit wird mit dem Konstruktor new Date() gesetzt
+                long secDiff = (ausfahrtszeit.getTime() - parkzeit.getTime()) / 1000; // Zeitdifferenz in Millisek daher / 1000 
+                long stunden = secDiff / 3600; // umrechnung in sek. und speichern in die Variable stunden
+                System.out.println("Fahrzeug mit Kennzeichen " + kennzeichen + " hat das Parkhaus verlassen.");
+                System.out.println("Parkdauer: " + stunden + " Stunden.");
+
+                // Prüfen, ob das Fahrzeug ein E-Auto ist
+                boolean istEAuto = kennzeichen.endsWith("E");
+                
+                // Parkgebühren berechnen
+                double gebuehren = berechneGebuehren(parkzeit, ausfahrtszeit, istEAuto); 
+                System.out.println("Die Parkgebühren betragen: " + gebuehren + " Euro.");
+
+                // Prüfen auf Zahlung und Schuldenverwaltung
+                if (!schuldenMap.containsKey(kennzeichen)) {
+                    System.out.println("Das Fahrzeug hat nicht bezahlt. Schulden werden gespeichert.");
+                    schuldenMap.put(kennzeichen, gebuehren);
+                } else {
+                    System.out.println("Das Fahrzeug hat offene Schulden von " + schuldenMap.get(kennzeichen) + " Euro.");
+                }
+
+                // Wenn das Kennzeichen gefunden wird, setze den Platz auf null
+                kennzeichenArray[i] = null;
+                parkzeitArray[i] = null; // Setze die Parkzeit auf null
+                aktuellerPlatz--; // Optional: Reduziere den aktuellen Platz um 1
+                return;
+            }
+        }
+        System.out.println("Fahrzeug mit Kennzeichen " + kennzeichen + " nicht gefunden.");
+    }
+
+    public void zahlung() {
+        System.out.print("Bitte geben Sie das Kennzeichen zur Zahlung ein: ");
+        String kennzeichen = scanner.nextLine().toUpperCase().trim();
+
+        // Suche das Kennzeichen im Array
+        for (int i = 0; i < aktuellerPlatz; i++) {
+            if (kennzeichenArray[i] != null && kennzeichenArray[i].equals(kennzeichen)) { // suchen des kennzeichens, wenn nicht null Parkplatz ist belegt
+                // Berechne die Gebühren
+                Date parkzeit = parkzeitArray[i];//Die Parkzeit des Fahrzeugs wird aus dem parkzeitArray abgerufen
+                Date ausfahrtszeit = new Date(); // Eine neue Date-Instanz wird erstellt, um die aktuelle Zeit als Ausfahrtszeit zu speichern
+                boolean istEAuto = kennzeichen.endsWith("E");
+                double gebuehren = berechneGebuehren(parkzeit, ausfahrtszeit, istEAuto); 
+
+                // Hinzufügen der vorherigen Schulden zur neuen Gebühr, falls vorhanden
+                if (schuldenMap.containsKey(kennzeichen)) {
+                    double offeneSchulden = schuldenMap.get(kennzeichen);
+                    System.out.println("Offene Schulden von " + offeneSchulden + " Euro werden zur Gebühr hinzugefügt.");
+                    gebuehren += offeneSchulden; // offene Schulden werden zu den berechneten Gebühren aufaddiert
+                    schuldenMap.remove(kennzeichen); // Schulden löschen, da sie bezahlt werden
+                }
+
+                System.out.printf("Das Fahrzeug mit Kennzeichen %s hat %,.2f Euro zu zahlen.%n", kennzeichen, gebuehren); // %,.2 sorgt das Betrag als Fließkommazahl mit zwei Dezimalstellen angezeigt wird
+                                                                                                                          //%n Platzhalter
+                // Rabatt für E-Auto anwenden, falls das Kennzeichen mit "E" endet
+                if (istEAuto) {
+                    gebuehren *= 0.8; // 20 % Rabatt
+                    System.out.printf("20%% Rabatt für E-Autos angewendet. Neue Gebühr: %,.2f Euro.%n", gebuehren);
+                }
+
+                // Hier Kreditkartenzahlung verarbeiten
+                if (kreditkartenZahlung(gebuehren)) {
+                    System.out.println("Zahlung erfolgreich. Vielen Dank!");
+                } else {
+                    System.out.println("Zahlung fehlgeschlagen. Bitte versuchen Sie es erneut.");
+                }
+
+                return; // Zahlung bearbeitet, frühzeitig zurückkehren
+            }
+        }
+        System.out.println("Fahrzeug mit Kennzeichen " + kennzeichen + " nicht gefunden.");
+    }
+
+    public boolean kreditkartenZahlung(double betrag) {
+        System.out.printf("Bitte bezahlen Sie %,.2f Euro mit Ihrer 16-stelligen VISA-Kreditkarte.%n", betrag);
+        System.out.print("Geben Sie die Kreditkartennummer ein: ");
+        String kreditkartenNummer = scanner.nextLine().trim();
+
+        if (validitaetKreditkartennummer(kreditkartenNummer)) {
+            System.out.println("Kreditkarte gültig.");
+            return true;
+        } else {
+            System.out.println("Ungültige Kreditkartennummer.");
+            return false;
+        }
+    }
+
+    private boolean validitaetKreditkartennummer(String eingabe) {
+        if (eingabe.length() != 16 || !eingabe.matches("\\d{16}")) {
+            return false; // Gültigkeit nur für 16-stellige VISA-Nummern
+        }
+
+        int[] kreditkarteInt = new int[eingabe.length()];
+        for (int i = 0; i < eingabe.length(); i++) {
+            kreditkarteInt[i] = Integer.parseInt(eingabe.substring(i, i + 1));
+        }
+
+        for (int i = kreditkarteInt.length - 2; i >= 0; i -= 2) {
+            int wert = kreditkarteInt[i] * 2;
+            if (wert > 9) {
+                wert = wert % 10 + 1;
+            }
+            kreditkarteInt[i] = wert;
+        }
+
+        int total = 0;
+        for (int i : kreditkarteInt) {
+            total += i;
+        }
+
+        return total % 10 == 0;
+    }
+ 
+    public double berechneGebuehren(Date parkzeit, Date ausfahrtszeit, boolean istEAuto) {
+        long diffInMillis = ausfahrtszeit.getTime() - parkzeit.getTime();
+        long diffInMinutes = diffInMillis / (1000 * 60);
+
+        // Ersten 15 Minuten kostenlos
+        if (diffInMinutes <= 15) {
+            return 0.0;
+        }
+
+        // Ziehe die 15 kostenlosen Minuten von der Parkdauer ab
+        diffInMinutes -= 15;
+
+        double gebuehren = 0.0;
+
+        // Initialisiere Kalenderobjekte für die Parkzeit
+        Calendar calEin = Calendar.getInstance();
+        calEin.setTime(parkzeit);
+
+        // Berechne die Gebühren für die Parkzeit
+        while (diffInMinutes > 0) {
+            int stunde = calEin.get(Calendar.HOUR_OF_DAY);
+
+            // Wenn die Stunde zwischen 20 und 6 liegt, max. 5 Euro pro Stunde
+            if (stunde >= 20 || stunde < 6) {
+                gebuehren += 5.0; // Maximale Gebühr
+                diffInMinutes -= 60; // Eine Stunde abziehen
+            } else {
+                gebuehren += 1.0; // 1 Euro pro angefangener Stunde
+                diffInMinutes -= 60; // Eine Stunde abziehen
+            }
+
+            // Gehe zur nächsten vollen Stunde
+            calEin.add(Calendar.HOUR_OF_DAY, 1);
+        }
+
+        // Maximal 15 Euro pro Tag
+        long tage = (ausfahrtszeit.getTime() - parkzeit.getTime()) / (1000 * 60 * 60 * 24);
+        gebuehren = Math.min(gebuehren, 15 * (tage + 1)); // Deckelung auf 15 Euro pro Tag
+
+        // 20% Rabatt für E-Autos
+        if (istEAuto) {
+            gebuehren *= 0.8;
+        }
+
+        return gebuehren;
+    }
+
+
+    // Einfache Methode zur Generierung eines zufälligen Kennzeichens
+    public String generiereKennzeichen() {
+        String[] buchstaben = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"}; //Array
+        Random rand = new Random(); //Mithilfe eines Random-Objekts werden  zufällige Buchstaben aus diesem Array ausgewählt.
+        
+        String kennzeichen = buchstaben[rand.nextInt(buchstaben.length)] +     //rand.nextInt(buchstaben.length)= zufällige Buchstaben aus dem Array auswählen
+                buchstaben[rand.nextInt(buchstaben.length)] +
+                buchstaben[rand.nextInt(buchstaben.length)] + "-" +    // Bindestrich hinzufügen
+                (rand.nextInt(900) + 100); // Zahl zwischen 100 und 999
+        return kennzeichen;
+    }
+
+    // Einfache Methode zur Validierung eines Kennzeichens (Format: AAA-123)
+    public boolean istKennzeichenGueltig(String kennzeichen) {
+        return kennzeichen.matches( "[A-Z]{2,3}-[A-Z]{2,3} \\d{3,4}(E)?");
+    }
+}                           // A-Z 2 als auch 3 Buchstaben in den beiden Segmenten vor dem BindeStrich
+                           //    \\d steht für eine Ziffer von 0 -9   , {3,4} bedeutet, dass diese Ziffer mindestens 3 und maximal 4 Mal wiederholt werden darf

Qualifier/src/ParkhausSystemNEU.java

@@ -0,0 +1,310 @@
+
+ import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Random;
+import java.util.Scanner;
+
+public class ParkhausSystemNEU {
+    private String[] kennzeichenArray; // Array zur Speicherung der Kennzeichen
+    private Date[] parkzeitArray; // Array zur Speicherung der Parkzeiten
+    private int maxPlatz = 180; // Maximale Anzahl der Parkplätze
+    private int aktuellerPlatz = 0; // Aktuell belegte Plätze
+    private HashMap<String, Double> schuldenMap; // Map zur Speicherung der Schulden
+
+    Scanner scanner = new Scanner(System.in);
+    SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm"); //Z.101
+ 
+    public static void main(String[] args) {
+        ParkhausSystemNEU parkhausSystem = new ParkhausSystemNEU(); // objekt erstellung
+        parkhausSystem.showMenu();
+    }
+
+    public ParkhausSystemNEU() {
+        kennzeichenArray = new String[maxPlatz]; //  Array für Kennzeichen
+        parkzeitArray = new Date[maxPlatz]; // Array für Parkzeiten
+        schuldenMap = new HashMap<>(); // die Map für Schulden
+    }
+
+    public void showMenu() { //Benutzeroberfläche
+        while (true) {
+            System.out.println("Hauptmenü:");
+            System.out.println("1. Einfahrt");
+            System.out.println("2. Ausfahrt");
+            System.out.println("3. Zahlung");
+            System.out.println("4. Beenden");
+            System.out.println("Aktuell verfügbare Plätze: " + (maxPlatz - aktuellerPlatz));
+            System.out.print("Bitte Auswahl treffen: ");
+            int auswahl = scanner.nextInt();
+            scanner.nextLine(); // Zeilenumbruch konsumieren
+
+            switch (auswahl) { // Auswahl des benutzers an die switch-Anwesoung übergeben
+                case 1:
+                    einfahrt();
+                    break;
+
+                case 2:
+                    ausfahrt();
+                    break;
+
+                case 3:
+                    zahlung();
+                    break;
+
+                case 4:
+                    System.out.println("Programm beendet.");
+                    return; // Beende die Methode und somit das Programm
+
+                default:
+                    System.out.println("Ungültige Auswahl.");
+            }
+        }
+    }
+
+    public void einfahrt() {
+        if (aktuellerPlatz < maxPlatz) {
+            System.out.println("Bitte geben Sie Ihr Kennzeichen ein (oder leer lassen für zufällig generiert):");
+            String kennzeichen = scanner.nextLine().toUpperCase().trim(); // toUpperCase - Konvertierung der Eing in Großbuch. unabhängig vom bennutzer
+  // trim - um versehentlich eingegebene Leerzeichen zu entfernen und so sicherzustellen, dass nur der eigentliche Inhalt der Benutzereingabe verarbeitet wird
+            
+            // Zufälliges Kennzeichen generieren, wenn Benutzer kein Kennzeichen eingibt
+            if (kennzeichen.isEmpty()) { // Prüft, ob die Eingabe des Kennzeichens leer ist
+                kennzeichen = generiereKennzeichen();
+            
+            } else {
+                // Validierung des Kennzeichens
+                if (!istKennzeichenGueltig(kennzeichen)) { //Methode überprüft, ob das Kennzeichen dem geforderten Format entspricht.
+                    System.out.println("Ungültiges Kennzeichen. Bitte überprüfen Sie das Format.");
+                    return;
+                }
+            }
+
+            // Überprüfen, ob das Fahrzeug Schulden hat
+            
+          
+            if (schuldenMap.containsKey(kennzeichen)) { //prüft, ob das Fahrzeugkennzeichen in der schuldenMap vorhanden
+                System.out.println("Achtung: Das Fahrzeug mit Kennzeichen " + kennzeichen + " hat noch offene Schulden in Höhe von "
+                        + schuldenMap.get(kennzeichen) + " Euro. Diese werden zur neuen Rechnung hinzugefügt.");
+            }
+
+            // Aktueller Zeitstempel
+            System.out.print(
+                    "Bitte geben Sie die Parkzeit ein (Format: dd.MM.yyyy, HH:mm) oder leer lassen für aktuelle Zeit: ");
+            String zeitEingabe = scanner.nextLine();
+           //Überprüfung der Eingabe
+            
+            Date parkzeit; //parkzeit als Date objekt festgelegt
+            try {
+                if (zeitEingabe.isEmpty()) {
+                    parkzeit = new Date(); // setzt die Parkzeit des Fahrzeugs auf den aktuellen Zeitstempel, 
+                } else {
+                    parkzeit = sdf.parse(zeitEingabe); //Wenn der Benutzer eine gültige Zeit im richtigen Format eingegeben hat, wird die Eingabe mithilfe von SimpleDateFormat.parse()Z.17 in ein Date-Objekt umgewandelt.
+                }
+            } catch (ParseException e) { // stellt sicher, dass das Programm nicht abstürzt, wenn ein Fehler beim Parsen(String in ein Datum Date) eines Datums auftritt.
+                System.out.println("Ungültiges Zeitformat. Verwenden Sie das Format dd.MM.yyyy, HH:mm.");
+                return; //Prozess wird abgebrochen
+            }
+
+            // Speichere das Kennzeichen und die Parkzeit im Array
+            kennzeichenArray[aktuellerPlatz] = kennzeichen;
+            parkzeitArray[aktuellerPlatz] = parkzeit;
+            aktuellerPlatz++; // Erhöhe den belegten Platz
+            System.out.println(
+                    "Fahrzeug mit Kennzeichen " + kennzeichen + " eingeparkt um " + sdf.format(parkzeit) + ".");
+        } else {
+            System.out.println("Das Parkhaus ist voll.");
+        }
+    }
+
+    public void ausfahrt() {
+        System.out.print("Bitte geben Sie das Kennzeichen zur Ausfahrt ein: ");
+        String kennzeichen = scanner.nextLine().toUpperCase().trim();
+
+        // Suche das Kennzeichen im Array
+        for (int i = 0; i < aktuellerPlatz; i++) {
+            if (kennzeichenArray[i] != null && kennzeichenArray[i].equals(kennzeichen)) {//Es wird geprüft, ob das aktuelle Element im kennzeichenArray nicht null ist (d.h. ob der Parkplatz tatsächlich belegt ist) und ob es mit dem übergebenen kennzeichen übereinstimmt.
+               
+            	
+            	// Berechnung der Parkdauer
+                Date parkzeit = parkzeitArray[i];
+                Date ausfahrtszeit = new Date(); // Aktuelle Zeit wird mit dem Konstruktor new Date() gesetzt
+                long secDiff = (ausfahrtszeit.getTime() - parkzeit.getTime()) / 1000; // Zeitdifferenz in Millisek daher / 1000 
+                long stunden = secDiff / 3600; // umrechnung in sek. und speichern in die Variable stunden
+                System.out.println("Fahrzeug mit Kennzeichen " + kennzeichen + " hat das Parkhaus verlassen.");
+                System.out.println("Parkdauer: " + stunden + " Stunden.");
+
+                // Prüfen, ob das Fahrzeug ein E-Auto ist
+                boolean istEAuto = kennzeichen.endsWith("E");
+                
+                // Parkgebühren berechnen
+                double gebuehren = berechneGebuehren(parkzeit, ausfahrtszeit, istEAuto); 
+                System.out.println("Die Parkgebühren betragen: " + gebuehren + " Euro.");
+
+                // Prüfen auf Zahlung und Schuldenverwaltung
+                if (!schuldenMap.containsKey(kennzeichen)) {
+                    System.out.println("Das Fahrzeug hat nicht bezahlt. Schulden werden gespeichert.");
+                    schuldenMap.put(kennzeichen, gebuehren);
+                } else {
+                    System.out.println("Das Fahrzeug hat offene Schulden von " + schuldenMap.get(kennzeichen) + " Euro.");
+                }
+
+                // Wenn das Kennzeichen gefunden wird, setze den Platz auf null
+                kennzeichenArray[i] = null;
+                parkzeitArray[i] = null; // Setze die Parkzeit auf null
+                aktuellerPlatz--; // Optional: Reduziere den aktuellen Platz um 1
+                return;
+            }
+        }
+        System.out.println("Fahrzeug mit Kennzeichen " + kennzeichen + " nicht gefunden.");
+    }
+
+    public void zahlung() {
+        System.out.print("Bitte geben Sie das Kennzeichen zur Zahlung ein: ");
+        String kennzeichen = scanner.nextLine().toUpperCase().trim();
+
+        // Suche das Kennzeichen im Array
+        for (int i = 0; i < aktuellerPlatz; i++) {
+            if (kennzeichenArray[i] != null && kennzeichenArray[i].equals(kennzeichen)) { // suchen des kennzeichens, wenn nicht null Parkplatz ist belegt
+                // Berechne die Gebühren
+                Date parkzeit = parkzeitArray[i];//Die Parkzeit des Fahrzeugs wird aus dem parkzeitArray abgerufen
+                Date ausfahrtszeit = new Date(); // Eine neue Date-Instanz wird erstellt, um die aktuelle Zeit als Ausfahrtszeit zu speichern
+                boolean istEAuto = kennzeichen.endsWith("E");
+                double gebuehren = berechneGebuehren(parkzeit, ausfahrtszeit, istEAuto); 
+
+                // Hinzufügen der vorherigen Schulden zur neuen Gebühr, falls vorhanden
+                if (schuldenMap.containsKey(kennzeichen)) {
+                    double offeneSchulden = schuldenMap.get(kennzeichen);
+                    System.out.println("Offene Schulden von " + offeneSchulden + " Euro werden zur Gebühr hinzugefügt.");
+                    gebuehren += offeneSchulden; // offene Schulden werden zu den berechneten Gebühren aufaddiert
+                    schuldenMap.remove(kennzeichen); // Schulden löschen, da sie bezahlt werden
+                }
+
+                System.out.printf("Das Fahrzeug mit Kennzeichen %s hat %,.2f Euro zu zahlen.%n", kennzeichen, gebuehren); // %,.2 sorgt das Betrag als Fließkommazahl mit zwei Dezimalstellen angezeigt wird
+                                                                                                                          //%n Platzhalter
+                // Rabatt für E-Auto anwenden, falls das Kennzeichen mit "E" endet
+                if (istEAuto) {
+                    gebuehren *= 0.8; // 20 % Rabatt
+                    System.out.printf("20%% Rabatt für E-Autos angewendet. Neue Gebühr: %,.2f Euro.%n", gebuehren);
+                }
+
+                // Hier Kreditkartenzahlung verarbeiten
+                if (kreditkartenZahlung(gebuehren)) {
+                    System.out.println("Zahlung erfolgreich. Vielen Dank!");
+                } else {
+                    System.out.println("Zahlung fehlgeschlagen. Bitte versuchen Sie es erneut.");
+                }
+
+                return; // Zahlung bearbeitet, frühzeitig zurückkehren
+            }
+        }
+        System.out.println("Fahrzeug mit Kennzeichen " + kennzeichen + " nicht gefunden.");
+    }
+
+    public boolean kreditkartenZahlung(double betrag) {
+        System.out.printf("Bitte bezahlen Sie %,.2f Euro mit Ihrer 16-stelligen VISA-Kreditkarte.%n", betrag);
+        System.out.print("Geben Sie die Kreditkartennummer ein: ");
+        String kreditkartenNummer = scanner.nextLine().trim();
+
+        if (validitaetKreditkartennummer(kreditkartenNummer)) {
+            System.out.println("Kreditkarte gültig.");
+            return true;
+        } else {
+            System.out.println("Ungültige Kreditkartennummer.");
+            return false;
+        }
+    }
+
+    private boolean validitaetKreditkartennummer(String eingabe) {
+        if (eingabe.length() != 16 || !eingabe.matches("\\d{16}")) {
+            return false; // Gültigkeit nur für 16-stellige VISA-Nummern
+        }
+
+        int[] kreditkarteInt = new int[eingabe.length()];
+        for (int i = 0; i < eingabe.length(); i++) {
+            kreditkarteInt[i] = Integer.parseInt(eingabe.substring(i, i + 1));
+        }
+
+        for (int i = kreditkarteInt.length - 2; i >= 0; i -= 2) {
+            int wert = kreditkarteInt[i] * 2;
+            if (wert > 9) {
+                wert = wert % 10 + 1;
+            }
+            kreditkarteInt[i] = wert;
+        }
+
+        int total = 0;
+        for (int i : kreditkarteInt) {
+            total += i;
+        }
+
+        return total % 10 == 0;
+    }
+ 
+    public double berechneGebuehren(Date parkzeit, Date ausfahrtszeit, boolean istEAuto) {
+        long diffInMillis = ausfahrtszeit.getTime() - parkzeit.getTime();
+        long diffInMinutes = diffInMillis / (1000 * 60);
+
+        // Ersten 15 Minuten kostenlos
+        if (diffInMinutes <= 15) {
+            return 0.0;
+        }
+
+        // Ziehe die 15 kostenlosen Minuten von der Parkdauer ab
+        diffInMinutes -= 15;
+
+        double gebuehren = 0.0;
+
+        // Initialisiere Kalenderobjekte für die Parkzeit
+        Calendar calEin = Calendar.getInstance();
+        calEin.setTime(parkzeit);
+
+        // Berechne die Gebühren für die Parkzeit
+        while (diffInMinutes > 0) {
+            int stunde = calEin.get(Calendar.HOUR_OF_DAY);
+
+            // Wenn die Stunde zwischen 20 und 6 liegt, max. 5 Euro pro Stunde
+            if (stunde >= 20 || stunde < 6) {
+                gebuehren += 5.0; // Maximale Gebühr
+                diffInMinutes -= 60; // Eine Stunde abziehen
+            } else {
+                gebuehren += 1.0; // 1 Euro pro angefangener Stunde
+                diffInMinutes -= 60; // Eine Stunde abziehen
+            }
+
+            // Gehe zur nächsten vollen Stunde
+            calEin.add(Calendar.HOUR_OF_DAY, 1);
+        }
+
+        // Maximal 15 Euro pro Tag
+        long tage = (ausfahrtszeit.getTime() - parkzeit.getTime()) / (1000 * 60 * 60 * 24);
+        gebuehren = Math.min(gebuehren, 15 * (tage + 1)); // Deckelung auf 15 Euro pro Tag
+
+        // 20% Rabatt für E-Autos
+        if (istEAuto) {
+            gebuehren *= 0.8;
+        }
+
+        return gebuehren;
+    }
+
+
+    // Einfache Methode zur Generierung eines zufälligen Kennzeichens
+    public String generiereKennzeichen() {
+        String[] buchstaben = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"}; //Array
+        Random rand = new Random(); //Mithilfe eines Random-Objekts werden  zufällige Buchstaben aus diesem Array ausgewählt.
+        
+        String kennzeichen = buchstaben[rand.nextInt(buchstaben.length)] +     //rand.nextInt(buchstaben.length)= zufällige Buchstaben aus dem Array auswählen
+                buchstaben[rand.nextInt(buchstaben.length)] +
+                buchstaben[rand.nextInt(buchstaben.length)] + "-" +    // Bindestrich hinzufügen
+                (rand.nextInt(900) + 100); // Zahl zwischen 100 und 999
+        return kennzeichen;
+    }
+
+    // Einfache Methode zur Validierung eines Kennzeichens (Format: AAA-123)
+    public boolean istKennzeichenGueltig(String kennzeichen) {
+        return kennzeichen.matches( "[A-Z]{2,3}-[A-Z]{2,3} \\d{3,4}(E)?");
+    }
+}                           // A-Z 2 als auch 3 Buchstaben in den beiden Segmenten vor dem BindeStrich
+                           //    \\d steht für eine Ziffer von 0 -9   , {3,4} bedeutet, dass diese Ziffer mindestens 3 und maximal 4 Mal wiederholt werden darf