From 3410f07cdeb3f40cee7fa6049e0b2f860d6f8559 Mon Sep 17 00:00:00 2001 From: gozde Date: Tue, 8 Oct 2024 04:14:37 +0200 Subject: [PATCH] Methoden --- PR2GIT/src/Parkhaus3.java | 310 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 310 insertions(+) create mode 100644 PR2GIT/src/Parkhaus3.java diff --git a/PR2GIT/src/Parkhaus3.java b/PR2GIT/src/Parkhaus3.java new file mode 100644 index 0000000..0a4ae6d --- /dev/null +++ b/PR2GIT/src/Parkhaus3.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 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 + private int aktuellerPlatz = 0; // Aktuell belegte Plätze + private HashMap 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) { + Parkhaus3 parkhausSystem = new Parkhaus3(); // objekt erstellung + parkhausSystem.showMenu(); + } + + 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 + } + + 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