0Pricing
Java Academy · Lektion

Wildcards mit unterer Schranke

? super T für Konsumenten

Wildcards mit unterer Schranke ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Die Wildcard mit unterer Schranke

? super T ist eine Wildcard mit unterer Schranke. Das bedeutet: „ein unbekannter Typ, der T oder ein Obertyp von T ist“.

List<? super Integer> kann sich auf eine List<Integer>, eine List<Number> oder eine List<Object> beziehen.

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

public class Main {
    public static void main(String[] args) {
        List<? super Integer> a = new ArrayList<Number>();
        List<? super Integer> b = new ArrayList<Object>();
        a.add(1);
        b.add(2);
        System.out.println(a + " " + b);
    }
}

Schreiben in einen Konsumenten

Mit ? super Integer können Sie sicher jedes Integer (oder einen Untertyp von Integer) hinzufügen.

Unabhängig vom tatsächlichen Listentyp handelt es sich mindestens um eine Liste eines Obertyps von Integer, sodass ein Integer immer hineinpasst.

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

public class Main {
    static void addNumbers(List<? super Integer> dest) {
        for (int i = 1; i <= 3; i++) dest.add(i);
    }
    public static void main(String[] args) {
        List<Number> nums = new ArrayList<>();
        addNumbers(nums);
        System.out.println(nums);
    }
}

Beim Lesen erhalten Sie Object

Der Nachteil: Wenn Sie aus einer ? super T-Liste lesen, weiß der Compiler nur, dass die Elemente irgendein unbekannter Obertyp von T sind.

Der einzige sichere Typ für Lesezugriffe ist Object.

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

public class Main {
    public static void main(String[] args) {
        List<? super Integer> list = new ArrayList<Number>();
        list.add(10);
        Object o = list.get(0); // only Object is guaranteed
        // Integer i = list.get(0); // would NOT compile
        System.out.println(o);
    }
}

Warum das Lesen eingeschränkt ist

Eine List<? super Integer> könnte tatsächlich eine List<Object> sein, die Strings enthält.

Ein Lesezugriff könnte also jedes beliebige Object zurückgeben. Der Compiler kann kein Integer garantieren, daher liefern Lesezugriffe nur Object.

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

public class Main {
    public static void main(String[] args) {
        List<Object> raw = new ArrayList<>();
        raw.add("a string");
        List<? super Integer> view = raw; // legal: Object is a supertype of Integer
        view.add(5);
        System.out.println(view.get(0).getClass().getSimpleName());
    }
}

Anwendungsfall: Konsument

Verwenden Sie ? super T, wenn eine Methode Werte nur konsumiert, also in eine Sammlung schreibt.

Eine Methode, die eine Zielsammlung füllt, ist der klassische Fall.

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

public class Main {
    static void fill(List<? super String> dest, int count) {
        for (int i = 0; i < count; i++) dest.add("item" + i);
    }
    public static void main(String[] args) {
        List<Object> objs = new ArrayList<>();
        fill(objs, 3);
        System.out.println(objs);
    }
}

Auch das Hinzufügen von Untertypen funktioniert

Mit ? super Number können Sie jedes Number oder dessen Untertypen hinzufügen: Integer, Double und Long.

Die untere Schranke garantiert, dass die Liste mindestens Number akzeptiert, sodass alle Untertypen hineinpassen.

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

public class Main {
    public static void main(String[] args) {
        List<? super Number> list = new ArrayList<Object>();
        list.add(1);      // Integer
        list.add(2.5);    // Double
        list.add(3L);     // Long
        System.out.println(list);
    }
}

Collections.addAll-Variante

Das JDK verwendet untere Schranken für Senken. Ein Beispiel ist eine generische Methode, die Elemente in ein Ziel schreibt.

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

public class Main {
    @SafeVarargs
    static <T> void addAll(List<? super T> dest, T... items) {
        for (T item : items) dest.add(item);
    }
    public static void main(String[] args) {
        List<Object> sink = new ArrayList<>();
        addAll(sink, "a", "b", "c");
        System.out.println(sink);
    }
}

Comparator mit super

Ein Beispiel aus der Praxis: Comparator<? super T> ermöglicht es, beim Sortieren einen Comparator zu verwenden, der für einen Obertyp geschrieben wurde.

Ein Comparator, der beliebige Object anhand von toString vergleicht, kann eine Liste von Strings sortieren.

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Comparator<Object> byString = Comparator.comparing(Object::toString);
        List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));
        names.sort(byString); // List<String>.sort accepts Comparator<? super String>
        System.out.println(names);
    }
}

super und extends sind Spiegelbilder

Die beiden Wildcards sind Gegenstücke:

  • ? extends T: T lesen, nicht schreiben. Ein Produzent.
  • ? super T: T schreiben, nur Object lesen. Ein Konsument.

Diese Symmetrie bildet den Kern der PECS-Regel, die Sie als Nächstes kennenlernen.

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

public class Main {
    public static void main(String[] args) {
        List<? super Integer> consumer = new ArrayList<Number>();
        consumer.add(1);
        System.out.println("consumer can write: " + consumer);
    }
}

Kopieren zwischen Schranken

Eine Kopiermethode zeigt beide Wildcards gleichzeitig: Sie liest aus ? extends T und schreibt in ? super T.

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

public class Main {
    static <T> void copy(List<? extends T> src, List<? super T> dest) {
        for (T t : src) dest.add(t);
    }
    public static void main(String[] args) {
        List<Integer> src = List.of(1, 2, 3);
        List<Number> dest = new ArrayList<>();
        copy(src, dest);
        System.out.println(dest);
    }
}

Wann Sie keine Wildcard verwenden sollten

Wenn eine Methode T sowohl liest als auch schreibt, verwenden Sie keine Wildcard. Verwenden Sie stattdessen einen exakten Typ oder einen benannten Type-Parameter.

Wildcards sind genau für die Fälle mit ausschließlich lesendem oder ausschließlich schreibendem Zugriff gedacht.

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

public class Main {
    static <T> void swapFirstTwo(List<T> list) {
        T tmp = list.get(0);
        list.set(0, list.get(1));
        list.set(1, tmp);
    }
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));
        swapFirstTwo(list);
        System.out.println(list);
    }
}

Kurzer Test

Testen Sie Ihr Verständnis der unteren Schranken.

Zusammenfassung

Sie haben Wildcards mit unterer Schranke kennengelernt:

  • ? super T bedeutet ein unbekannter Obertyp von T.
  • Sie können T und dessen Untertypen schreiben (ein Konsument).
  • Lesezugriffe liefern nur Object.
  • Diese Wildcard ist das genaue Gegenstück zu ? extends T.

Als Nächstes folgt die Regel, die beide zusammenführt: PECS.

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

public class Main {
    public static void main(String[] args) {
        List<? super Integer> list = new ArrayList<Number>();
        list.add(42);
        System.out.println("Lower bound recap: " + list);
    }
}

Häufig gestellte Fragen

Ist die Lektion „Wildcards mit unterer Schranke“ kostenlos?

Ja — der vollständige Text von „Wildcards mit unterer Schranke“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Wildcards mit unterer Schranke“?

? super T für Konsumenten Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Wildcards mit unterer Schranke“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Wildcards mit oberer Schranke
  2. Wildcards mit unterer Schranke
  3. Das PECS-Prinzip
  4. Wildcards in APIs
← Zurück zu Java Academy