public class Schule
{
    private List<Lehrer> lehrerListe;
 
    public Schule()
    {
        this.lehrerListe = new List<Lehrer>();
    }
 
    public void AddLehrer(Lehrer l)
    {
        lehrerListe.Add(l);
    }
 
    public List<Lehrer> FindeVielBeschaeftigte()
    {
        List<Lehrer> ergebnis = new List<Lehrer>();
 
        foreach (Lehrer l in lehrerListe)
        {
            if (l.GetKlassen().Count > 2)
            {
                ergebnis.Add(l);
            }
        }
 
        return ergebnis;
    }
}
 
public class Lehrer
{
    private List<Klasse> klassen;
 
    public Lehrer()
    {
        this.klassen = new List<Klasse>();
    }
 
    public void AddKlasse(Klasse k)
    {
        klassen.Add(k);
    }
 
    public List<Klasse> GetKlassen()
    {
        return klassen;
    }
}
 
public class Klasse
{
    // Kann leer bleiben
}

In Level 11 hatte eine Klasse (Klasse) eine Liste von Objekten (Schueler). Hier geht es eine Ebene weiter: Schule hat eine Liste von Lehrer-Objekten, und jeder Lehrer hat wiederum seine eigene Liste von Klasse-Objekten.

Die Navigation folgt damit einer Kette:

Schule  →  List<Lehrer>  →  List<Klasse>

Um an die Klassen eines Lehrers zu gelangen, muss man also zwei Ebenen tief gehen: erst zum Lehrer, dann zu seiner Klassenliste.

public class Klasse
{
    // Kann leer bleiben
}

Klasse dient hier nur als Datenobjekt – sie hat keine eigene Logik und keine Attribute. Solche „leeren" Klassen tauchen im Abitur gelegentlich auf, wenn ein Typ nur als Platzhalter für eine Beziehung gebraucht wird. Wichtig ist, dass die Klasse trotzdem definiert wird, damit List<Klasse> kompiliert.

public Lehrer()
{
    this.klassen = new List<Klasse>();
}
 
public List<Klasse> GetKlassen()
{
    return klassen;
}

Lehrer folgt demselben Muster wie Klasse aus Level 11: eine Liste wird im Konstruktor initialisiert, AddKlasse() trägt Objekte ein, und GetKlassen() macht die Liste von außen lesbar.

GetKlassen() gibt dabei die interne Liste direkt zurück – das ist im Abitur der übliche Weg, auch wenn es bedeutet, dass der Aufrufer theoretisch die Liste verändern könnte.

public List<Lehrer> FindeVielBeschaeftigte()
{
    List<Lehrer> ergebnis = new List<Lehrer>();
 
    foreach (Lehrer l in lehrerListe)
    {
        if (l.GetKlassen().Count > 2)
        {
            ergebnis.Add(l);
        }
    }
 
    return ergebnis;
}

Das Muster ist dasselbe wie beim Filtern aus Sektion 2: eine neue Ergebnisliste aufbauen, alle Elemente durchlaufen, passende hinzufügen, Liste zurückgeben.

Der entscheidende Unterschied zu Level 11 ist die Bedingung:

l.GetKlassen().Count > 2

Hier wird direkt auf dem Rückgabewert von GetKlassen() die Eigenschaft .Count aufgerufen – in einem einzigen Ausdruck. Das entspricht dem Navigieren entlang der Kette: erst zum Lehrer, dann zu seiner Klassenliste, dann zur Anzahl der Einträge.

Man könnte das auch auf zwei Zeilen aufteilen:

List<Klasse> klassen = l.GetKlassen();
if (klassen.Count > 2) { ... }

Beide Varianten sind korrekt. Die einzeilige Form ist kompakter und entspricht eher dem, was man im Abitur sieht.

Die Aufgabe sagt „mehr als 2 Klassen". Das bedeutet: ab 3 Klassen aufwärts gilt ein Lehrer als viel beschäftigt. > 2 ist daher korrekt – >= 2 würde bereits Lehrer mit genau 2 Klassen einschließen, was zu viel wäre.

Auf solche kleinen Unterschiede zwischen > und >= wird im Abitur gezielt geachtet.