Menu
CoddyTech

Wildcards (?, extends, super)

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 57 sur 87.

Les paramètres de type bornés limitent les types génériques à des types spécifiques, mais que faire lorsque tu travailles avec des types génériques existants et que tu ne connais pas, ou que tu ne te soucies pas de connaître, le paramètre de type exact ? C’est là que les caractères génériques entrent en jeu.

Le joker non borné ? représente un type inconnu. Il est utile lorsque tu veux accepter n’importe quel type paramétré :

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

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

Le joker à borne supérieure ? extends Type accepte le type spécifié ou n’importe lequel de ses sous-types. Utilisez-le lorsque vous devez lire depuis une structure générique :

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 d'Integer
sumNumbers(Arrays.asList(1.5, 2.5));       // Liste de Double

Le joker avec borne inférieure ? super Type accepte le type spécifié ou l’une de ses superclasses. Utilise-le lorsque tu dois écrire dans une structure générique :

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

List<Number> numbers = new ArrayList<>();
addIntegers(numbers);  // Fonctionne - Number est un supertype de Integer

Une règle utile : utilise extends lorsque tu ne fais que lire (producteur), et super lorsque tu ne fais qu’écrire (consommateur). C’est ce qu’on appelle le principe PECS : producteur extends, consommateur super.

challenge icon

Défi

Facile

Construisons un système de nourrissage de zoo qui illustre les trois types de jokers ! Tu vas créer une hiérarchie d’animaux et d’aliments, puis écrire des méthodes utilitaires qui utilisent des jokers non bornés, à borne supérieure et à borne inférieure pour gérer différents scénarios de nourrissage.

Tu vas répartir ton code dans quatre fichiers :

  • Food.java : Crée une hiérarchie de classes simple pour les aliments. Commence par une classe de base Food qui possède un champ privé name (String), un constructeur pour l’initialiser et une méthode getName(). Crée ensuite deux sous-classes dans le même fichier : Meat étend Food (le constructeur appelle super(name)) et Vegetable étend Food (même principe).
  • Animal.java : Crée une classe de base Animal avec un champ privé species (String), un constructeur et une méthode getSpecies(). Crée deux sous-classes : Carnivore et Herbivore, qui étendent chacune Animal et appellent le constructeur parent.
  • ZooFeeder.java : C’est là que les jokers brillent ! Crée une classe utilitaire avec trois méthodes statiques :

    printInventory(List<?> items) - Utilise un joker non borné pour afficher n’importe quelle liste. Parcours la liste et affiche chaque élément avec toString(), un par ligne.

    calculateTotalFood(List<? extends Food> foods) - Utilise un joker à borne supérieure pour lire une liste contenant n’importe quel type de Food. Renvoie le nombre d’éléments sous forme d’int. Cela illustre la lecture depuis un producteur.

    addMeatToStock(List<? super Meat> stock, String meatName) - Utilise un joker à borne inférieure pour écrire dans une liste pouvant contenir Meat. Crée un nouvel objet Meat avec le nom donné et ajoute-le au stock. Cela illustre l’écriture vers un consommateur.

  • Main.java : Assemble ton système de nourrissage de zoo ! Tu recevras deux entrées : un nom de viande (String) et un nom de légume (String).

    Commence par créer un ArrayList<Food>, puis ajoute un objet Meat avec le nom de la viande et un objet Vegetable avec le nom du légume. Affiche Food inventory:, puis appelle printInventory avec cette liste.

    Ensuite, affiche une ligne vide, puis affiche Total food items: [count] en utilisant calculateTotalFood sur ta liste d’aliments.

    Enfin, crée un nouveau ArrayList<Food> appelé meatStock. Affiche une ligne vide, puis Adding to meat stock.... Appelle addMeatToStock avec cette liste et la chaîne "Beef". Affiche ensuite Meat stock after adding:, puis appelle printInventory sur le stock de viande.

Tu recevras deux entrées dans l’ordre : un nom de viande, puis un nom de légume.

Redéfinis toString() dans ta classe Food pour qu’elle renvoie le nom de l’aliment, afin que l’affichage fonctionne correctement. Remarque que chaque type de joker a un rôle différent : ? pour une flexibilité maximale lorsque tu as seulement besoin de lire des valeurs comme des Object, ? extends pour lire des types spécifiques et ? super pour écrire dans une collection !

Essayez vous-même

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: Créer une ArrayList<Food> et y ajouter des objets Meat et Vegetable
        
        // TODO: Afficher "Food inventory:", puis appeler printInventory
        
        // TODO: Afficher une ligne vide, puis "Total food items: [count]" en utilisant calculateTotalFood
        
        // TODO: Créer une nouvelle ArrayList<Food> appelée meatStock
        
        // TODO: Afficher une ligne vide, puis "Adding to meat stock..."
        
        // TODO: Appeler addMeatToStock avec meatStock et "Beef"
        
        // TODO: Afficher "Meat stock after adding:", puis appeler printInventory sur meatStock
    }
}
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Programmation Orientée Objet

Entraînez-vous par vous-même : Compilateur Java en ligne