From 5c6912219b6e190aba7cdf3a7de491cdabab13b4 Mon Sep 17 00:00:00 2001 From: obai Date: Tue, 8 Oct 2024 16:57:35 +0200 Subject: [PATCH] parkhaus --- .../myLogFile.log | 0 .../VerwalteStudent.java | 14 +- .../src/MyCollections/List/My_ArrayList.java | 1 + .../src/MyCollections/List/Test.java | 18 +- .../src/Parkhaus/Allgemeine_Test.java | 47 ++++ .../Parkhaus/AutoNichtGefundenException.java | 9 + Programmierung2/src/Parkhaus/Fahrzeug.java | 93 +++++++ .../src/Parkhaus/JTest_AutoMitSchulden.java | 52 ++++ .../src/Parkhaus/JTest_Einfahren.java | 32 +++ .../src/Parkhaus/JTest_ausfahren.java | 39 +++ .../Parkhaus/JTest_berechneParkgebuehren.java | 86 +++++++ .../src/Parkhaus/JTest_checkVisakarte.java | 46 ++++ Programmierung2/src/Parkhaus/Main.java | 14 ++ Programmierung2/src/Parkhaus/Parkhaus.java | 226 ++++++++++++++++++ Programmierung2/src/Parkhaus/TextUI.java | 116 +++++++++ Programmierung2/src/Parkhaus/Zahlung.java | 43 ++++ .../kennzeichenzufaelliggenerieren.java | 46 ++++ .../src/VorlesungsFolien/Verebung/Main.java | 13 +- .../src/oop/Verebung/Mitarbeiter.java | 52 ++++ 19 files changed, 926 insertions(+), 21 deletions(-) rename myLogFile.log => Programmierung2/myLogFile.log (100%) create mode 100644 Programmierung2/src/Parkhaus/Allgemeine_Test.java create mode 100644 Programmierung2/src/Parkhaus/AutoNichtGefundenException.java create mode 100644 Programmierung2/src/Parkhaus/Fahrzeug.java create mode 100644 Programmierung2/src/Parkhaus/JTest_AutoMitSchulden.java create mode 100644 Programmierung2/src/Parkhaus/JTest_Einfahren.java create mode 100644 Programmierung2/src/Parkhaus/JTest_ausfahren.java create mode 100644 Programmierung2/src/Parkhaus/JTest_berechneParkgebuehren.java create mode 100644 Programmierung2/src/Parkhaus/JTest_checkVisakarte.java create mode 100644 Programmierung2/src/Parkhaus/Main.java create mode 100644 Programmierung2/src/Parkhaus/Parkhaus.java create mode 100644 Programmierung2/src/Parkhaus/TextUI.java create mode 100644 Programmierung2/src/Parkhaus/Zahlung.java create mode 100644 Programmierung2/src/Parkhaus/kennzeichenzufaelliggenerieren.java create mode 100644 Programmierung2/src/oop/Verebung/Mitarbeiter.java diff --git a/myLogFile.log b/Programmierung2/myLogFile.log similarity index 100% rename from myLogFile.log rename to Programmierung2/myLogFile.log diff --git a/Programmierung2/src/GUIAnwendungen/StudentManagementSystem/VerwalteStudent.java b/Programmierung2/src/GUIAnwendungen/StudentManagementSystem/VerwalteStudent.java index 956fba5..5a60755 100644 --- a/Programmierung2/src/GUIAnwendungen/StudentManagementSystem/VerwalteStudent.java +++ b/Programmierung2/src/GUIAnwendungen/StudentManagementSystem/VerwalteStudent.java @@ -64,23 +64,17 @@ public class VerwalteStudent { } public void showUser() { - String studentName = view.getEingabeNameZuSuchen().getText(); - student = findStudent(studentName); + String idText = view.getEingabeIdZuLoeschen().getText(); + 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("");; diff --git a/Programmierung2/src/MyCollections/List/My_ArrayList.java b/Programmierung2/src/MyCollections/List/My_ArrayList.java index 07e03cc..f8601cc 100644 --- a/Programmierung2/src/MyCollections/List/My_ArrayList.java +++ b/Programmierung2/src/MyCollections/List/My_ArrayList.java @@ -27,6 +27,7 @@ public class My_ArrayList implements MyList { for (int i = 0; i < arr.length ; i++) neuarr[i] = arr[i]; arr = neuarr; + neuarr = null; } @Override diff --git a/Programmierung2/src/MyCollections/List/Test.java b/Programmierung2/src/MyCollections/List/Test.java index f57871c..48bd515 100644 --- a/Programmierung2/src/MyCollections/List/Test.java +++ b/Programmierung2/src/MyCollections/List/Test.java @@ -8,13 +8,27 @@ public class Test { ArrayList 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); } } diff --git a/Programmierung2/src/Parkhaus/Allgemeine_Test.java b/Programmierung2/src/Parkhaus/Allgemeine_Test.java new file mode 100644 index 0000000..16e3081 --- /dev/null +++ b/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()); + } + +} diff --git a/Programmierung2/src/Parkhaus/AutoNichtGefundenException.java b/Programmierung2/src/Parkhaus/AutoNichtGefundenException.java new file mode 100644 index 0000000..15600ef --- /dev/null +++ b/Programmierung2/src/Parkhaus/AutoNichtGefundenException.java @@ -0,0 +1,9 @@ +package Parkhaus; + +public class AutoNichtGefundenException extends Exception { + + AutoNichtGefundenException(String autoNichtGefunden){ + super(autoNichtGefunden); + } + +} diff --git a/Programmierung2/src/Parkhaus/Fahrzeug.java b/Programmierung2/src/Parkhaus/Fahrzeug.java new file mode 100644 index 0000000..e0ad326 --- /dev/null +++ b/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; + } + +} diff --git a/Programmierung2/src/Parkhaus/JTest_AutoMitSchulden.java b/Programmierung2/src/Parkhaus/JTest_AutoMitSchulden.java new file mode 100644 index 0000000..461bfc5 --- /dev/null +++ b/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); + + + } + +} diff --git a/Programmierung2/src/Parkhaus/JTest_Einfahren.java b/Programmierung2/src/Parkhaus/JTest_Einfahren.java new file mode 100644 index 0000000..e3d2ced --- /dev/null +++ b/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()); + + } +} \ No newline at end of file diff --git a/Programmierung2/src/Parkhaus/JTest_ausfahren.java b/Programmierung2/src/Parkhaus/JTest_ausfahren.java new file mode 100644 index 0000000..270e76d --- /dev/null +++ b/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)); + + } + +} diff --git a/Programmierung2/src/Parkhaus/JTest_berechneParkgebuehren.java b/Programmierung2/src/Parkhaus/JTest_berechneParkgebuehren.java new file mode 100644 index 0000000..871d9c3 --- /dev/null +++ b/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)); + } + + + +} diff --git a/Programmierung2/src/Parkhaus/JTest_checkVisakarte.java b/Programmierung2/src/Parkhaus/JTest_checkVisakarte.java new file mode 100644 index 0000000..fe50322 --- /dev/null +++ b/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)); + } + + + + + +} diff --git a/Programmierung2/src/Parkhaus/Main.java b/Programmierung2/src/Parkhaus/Main.java new file mode 100644 index 0000000..da21631 --- /dev/null +++ b/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(); + + } + +} diff --git a/Programmierung2/src/Parkhaus/Parkhaus.java b/Programmierung2/src/Parkhaus/Parkhaus.java new file mode 100644 index 0000000..e3dfc32 --- /dev/null +++ b/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 fahrzeuge; + private Set 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; + } + +} \ No newline at end of file diff --git a/Programmierung2/src/Parkhaus/TextUI.java b/Programmierung2/src/Parkhaus/TextUI.java new file mode 100644 index 0000000..5a22cb9 --- /dev/null +++ b/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("<> "); + 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"); + + } + } + } +} diff --git a/Programmierung2/src/Parkhaus/Zahlung.java b/Programmierung2/src/Parkhaus/Zahlung.java new file mode 100644 index 0000000..aa4a070 --- /dev/null +++ b/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; + + } + +} diff --git a/Programmierung2/src/Parkhaus/kennzeichenzufaelliggenerieren.java b/Programmierung2/src/Parkhaus/kennzeichenzufaelliggenerieren.java new file mode 100644 index 0000000..9e530d2 --- /dev/null +++ b/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 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; + + } + +} \ No newline at end of file diff --git a/Programmierung2/src/VorlesungsFolien/Verebung/Main.java b/Programmierung2/src/VorlesungsFolien/Verebung/Main.java index 7723abf..d1fb414 100644 --- a/Programmierung2/src/VorlesungsFolien/Verebung/Main.java +++ b/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(); - Manager ma = new Manager("Stromberg", "01.02.1970"); - System.out.println(ma.toString()); // wieder die Methode von Object - System.out.println(ma.getDetails()); + Mitarbeiter ai = new Manager("Herr Muller" , "01.02.2011"); + System.out.println(ai.getDetails()); } } @@ -40,7 +34,8 @@ class Manager extends Mitarbeiter { public Manager(String name, String geburtsdatum) { super(name, 65000, geburtsdatum); // das MUSS gemacht werden! } - + + @Override public String getDetails() { return super.getDetails() + " " + abteilung; } diff --git a/Programmierung2/src/oop/Verebung/Mitarbeiter.java b/Programmierung2/src/oop/Verebung/Mitarbeiter.java new file mode 100644 index 0000000..a287c07 --- /dev/null +++ b/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()); + + } + + + +}