public class Schueler
{
    private List<Fehltag> fehltage;
 
    public Schueler()
    {
        this.fehltage = new List<Fehltag>();
    }
 
    public void AddFehltag(Fehltag f)
    {
        fehltage.Add(f);
    }
 
    public bool HatKritischGefehlt()
    {
        foreach (Fehltag f in fehltage)
        {
            if (f.IstEntschuldigt() == false && f.GetDatum() > DateTime.Now.AddMonths(-1))
            {
                return true;
            }
        }
        return false;
    }
}
 
public class Fehltag
{
    private DateTime datum;
    private bool entschuldigt;
 
    public Fehltag(DateTime d, bool e)
    {
        this.datum = d;
        this.entschuldigt = e;
    }
 
    public DateTime GetDatum()
    {
        return datum;
    }
 
    public bool IstEntschuldigt()
    {
        return entschuldigt;
    }
}

Dieses Level führt Datumslogik ein. Statt einfacher Zahlen oder Strings vergleichen wir jetzt DateTime-Werte – also Zeitpunkte. Die zentrale Frage lautet: Liegt ein gegebenes Datum innerhalb des letzten Monats?

public Fehltag(DateTime d, bool e)
{
    this.datum = d;
    this.entschuldigt = e;
}

Fehltag speichert zwei Informationen: wann gefehlt wurde (datum) und ob es entschuldigt war (entschuldigt). Beide werden über den Konstruktor gesetzt und sind über Getter-Methoden abrufbar – nichts strukturell Neues gegenüber den vorherigen Leveln.

Das Attribut entschuldigt ist vom Typ bool. Die Getter-Methode heißt hier IstEntschuldigt() statt GetEntschuldigt() – das ist die übliche Konvention für boolesche Getter und entspricht dem Abitur-Schema.

Die Methode soll true zurückgeben, sobald mindestens ein Fehltag beide Bedingungen erfüllt: nicht entschuldigt und im letzten Monat. Sobald ein solcher Fehltag gefunden wird, kann sofort abgebrochen werden.

DateTime.Now.AddMonths(-1)

DateTime.Now liefert den aktuellen Zeitpunkt. .AddMonths(-1) zieht davon einen Monat ab – das Ergebnis ist die Grenze, ab der ein Datum als „im letzten Monat" gilt.

Ein Fehltag liegt im letzten Monat, wenn sein Datum nach dieser Grenze liegt:

Grenze          Heute
   |              |
───┼──────────────┼───
   ↑
"letzter Monat" beginnt hier

Also: f.GetDatum() > DateTime.Now.AddMonths(-1) → das Datum liegt zwischen Grenze und heute → im letzten Monat.

if (f.IstEntschuldigt() == false && f.GetDatum() > DateTime.Now.AddMonths(-1))

Beide Teilbedingungen müssen gleichzeitig erfüllt sein (&&):

• f.IstEntschuldigt() == false – der Fehltag ist nicht entschuldigt
• f.GetDatum() > DateTime.Now.AddMonths(-1) – er liegt im letzten Monat

Ist einer der beiden Punkte nicht erfüllt, wird der Fehltag übersprungen.

Hinweis: f.IstEntschuldigt() == false lässt sich auch als !f.IstEntschuldigt() schreiben. Beide Formen sind korrekt – die ausgeschriebene Variante ist für den Einstieg leichter lesbar.

return true;

Sobald ein kritischer Fehltag gefunden wurde, gibt die Methode sofort true zurück – die Schleife wird nicht weiter durchlaufen. Das reicht aus, denn die Frage ist nur: Gibt es mindestens einen? – nicht: Wie viele gibt es?

Findet die Schleife keinen einzigen kritischen Fehltag, landet die Ausführung am Ende der Methode:

return false;

Im Abitur (Hessen) wird für Datumsoperationen die Java-Klasse LocalDate verwendet. In C# nutzen wir stattdessen DateTime. Die wichtigsten Entsprechungen:

In C# können DateTime-Werte direkt mit >, < und == verglichen werden – das ist einfacher als in Java, wo dafür eigene Methoden wie isAfter() nötig sind.