Приведи пример использования PECS

PECS: Producer Extends, Consumer Super

PECS — один из самых полезных принципов при работе с generics wildcards в Java. Это правило помогает правильно выбирать между ? extends и ? super для достижения максимальной гибкости и типобезопасности.

Суть принципа

• Producer Extends — если вы читаете данные из коллекции (она "производит" элементы), используйте ? extends T
• Consumer Super — если вы пишете данные в коллекцию (она "потребляет" элементы), используйте ? super T

Практический пример: обработка коллекции животных

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

class AnimalProcessor {
    
    // НЕПРАВИЛЬНО: слишком ограничивающе
    public static void printAnimals(List<Animal> animals) {
        for (Animal animal : animals) {
            System.out.println(animal);
        }
    }
    
    // ПРАВИЛЬНО: Producer Extends
    // Коллекция ПРОИЗВОДИТ элементы (мы их читаем)
    public static void printAnimals(List<? extends Animal> animals) {
        for (Animal animal : animals) {
            System.out.println(animal);
        }
    }
}

public static void main(String[] args) {
    List<Dog> dogs = Arrays.asList(new Dog(), new Dog());
    List<Cat> cats = Arrays.asList(new Cat(), new Cat());
    
    // С extends это работает, без него — компилируется ошибка
    AnimalProcessor.printAnimals(dogs);
    AnimalProcessor.printAnimals(cats);
}

Producer Extends — детально

Используется когда вы извлекаете данные из коллекции:

public class Collection {
    
    // Копируем всех животных из source в destination
    public static void copyAnimals(
        List<? extends Animal> source,  // ЧИТАЕМ отсюда
        List<Animal> destination        // ПИШЕМ сюда
    ) {
        for (Animal animal : source) {
            destination.add(animal);
        }
    }
}

// Использование
List<Dog> dogSource = new ArrayList<>();
List<Cat> catSource = new ArrayList<>();
List<Animal> allAnimals = new ArrayList<>();

Collection.copyAnimals(dogSource, allAnimals);  // ✓ Работает
Collection.copyAnimals(catSource, allAnimals);  // ✓ Работает

Почему это работает? Компилятор знает, что source содержит животных (любых), поэтому безопасно читать их как Animal.

Что НЕ работает:

List<? extends Animal> animals = new ArrayList<Dog>();
animals.add(new Dog());      // ❌ Ошибка компиляции!
animals.add(new Animal());   // ❌ Ошибка компиляции!

// Почему? Потому что животных может быть List<Cat>, 
// и мы не должны добавлять туда Dog

Consumer Super — детально

Используется когда вы добавляете данные в коллекцию:

public class Shelter {
    
    // Добавляем животных в укрытие
    public static void addAnimals(
        List<Animal> source,           // ЧИТАЕМ отсюда
        List<? super Dog> shelter      // ПИШЕМ сюда (для собак и их родителей)
    ) {
        for (Animal animal : source) {
            if (animal instanceof Dog) {
                shelter.add((Dog) animal);
            }
        }
    }
}

List<Dog> dogs = new ArrayList<>();
List<Animal> animalShelter = new ArrayList<>();
List<Object> objectShelter = new ArrayList<>();

Shelter.addAnimals(dogs, dogs);               // ✓ Собаки в приют для собак
Shelter.addAnimals(dogs, animalShelter);      // ✓ Собаки в приют для животных
Shelter.addAnimals(dogs, objectShelter);      // ✓ Собаки в универсальный приют

Почему это работает? Компилятор знает, что shelter может принимать Dog (или их родителей), поэтому безопасно писать туда собак.

Классический пример: Collections.copy

Java использует PECS в своей стандартной библиотеке:

// Реальная сигнатура из Collections
public static <T> void copy(
    List<? super T> dest,      // CONSUMER (пишем сюда)
    List<? extends T> src      // PRODUCER (читаем отсюда)
)

// Использование
List<Animal> animals = new ArrayList<>();
List<Dog> dogs = Arrays.asList(new Dog(), new Dog());
List<Object> objects = new ArrayList<>();

Collections.copy(animals, dogs);   // ✓ Копируем собак в животных
Collections.copy(objects, dogs);   // ✓ Копируем собак в объекты

Пример из реальной практики: Service

public interface AnimalService {
    
    // API для получения животных (Producer Extends)
    List<? extends Animal> getAllAnimals();
    
    // API для сохранения животных (Consumer Super)
    void saveAnimals(List<? super Animal> animalsToSave);
    
    // Комбинированный метод обработки
    void processAnimals(
        List<? extends Animal> source,    // Читаем
        List<? super Animal> destination  // Пишем
    ) {
        for (Animal animal : source) {
            // Какая-то обработка
            destination.add(animal);
        }
    }
}

Когда НЕ использовать wildcards

// НЕПРАВИЛЬНО: слишком универсально, теряет информацию
public List<? extends Object> getData() { ... }

// ПРАВИЛЬНО: конкретный тип
public List<String> getData() { ... }

Wildcards нужны когда вы работаете с коллекциями, которые вы не создаёте, а получаете как параметры.

Итог

PECS помогает выбрать правильный wildcard:

• ? extends — для источников данных (читаем)
• ? super — для приёмников данных (пишем)

Это делает API более гибким и типобезопасным одновременно, позволяя работать с иерархиями типов без потери безопасности.