Menu
CoddyTech

Comodines (?, extends, super)

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy. Lección 57 de 87.

Los parámetros de tipo acotados restringen los genéricos a tipos específicos, pero ¿qué pasa cuando trabajas con tipos genéricos existentes y no sabes, o no te importa, cuál es el parámetro de tipo exacto? Aquí es donde entran en juego los comodines.

El comodín no acotado ? representa un tipo desconocido. Es útil cuando quieres aceptar cualquier tipo parametrizado:

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

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

El comodín con límite superior ? extends Type acepta el tipo especificado o cualquiera de sus subclases. Úsalo cuando necesites leer de una estructura genérica:

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

El comodín con límite inferior ? super Type acepta el tipo especificado o cualquiera de sus superclases. Úsalo cuando necesites escribir en una estructura genérica:

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

List<Number> numbers = new ArrayList<>();
addIntegers(numbers);  // Funciona: Number es un supertipo de Integer

Una pauta útil: usa extends cuando solo leas (productor) y usa super cuando solo escribas (consumidor). Esto se conoce como el principio PECS: Productor Extends, Consumidor Super.

challenge icon

Desafío

Fácil

¡Vamos a crear un sistema de alimentación para un zoológico que demuestre los tres tipos de comodines! Crearás una jerarquía de animales y alimentos y, después, escribirás métodos de utilidad que usan comodines sin límite, con límite superior y con límite inferior para gestionar distintos escenarios de alimentación.

Organizarás el código en cuatro archivos:

  • Food.java: Crea una jerarquía sencilla de clases para los alimentos. Empieza con una clase base Food que tenga un campo privado name (String), un constructor para inicializarlo y un método getName(). Después, crea dos subclases en el mismo archivo: Meat extiende Food (el constructor llama a super(name)) y Vegetable extiende Food (con el mismo patrón).
  • Animal.java: Crea una clase base Animal con un campo privado species (String), un constructor y un método getSpecies(). Crea dos subclases: Carnivore y Herbivore, cada una extendiendo Animal y llamando al constructor de la clase padre.
  • ZooFeeder.java: ¡Aquí es donde brillan los comodines! Crea una clase de utilidad con tres métodos estáticos:

    printInventory(List<?> items) - Usa un comodín sin límite para imprimir cualquier lista. Recorre la lista e imprime cada elemento usando toString(), uno por línea.

    calculateTotalFood(List<? extends Food> foods) - Usa un comodín con límite superior para leer de una lista de cualquier tipo de Food. Devuelve la cantidad de elementos como un int. Esto demuestra la lectura de un productor.

    addMeatToStock(List<? super Meat> stock, String meatName) - Usa un comodín con límite inferior para escribir en una lista que pueda contener Meat. Crea un objeto Meat nuevo con el nombre indicado y añádelo al inventario. Esto demuestra la escritura en un consumidor.

  • Main.java: ¡Reúne tu sistema de alimentación para el zoológico! Recibirás dos entradas: el nombre de una carne (String) y el nombre de una verdura (String).

    Primero, crea un ArrayList<Food> y añade un objeto Meat con el nombre de la carne y un objeto Vegetable con el nombre de la verdura. Imprime Food inventory: después llama a printInventory con esta lista.

    A continuación, imprime una línea en blanco y después imprime Total food items: [count] usando calculateTotalFood con tu lista de alimentos.

    Por último, crea un ArrayList<Food> nuevo llamado meatStock. Imprime una línea en blanco y después Adding to meat stock.... Llama a addMeatToStock con esta lista y la cadena "Beef". Después, imprime Meat stock after adding: y llama a printInventory con el inventario de carne.

Recibirás dos entradas en este orden: el nombre de una carne y el nombre de una verdura.

Sobrescribe toString() en tu clase Food para que devuelva el nombre del alimento y así la impresión funcione correctamente. Observa cómo cada tipo de comodín tiene un propósito distinto: ? para máxima flexibilidad cuando solo necesitas leer como Object, ? extends para leer tipos específicos y ? super para escribir en una colección.

Pruébalo tú mismo

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: Crea un ArrayList<Food> y añade objetos Meat y Vegetable
        
        // TODO: Imprime "Food inventory:" y luego llama a printInventory
        
        // TODO: Imprime una línea en blanco y luego "Total food items: [count]" usando calculateTotalFood
        
        // TODO: Crea un nuevo ArrayList<Food> llamado meatStock
        
        // TODO: Imprime una línea en blanco y luego "Adding to meat stock..."
        
        // TODO: Llama a addMeatToStock con meatStock y "Beef"
        
        // TODO: Imprime "Meat stock after adding:" y luego llama a printInventory con meatStock
    }
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de Java online