erste Kommentare

src/main/java/de/deversmann/Parkhaus.java

@@ -75,63 +75,107 @@ public class Parkhaus {
         this.belegteParkplätze = belegteParkplätze;
     }
 
-
+    /**
-    public ArrayList berechneParkdauer(String einfahrtZeit, String ausfahrZeit) {
+     * Der Preis wird anhand der Attribute des Autos berechnet, dieses hat alle notwendigen Informationen wie die
-        ArrayList parkdauer = new ArrayList();
+     * Ein- und Ausfahrtszeit, ob es ein eAuto ist und ob noch Schulden von einer nicht bezahlten Parksession vorliegen.
-        simpleDateFormat.setLenient(false);
+     *
-        try {
+     * @param auto
-            Date einfahrtZeitDate = simpleDateFormat.parse(einfahrtZeit);
+     * @return preis
-            Date ausfahrZeitDate = simpleDateFormat.parse(ausfahrZeit);
+     * @throws ParseException
-            Duration duration = Duration.ofMillis(Math.abs(ausfahrZeitDate.getTime() - einfahrtZeitDate.getTime()));
+     */
-            long days = duration.toDays();
-            long hours = duration.toHours() % 24;
-            long minutes = duration.toMinutes() % 60;
-
-            Collections.addAll(parkdauer, days, hours, minutes);
-        } catch (ParseException e) {
-            System.out.println("Fehler beim Parsen der Daten" + e.getMessage());
-        }
-
-        return parkdauer;
-    }
-
     public double berechnePreis(Auto auto) throws ParseException {
+        //der Preis ist initial auf 0
         double preis = 0;
+
+        //setzt aus, dass man nicht existierende Daten eingeben kann wie den 31.02 oder den 00.12.
         simpleDateFormat.setLenient(false);
+
+        //holt die Ein- und Ausfahrtszeit des übergebenen Autos mittels getter
         Date einfahrtZeitDate = simpleDateFormat.parse(auto.getEinfahrtZeit());
         Date ausfahrtZeitDate = simpleDateFormat.parse(auto.getAusfahrtZeit());
+
+        //holt die Einfahrts- und Ausfahrtsstunde zum überprüfen des Nachttarifs
         int einfahrtStunde = einfahrtZeitDate.getHours();
         int ausfahrtStunde = ausfahrtZeitDate.getHours();
+
+        //berechnet die Parkdauer und wandelt von Millisekunden in Minuten um
         long parkdauerInMinuten = (ausfahrtZeitDate.getTime() - einfahrtZeitDate.getTime()) / (60 * 1000);
 
+        //wenn die Parkdauer 15 Minuten nicht überschreitet, kann frei geparkt werden (KISS & RIDE)
         if (parkdauerInMinuten < FREIE_MINUTEN) {
             return 0;
         }
 
+        //kostenpflichtige Minuten berechnen
         long kostenpflichtigeMinuten = parkdauerInMinuten - FREIE_MINUTEN;
+
+        //kostenpflichtige Stunden berechnen, wobei jede angefangene Stunde aufgerundet wird
         double kostenPflichtigeStunden = Math.ceil(((double) kostenpflichtigeMinuten / 60));
 
-        long parkdauerInTagen = (long) Math.ceil(parkdauerInMinuten / (60.0 * 24));
+        //überprüfen, ob ein oder mehrere ganze Tage im Parkhaus geparkt wurden
-
-
-        if (parkdauerInTagen >= 1) {
         long kostenpflichtigeGanzeTage = (long) Math.floor(kostenPflichtigeStunden / 24);
+
+        //wenn mindestens ein ganzer Tag
         if (kostenpflichtigeGanzeTage >= 1) {
 
+            //wird der Preis auf die Anzahl der Tage mal den Tagessatz gesetzt
             preis = kostenpflichtigeGanzeTage * TAGES_MAX_PREIS;
+
+            /*
+            die übrigen Stunden der Berechnung setzten sich aus den kostenpflichtigen Stunden abzüglich der
+            kostenpflichtigen ganzen Tage in Stunden zusammen
+            */
             long übrigenStunden = (long) (kostenPflichtigeStunden - kostenpflichtigeGanzeTage * 24);
+
+            /*
+            wenn die übrigen Stunden weniger als 6 sind, kann automatisch der Preis um die Anzahl der übrigen Stunden
+            erhöht werden
+             */
             if (übrigenStunden <= 5) {
                 preis = preis + (übrigenStunden * ANGEFANGENE_STUNDE_PREIS);
-                } else if (einfahrtStunde >= 20) {
+            }
+            // ab 20:00 muss überprüft werden, ob der Nachttarif greift
+            else if (einfahrtStunde >= 20) {
+                /*
+                die Stunden am Tag der Einfahrt werden berechnet, indem die Einfahrtsstunde genommen wird und
+                die Stunden hinzugefügt werden, die noch übrig sind. Das ganze wird mit 24, also einem ganzen Tag subtrahiert
+
+                Bsp.: Einfahrt 20:00, Ausfahrt 10:00 am folgenden Tag = Parkzeit von 14h
+
+                        (20 + 14) - 24 = 10
+                        also sind 10 Stunden im Tag der Ausfahrt
+                */
+
                 long stundenImAltenTag = (einfahrtStunde + übrigenStunden) - 24;
                 long stundenImNeuenTag = übrigenStunden - stundenImAltenTag;
-                    if (stundenImNeuenTag <= 5) {
+                /*
+                wenn am Folgetag nur bis maximal 05:59 geparkt wurde, greift der Nachttarif und es werden nur 5€
+                auf den Preis aufgeschlagen
+                im neuen Tag sind dann insgesamt 6h auf die der Nachttarif angewand werden kann
+                00:00-01:00, 01:00-02:00, ..., 05:00-05:59
+                 */
+                if (stundenImNeuenTag <= 6) {
                     preis += 5;
-                    } else {
+                }
-                        preis += 5 + stundenImNeuenTag - 5;
+                /*
+                wenn lönger als 05:59 geparkt wird muss die verbleibende Parkdauer um eine Stunde gekürzt werden, da
+                ja der Nachttarif eine Stunde schluckt.
+
+                Bsp.: 00:00-07:01 Parkdauer zur berechnung 8h
+                        00:00-05:59 sind 5€ für 6h
+                        06:00-06:59 1€ für eine ganze Stunde
+                        07:00-07:01 1€ für angebrochene Stunde
+                        Preis 7€
+                        Stunden im neuen Tag = 8    - 1    --> 7€
+
+                 */
+                else {
+                    preis += stundenImNeuenTag - 1;
                 }
 
+                //hier das gleiche Spiel nur von Mitternacht ausgehend
             } else if (einfahrtStunde <= 5) {
+
                 long angebrocheneStundenAusserhalbDerNacht = (long) 6 - einfahrtStunde;
                 long übrigeStundenAusserhalb = übrigenStunden - einfahrtStunde;
                 if (angebrocheneStundenAusserhalbDerNacht == 6) {
@@ -168,7 +212,7 @@ public class Parkhaus {
             }
             preis = preis == 0 ? kostenPflichtigeStunden : preis;
         }
-        }
+
         if (auto.iseAuto()) {
             preis = preis * E_AUTO_RABATT;
         }