157 lines
6.1 KiB
Plaintext
157 lines
6.1 KiB
Plaintext
du musst mir das mit Calendar genauer erklären, gerne auch mit Beispiele : Calendar calEin = Calendar.getInstance();
|
|
calEin.setTime(d1);
|
|
Calendar calAus = Calendar.getInstance();
|
|
calAus.setTime(d2);
|
|
|
|
// Gebühren deklarieren
|
|
double gebuehrenTag = 0;
|
|
double gebuehrenNacht = 0;
|
|
|
|
// Berechnung der Gebühren für jeden Tag
|
|
while (calEin.before(calAus) || calEin.equals(calAus)) {
|
|
int aktuelleStunde = calEin.get(Calendar.HOUR_OF_DAY);
|
|
|
|
|
|
Antwort:
|
|
|
|
|
|
Gerne! Ich werde die Verwendung der `Calendar`-Klasse in deinem Code detailliert erklären und Beispiele geben, um die Funktionsweise zu verdeutlichen.
|
|
|
|
### Einführung in die `Calendar`-Klasse
|
|
|
|
Die `Calendar`-Klasse in Java ist eine abstrakte Klasse, die die Arbeit mit Datums- und Zeitangaben erleichtert. Sie ermöglicht das Erstellen, Bearbeiten und Vergleichen von Datumsangaben in einer flexiblen Art und Weise. Hier sind einige wichtige Punkte zur `Calendar`-Klasse:
|
|
|
|
1. **Instanziierung**:
|
|
- `Calendar` kann nicht direkt instanziiert werden (d.h., man kann kein Objekt von `Calendar` mit `new Calendar()` erstellen). Stattdessen verwendet man die statische Methode `getInstance()`, um ein `Calendar`-Objekt zu erhalten, das auf der aktuellen Zeit basiert.
|
|
|
|
2. **Zeitzonen und lokale Einstellungen**:
|
|
- Die `Calendar`-Klasse berücksichtigt die aktuelle Zeitzone des Systems, was bedeutet, dass sie sich entsprechend der eingestellten Zeitzone des Computers verhält.
|
|
|
|
3. **Manipulation von Datum und Uhrzeit**:
|
|
- Mit der `Calendar`-Klasse können verschiedene Teile eines Datums (Jahr, Monat, Tag, Stunde, Minute, Sekunde usw.) separat manipuliert werden.
|
|
|
|
### Erklärungen und Beispiele des Codes
|
|
|
|
#### Code-Abschnitt:
|
|
|
|
```java
|
|
Calendar calEin = Calendar.getInstance();
|
|
calEin.setTime(d1);
|
|
Calendar calAus = Calendar.getInstance();
|
|
calAus.setTime(d2);
|
|
```
|
|
|
|
**1. Erstellen und Setzen von Calendar-Objekten**:
|
|
- `Calendar calEin = Calendar.getInstance();`:
|
|
- Diese Zeile erstellt ein neues `Calendar`-Objekt namens `calEin`, das auf die aktuelle Zeit gesetzt ist.
|
|
|
|
- `calEin.setTime(d1);`:
|
|
- Diese Zeile setzt die Zeit von `calEin` auf die Einfahrtszeit (`d1`), die ein `Date`-Objekt ist. Damit wird `calEin` die spezifische Zeit von `d1` halten.
|
|
|
|
- `Calendar calAus = Calendar.getInstance();`:
|
|
- Ähnlich wie bei `calEin` wird hier ein weiteres `Calendar`-Objekt namens `calAus` erstellt, das ebenfalls auf die aktuelle Zeit gesetzt ist.
|
|
|
|
- `calAus.setTime(d2);`:
|
|
- Hier wird die Ausfahrtszeit (`d2`) in das `calAus`-Objekt gesetzt.
|
|
|
|
#### Beispiel:
|
|
Angenommen, `d1` und `d2` sind die folgenden `Date`-Objekte:
|
|
|
|
```java
|
|
Date d1 = new SimpleDateFormat("dd.MM.yyyy HH:mm").parse("08.10.2024 23:30");
|
|
Date d2 = new SimpleDateFormat("dd.MM.yyyy HH:mm").parse("11.10.2024 07:30");
|
|
```
|
|
|
|
Wenn du `calEin` und `calAus` setzt, dann wird:
|
|
- `calEin` auf den 8. Oktober 2024 um 23:30 Uhr gesetzt.
|
|
- `calAus` auf den 11. Oktober 2024 um 07:30 Uhr gesetzt.
|
|
|
|
**Zustand der Calendar-Objekte nach dem Setzen**:
|
|
- `calEin`: `08.10.2024 23:30`
|
|
- `calAus`: `11.10.2024 07:30`
|
|
|
|
#### Gebühren deklarieren:
|
|
|
|
```java
|
|
double gebuehrenTag = 0;
|
|
double gebuehrenNacht = 0;
|
|
```
|
|
- Diese Variablen werden verwendet, um die Gebühren für die Parkzeit zu speichern.
|
|
|
|
#### Gebührenberechnungsschleife:
|
|
|
|
```java
|
|
while (calEin.before(calAus) || calEin.equals(calAus)) {
|
|
int aktuelleStunde = calEin.get(Calendar.HOUR_OF_DAY);
|
|
```
|
|
|
|
**2. Schleife zur Berechnung der Gebühren**:
|
|
- `while (calEin.before(calAus) || calEin.equals(calAus))`:
|
|
- Diese Schleife wird so lange ausgeführt, wie `calEin` vor `calAus` ist oder gleich `calAus`. Das bedeutet, dass die Schleife für jede Stunde zwischen der Einfahrts- und Ausfahrtszeit läuft.
|
|
|
|
- `int aktuelleStunde = calEin.get(Calendar.HOUR_OF_DAY);`:
|
|
- Hier wird die aktuelle Stunde des Tages (0-23) aus dem `calEin`-Objekt abgerufen. Diese Information wird verwendet, um zu bestimmen, ob die Stunde in den Nacht- oder Tagzeitraum fällt und entsprechende Gebühren zu berechnen.
|
|
|
|
#### Beispiel der Schleife:
|
|
Angenommen, die Schleife läuft für die Stunden:
|
|
|
|
1. **Erste Iteration**:
|
|
- **calEin**: `08.10.2024 23:30`
|
|
- **Aktuelle Stunde**: 23 (Nachtgebühr)
|
|
- `gebuehrenNacht` wird um 1 Euro erhöht.
|
|
|
|
2. **Zweite Iteration**:
|
|
- **calEin**: `09.10.2024 00:30`
|
|
- **Aktuelle Stunde**: 0 (Nachtgebühr)
|
|
- `gebuehrenNacht` wird um 1 Euro erhöht.
|
|
|
|
3. **Dritte Iteration**:
|
|
- **calEin**: `09.10.2024 01:30`
|
|
- **Aktuelle Stunde**: 1 (Nachtgebühr)
|
|
- `gebuehrenNacht` wird um 1 Euro erhöht.
|
|
|
|
4. **Vierte Iteration**:
|
|
- **calEin**: `09.10.2024 02:30`
|
|
- **Aktuelle Stunde**: 2 (Nachtgebühr)
|
|
- `gebuehrenNacht` wird um 1 Euro erhöht.
|
|
|
|
5. **Fünfte Iteration**:
|
|
- **calEin**: `09.10.2024 03:30`
|
|
- **Aktuelle Stunde**: 3 (Nachtgebühr)
|
|
- `gebuehrenNacht` wird um 1 Euro erhöht.
|
|
|
|
6. **Sechste Iteration**:
|
|
- **calEin**: `09.10.2024 04:30`
|
|
- **Aktuelle Stunde**: 4 (Nachtgebühr)
|
|
- `gebuehrenNacht` wird um 1 Euro erhöht.
|
|
|
|
7. **Siebte Iteration**:
|
|
- **calEin**: `09.10.2024 05:30`
|
|
- **Aktuelle Stunde**: 5 (Nachtgebühr)
|
|
- `gebuehrenNacht` wird um 1 Euro erhöht.
|
|
|
|
8. **Achte Iteration**:
|
|
- **calEin**: `09.10.2024 06:30`
|
|
- **Aktuelle Stunde**: 6 (Taggebühr)
|
|
- Hier wird `gebuehrenNacht` auf 5 Euro gesetzt, und die Tagesgebührenberechnung beginnt.
|
|
|
|
### Fortschreiten der Zeit
|
|
Nach jeder Iteration wird `calEin` um eine Stunde erhöht:
|
|
|
|
```java
|
|
calEin.add(Calendar.HOUR_OF_DAY, 1);
|
|
```
|
|
|
|
- Dies sorgt dafür, dass in der nächsten Schleifeniteration die nächste Stunde bearbeitet wird.
|
|
|
|
### Beispiel für das Fortschreiten der Zeit:
|
|
Angenommen, `calEin` ist jetzt `09.10.2024 06:30`, nach dem `add()` wird es:
|
|
|
|
- **calEin**: `09.10.2024 07:30`
|
|
|
|
### Fazit
|
|
- Die `Calendar`-Klasse bietet eine leistungsstarke Möglichkeit, Datums- und Uhrzeitangaben zu verwalten.
|
|
- Mit `Calendar` kannst du leicht durch Zeitintervalle iterieren, Gebühren basierend auf der aktuellen Zeit berechnen und die Zeit manipulieren.
|
|
- Die Schleife und das Setzen von Zeit erlauben eine flexible Berechnung über Tage hinweg, wobei die Gebühren nach den festgelegten Regeln verarbeitet werden.
|
|
|
|
Wenn du weitere Fragen zur Verwendung von `Calendar` oder zu einem anderen Teil des Codes hast, lass es mich wissen! |