Menu
CoddyTech

Wildcards (?, extends, super)

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy. Lektion 57 von 87.

Begrenzte Typparameter schränken Generics auf bestimmte Typen ein. Was aber, wenn du mit vorhandenen generischen Typen arbeitest und den genauen Typparameter nicht kennst oder er dir egal ist? Hier kommen Wildcards ins Spiel.

Der unbeschränkte Platzhalter ? steht für einen unbekannten Typ. Er ist nützlich, wenn du einen beliebigen parametrisierten Typ akzeptieren möchtest:

public static void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

printList(new ArrayList<String>());   // Funktioniert
printList(new ArrayList<Integer>());  // Funktioniert

Der Wildcard-Typ mit oberer Schranke ? extends Type akzeptiert den angegebenen Typ oder eine seiner Unterklassen. Verwende ihn, wenn du aus einer generischen Struktur lesen musst:

public static double sumNumbers(List<? extends Number> numbers) {
    double sum = 0;
    for (Number n : numbers) {
        sum += n.doubleValue();
    }
    return sum;
}

sumNumbers(Arrays.asList(1, 2, 3));        // Liste von Integer-Werten
sumNumbers(Arrays.asList(1.5, 2.5));       // Liste von Double-Werten

Der nach unten begrenzte Platzhalter ? super Type akzeptiert den angegebenen Typ oder eine seiner Oberklassen. Verwende ihn, wenn du in eine generische Struktur schreiben musst:

public static void addIntegers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

List<Number> numbers = new ArrayList<>();
addIntegers(numbers);  // Funktioniert – Number ist ein Supertyp von Integer

Eine hilfreiche Faustregel: Verwende extends, wenn du nur liest (Produzent), und super, wenn du nur schreibst (Konsument). Das ist als PECS-Prinzip bekannt: Produzent Extends, Konsument Super.

challenge icon

Aufgabe

Einfach

Lass uns ein Zoo-Fütterungssystem entwickeln, das alle drei Arten von Wildcards veranschaulicht! Du erstellst eine Hierarchie von Tieren und Futter und schreibst anschließend Hilfsmethoden, die unbegrenzte, nach oben und nach unten begrenzte Wildcards verwenden, um verschiedene Fütterungsszenarien zu behandeln.

Du verteilst deinen Code auf vier Dateien:

  • Food.java: Erstelle eine einfache Klassenhierarchie für Futter. Beginne mit einer Basisklasse Food, die ein privates Feld name (String), einen Konstruktor zur Initialisierung und eine getName()-Methode hat. Erstelle anschließend zwei Unterklassen in derselben Datei: Meat extends Food (der Konstruktor ruft super(name) auf) und Vegetable extends Food (dasselbe Muster).
  • Animal.java: Erstelle eine Basisklasse Animal mit einem privaten Feld species (String), einem Konstruktor und einer getSpecies()-Methode. Erstelle zwei Unterklassen: Carnivore und Herbivore, die jeweils von Animal erben und den Konstruktor der übergeordneten Klasse aufrufen.
  • ZooFeeder.java: Hier kommen Wildcards zum Einsatz! Erstelle eine Hilfsklasse mit drei statischen Methoden:

    printInventory(List<?> items) – Verwendet eine unbegrenzte Wildcard, um eine beliebige Liste auszugeben. Durchlaufe die Liste und gib jedes Element mit toString() aus, eines pro Zeile.

    calculateTotalFood(List<? extends Food> foods) – Verwendet eine nach oben begrenzte Wildcard, um aus einer Liste mit einem beliebigen Food-Typ zu lesen. Gib die Anzahl der Elemente als int zurück. Das veranschaulicht das Lesen aus einem Produzenten.

    addMeatToStock(List<? super Meat> stock, String meatName) – Verwendet eine nach unten begrenzte Wildcard, um in eine Liste zu schreiben, die Meat enthalten kann. Erstelle ein neues Meat-Objekt mit dem angegebenen Namen und füge es dem Vorrat hinzu. Das veranschaulicht das Schreiben in einen Konsumenten.

  • Main.java: Führe dein Zoo-Fütterungssystem zusammen! Du erhältst zwei Eingaben: einen Fleischnamen (String) und einen Gemüsenamen (String).

    Erstelle zuerst eine ArrayList<Food> und füge ein Meat-Objekt mit dem Fleischnamen sowie ein Vegetable-Objekt mit dem Gemüsenamen hinzu. Gib Food inventory: aus und rufe dann printInventory mit dieser Liste auf.

    Gib als Nächstes eine Leerzeile und danach Total food items: [count] aus, indem du calculateTotalFood mit deiner Futterliste aufrufst.

    Erstelle schließlich eine neue ArrayList<Food> mit dem Namen meatStock. Gib eine Leerzeile und anschließend Adding to meat stock... aus. Rufe addMeatToStock mit dieser Liste und dem String "Beef" auf. Gib danach Meat stock after adding: aus und rufe printInventory für den Fleischvorrat auf.

Du erhältst der Reihe nach zwei Eingaben: einen Fleischnamen und einen Gemüsenamen.

Überschreibe toString() in deiner Food-Klasse, sodass die Methode den Namen des Futters zurückgibt und die Ausgabe korrekt funktioniert. Beachte, dass jeder Wildcard-Typ einem anderen Zweck dient: ? für maximale Flexibilität, wenn du lediglich als Object lesen musst, ? extends beim Lesen bestimmter Typen und ? super beim Schreiben in eine Sammlung!

Probier es selbst

import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String meatName = scanner.nextLine();
        String vegetableName = scanner.nextLine();
        
        // TODO: Erstelle eine ArrayList<Food> und füge Meat- und Vegetable-Objekte hinzu
        
        // TODO: Gib "Food inventory:" aus und rufe dann printInventory auf
        
        // TODO: Gib eine Leerzeile und dann "Total food items: [count]" mithilfe von calculateTotalFood aus
        
        // TODO: Erstelle eine neue ArrayList<Food> namens meatStock
        
        // TODO: Gib eine Leerzeile und dann "Adding to meat stock..." aus
        
        // TODO: Rufe addMeatToStock mit meatStock und "Beef" auf
        
        // TODO: Gib "Meat stock after adding:" aus und rufe dann printInventory für meatStock auf
    }
}
quiz iconTeste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Objektorientierte Programmierung

Übe selbstständig: Online-Java-Compiler