336 lines
14 KiB
Java
336 lines
14 KiB
Java
package QualifierTeil2;
|
|
|
|
import java.text.ParseException;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.*;
|
|
|
|
public class Parkhaus {
|
|
private List<PKW> parkendePkws;
|
|
int kapazitaetVerfuegbar;
|
|
int belegt;
|
|
int maxKapazitaet;
|
|
|
|
public Parkhaus() {
|
|
this.parkendePkws = new ArrayList<>();
|
|
this.maxKapazitaet = randomAnzahlParkplätze();
|
|
this.kapazitaetVerfuegbar = maxKapazitaet;
|
|
this.belegt = 0;
|
|
}
|
|
|
|
|
|
// Methode zum Einfahren eines PKWs
|
|
public void einfahren(String kennzeichen, Date einfahrtZeit) {
|
|
PKW existierenderPKW = null;
|
|
|
|
// Ü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 in Höhe von " + (existierenderPKW.getGebuehrenkonto() /100) + " Euro.");
|
|
this.kapazitaetVerfuegbar--;
|
|
this.belegt++;
|
|
} else {
|
|
// Neuen PKW erstellen und Schulden übernehmen, falls vorhanden
|
|
PKW neuerPKW = new PKW(kennzeichen, einfahrtZeit);
|
|
double schulden = sucheSchulden(kennzeichen); // Funktion, die die alten Schulden findet (falls vorhanden)
|
|
neuerPKW.setGebuehrenkonto(schulden); // Vorherige Schulden hinzufügen
|
|
parkendePkws.add(neuerPKW);
|
|
this.kapazitaetVerfuegbar--;
|
|
this.belegt++;
|
|
System.out.println("Neuer PKW mit Kennzeichen " + kennzeichen + " eingefahren. Schulden: " + schulden + " Cent.");
|
|
}
|
|
}
|
|
|
|
|
|
// Methode zum Ausfahren eines PKWs anhand des Kennzeichens
|
|
public void ausfahren(String kennzeichen) {
|
|
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;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Falls Auto zum Entfernen gibt
|
|
if (zuEntfernen != null) {
|
|
|
|
//Ausfahrtszeit manuell eingeben oder automatisch übernehmen
|
|
SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
|
|
Date ausfahrtZeit;
|
|
|
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
System.out.println("Bitte geben Sie die Ausfahrtszeit ein (leer lassen für aktuelle Zeit, Format: dd.MM.yyyy, HH:mm): ");
|
|
String ausfahrtInput = scanner.nextLine();
|
|
|
|
if (ausfahrtInput.isEmpty()){
|
|
ausfahrtZeit = new Date();//Aktuelle Zeit nehmen
|
|
System.out.println("Ausfahrtszeit: " + sdf.format(ausfahrtZeit));
|
|
} else {
|
|
try {
|
|
ausfahrtZeit = sdf.parse(ausfahrtInput); // Manuelle Eingabe verarbeiten
|
|
System.out.println("Ausfahrtszeit: " + sdf.format(ausfahrtZeit));
|
|
} catch (ParseException e) {
|
|
System.out.println("Ungültiges Datum, benutze aktuelle Zeit.");
|
|
ausfahrtZeit = new Date();
|
|
System.out.println("Ausfahrtszeit: " + sdf.format(ausfahrtZeit));
|
|
}
|
|
}
|
|
|
|
// Berechnung der Gebühren
|
|
double aktuelleGebuehren = berechneGebuehren(kennzeichen, ausfahrtZeit);
|
|
double gesamtGebuehren = zuEntfernen.getGebuehrenkonto() + aktuelleGebuehren; // Summe der Schulden + aktuelle Gebühren
|
|
|
|
|
|
// Gebührenkonto aktualisieren
|
|
zuEntfernen.setGebuehrenkonto(aktuelleGebuehren); // Schulden für unbezahlte Gebühren hinzufügen
|
|
|
|
// Falls Gebühren vorhanden sind
|
|
if (gesamtGebuehren > 0) {
|
|
|
|
// Umwandlung von Minuten in Stunden und Minuten
|
|
long parkdauerMinuten = berechneParkdauer(kennzeichen,ausfahrtZeit);
|
|
long parkdauerStunden = parkdauerMinuten / 60;
|
|
long parkdauerVerbleibendeMinuten = parkdauerMinuten % 60;
|
|
System.out.println("Parkdauer: " + parkdauerStunden + " Stunden und " + parkdauerVerbleibendeMinuten + " Minuten.");
|
|
System.out.println("Parkgebühren: " + (zuEntfernen.getGebuehrenkonto() / 100.0) + " Euro");
|
|
|
|
// Kreditkartenvalidierung vor Ausfahrt
|
|
|
|
System.out.println("Bitte geben Sie Ihre 16-stellige VISA-Kreditkartennummer ein:");
|
|
String kreditkartenNummer = scanner.nextLine();
|
|
|
|
if (pruefeKreditkarte(kreditkartenNummer)) {
|
|
System.out.println("Zahlung erfolgreich. Sie dürfen ausfahren.");
|
|
zuEntfernen.setGebuehrenkonto(0); // Gebühren auf 0 setzen
|
|
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("Offenes Gebührenkonto: " + (zuEntfernen.getGebuehrenkonto() / 100.0) + " Euro");
|
|
}
|
|
} else {
|
|
// Gebührenfrei (unter 15 Minuten oder andere Ausnahme)
|
|
|
|
System.out.println("Parkdauer in Minuten: " + berechneParkdauer(kennzeichen, ausfahrtZeit));
|
|
System.out.println("Parkgebühren in Cent: " + zuEntfernen.getGebuehrenkonto());
|
|
System.out.println("PKW mit Kennzeichen " + kennzeichen + " darf gebührenfrei ausfahren.");
|
|
}
|
|
|
|
// 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");
|
|
|
|
} else {
|
|
System.out.println("Kein PKW mit diesem Kennzeichen gefunden.\n");
|
|
}
|
|
}
|
|
|
|
public long berechneParkdauer(String kennzeichen, Date ausfahrt) {
|
|
long minDiff = 0;
|
|
|
|
// Überprüfen, ob das Auto mit dem angegebenen Kennzeichen existiert
|
|
for (PKW pkw : parkendePkws) {
|
|
if (pkw.getKennzeichen().equals(kennzeichen)) {
|
|
Date einfahrt = pkw.getEinfahrt();
|
|
|
|
|
|
// Parkdauer in Minuten berechnen (Differenz zwischen Ausfahrt und Einfahrt)
|
|
minDiff = ((ausfahrt.getTime() - einfahrt.getTime())) / 60000;
|
|
break;
|
|
}
|
|
}
|
|
return minDiff;
|
|
}
|
|
|
|
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; //Parken ist kostenlos
|
|
}
|
|
|
|
// Parkdauer nach den 15 Minuten
|
|
long parkdauerOhneFreiminuten = parkdauer - 15;
|
|
|
|
|
|
// Gebühren für die restliche Zeit unter 24 Stunden, wenn vorhanden
|
|
if (parkdauerOhneFreiminuten > 0) {
|
|
// Berechnung der Gebühren für die restlichen Minuten nach den vollen Tagen
|
|
while (parkdauerOhneFreiminuten > 0) {
|
|
gebuehr += 100; // 1 Euro pro angefangene Stunde
|
|
parkdauerOhneFreiminuten -= 60;
|
|
}
|
|
}
|
|
|
|
// Maximale Gebühren in der Nacht von 20 Uhr bis 6 Uhr
|
|
gebuehr = berechneNachttarif(kennzeichen, gebuehr, ausfahrt);
|
|
|
|
// Hier wird die Gebühr auf maximal 15 Euro (1500 Cent) für den Tag gedeckelt
|
|
if (gebuehr > 1500) {
|
|
gebuehr = 1500; // Maximal 15 Euro pro Tag
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
// Methode zur Überprüfung der Kreditkartennummer mit dem Luhn-Algorithmus
|
|
public boolean pruefeKreditkarte(String kreditkartenNummer) {
|
|
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--) {
|
|
int n = Integer.parseInt(kreditkartenNummer.substring(i, i + 1));
|
|
if (alternate) {
|
|
n *= 2;
|
|
if (n > 9) {
|
|
n = (n % 10) + 1;
|
|
}
|
|
}
|
|
sum += n;
|
|
alternate = !alternate;
|
|
}
|
|
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 calAusfahrt = Calendar.getInstance();
|
|
calAusfahrt.setTime(ausfahrt);
|
|
|
|
// Bestimme die Einfahrtszeit des Fahrzeugs
|
|
Date einfahrt = findeEinfahrtZeit(kennzeichen); // Methode zum Finden der Einfahrtszeit
|
|
Calendar calEinfahrt = Calendar.getInstance();
|
|
calEinfahrt.setTime(einfahrt);
|
|
|
|
// Definiere die Nachtgrenzen: 20:00 Uhr bis 6:00 Uhr
|
|
Calendar startNacht = Calendar.getInstance();
|
|
startNacht.setTime(einfahrt);
|
|
startNacht.set(Calendar.HOUR_OF_DAY, 20); // Nacht beginnt um 20:00 Uhr
|
|
startNacht.set(Calendar.MINUTE, 0);
|
|
|
|
Calendar endeNacht = Calendar.getInstance();
|
|
endeNacht.setTime(einfahrt);
|
|
endeNacht.set(Calendar.HOUR_OF_DAY, 6); // Nacht endet um 06:00 Uhr
|
|
endeNacht.add(Calendar.DATE, 1); // Geht auf den nächsten Tag*/
|
|
|
|
/*// Schritt 1: Berechne Gebühren bis 20 Uhr
|
|
while (calEinfahrt.before(startNacht) && calEinfahrt.before(calAusfahrt)) {
|
|
// Jede angefangene Stunde bis 20:00 Uhr kostet 1 Euro
|
|
gebuehr += 100;
|
|
calEinfahrt.add(Calendar.HOUR_OF_DAY, 1); // Erhöhe um eine Stunde
|
|
}*/
|
|
|
|
// Schritt 2: Berechne Gebühren in der Nachtzeit
|
|
double nachtGebuehr = 0;
|
|
if (calAusfahrt.after(startNacht)) {
|
|
// Die Parkzeit überschreitet 20:00 Uhr und geht in die Nachtzeit
|
|
while (calEinfahrt.before(calAusfahrt) && (calEinfahrt.get(Calendar.HOUR_OF_DAY) >= 20 || calEinfahrt.get(Calendar.HOUR_OF_DAY) < 6)) {
|
|
nachtGebuehr += 100; // Jede Stunde in der Nacht kostet auch 1 Euro
|
|
calEinfahrt.add(Calendar.HOUR_OF_DAY, 1);
|
|
}
|
|
}
|
|
|
|
// Schritt 3: Deckele die Nachttarif-Gebühr auf maximal 5 Euro
|
|
if (nachtGebuehr > 500) {
|
|
nachtGebuehr = 500; // Maximal 5 Euro für die gesamte Nachtzeit
|
|
}
|
|
|
|
// Addiere die Nachtgebühren zu den normalen Stunden
|
|
return gebuehr + nachtGebuehr;
|
|
}
|
|
|
|
|
|
|
|
// 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();
|
|
}
|
|
}
|
|
|
|
|
|
|