Является ли extend хорошей практикой в дженериках?

Является ли extend хорошей практикой в дженериках?

Ответ: ДА, extend является хорошей и даже необходимой практикой в дженериках, но только в правильном контексте. Ключевое слово extends (в контексте дженериков) используется для определения верхней границы типа (upper bounded wildcard) и имеет очень важное применение. Давайте разберемся в деталях.

Что такое extends в дженериках?

В контексте дженериков extends означает "тип T должен быть T или подтипом T". Это ОТЛИЧАЕТСЯ от наследования классов и используется для ограничения типов:

// Обобщение класса с ограничением
public class Container<T extends Number> {
    private T value;
    
    public Container(T value) {
        this.value = value;
    }
    
    // Можем использовать методы Number
    public double doubleValue() {
        return value.doubleValue();
    }
}

// Использование
Container<Integer> intContainer = new Container<>(42);  // OK
Container<Double> doubleContainer = new Container<>(3.14);  // OK
Container<String> stringContainer = new Container<>("test");  // Ошибка компиляции!

Wildcard с extends

Один из самых частых паттернов — использование wildcard с extends:

// Метод, который принимает список чисел (любых типов)
public void processNumbers(List<? extends Number> numbers) {
    for (Number num : numbers) {
        System.out.println(num.doubleValue());
    }
}

// Использование
List<Integer> integers = Arrays.asList(1, 2, 3);
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
List<Long> longs = Arrays.asList(100L, 200L, 300L);

processNumbers(integers);  // OK
processNumbers(doubles);   // OK
processNumbers(longs);     // OK

Без extends это было бы невозможно:

// ✗ Неправильно — принимает только List<Number>
public void badMethod(List<Number> numbers) {}

List<Integer> integers = Arrays.asList(1, 2, 3);
badMethod(integers);  // Ошибка! List<Integer> не является List<Number>

PECS правило: Producer Extends, Consumer Super

Это один из самых важных принципов использования дженериков. PECS означает:

• Producer Extends — если читаешь из структуры, используй extends
• Consumer Super — если пишешь в структуру, используй super

Producer (Extends) — читаем данные

// Читаем числа из списка
public double sum(List<? extends Number> numbers) {
    double total = 0;
    for (Number num : numbers) {
        total += num.doubleValue();  // Читаем данные
    }
    return total;
}

// Работает с Integer, Double, Long, etc.
sum(Arrays.asList(1, 2, 3));
sum(Arrays.asList(1.1, 2.2, 3.3));

Consumer (Super) — пишем данные

// Пишем Integer в список
public void fillIntegers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
    list.add(3);
}

// Работает с List<Integer>, List<Number>, List<Object>
List<Integer> integers = new ArrayList<>();
List<Number> numbers = new ArrayList<>();
List<Object> objects = new ArrayList<>();

fillIntegers(integers);  // OK
fillIntegers(numbers);   // OK
fillIntegers(objects);   // OK

Примеры хорошего использования extends

1. Collection копирование

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (T item : src) {
        dest.add(item);  // Пишем в dest
    }
}

// Использование
List<Integer> srcInts = Arrays.asList(1, 2, 3);
List<Number> destNums = new ArrayList<>();
copy(destNums, srcInts);  // OK

2. API для работы с иерархией типов

public interface Repository<T> {
    void save(T entity);
    List<? extends T> findAll();
}

public class UserRepository implements Repository<User> {
    @Override
    public void save(User user) {}
    
    @Override
    public List<? extends User> findAll() {
        return new ArrayList<>();
    }
}

public class AdminUserRepository implements Repository<AdminUser> {
    // AdminUser extends User
}

3. Обработка иерархии типов

public abstract class Animal {}
public class Dog extends Animal {}
public class Cat extends Animal {}

public void processAnimals(List<? extends Animal> animals) {
    for (Animal animal : animals) {
        System.out.println(animal.getClass().getSimpleName());
    }
}

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

processAnimals(dogs);    // OK
processAnimals(cats);    // OK
processAnimals(mixed);   // OK

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

// ✗ Плохо — слишком общо, теряем тип
public <T extends Object> void process(T value) {}
// Лучше просто:
public void process(Object value) {}

// ✗ Плохо — ограничение не нужно
public <T extends Serializable> List<T> getList() {}
// Если не используем Serializable методы, ограничение лишнее
public <T> List<T> getList() {}

Множественные ограничения

Дженерик может иметь несколько ограничений:

public <T extends Number & Comparable<T>> void process(T value) {
    System.out.println(value.doubleValue());  // Number
    System.out.println(value.compareTo(value));  // Comparable
}

process(42);        // Integer extends Number и Comparable
process(3.14);      // Double extends Number и Comparable
process("test");    // Ошибка! String не наследует Number

Реальный пример: Collections.sort()

// Из Java стандартной библиотеки
public static <T extends Comparable<? super T>> void sort(List<T> list) {
    // Сортирует список элементов, которые реализуют Comparable
}

// Использование
List<Integer> numbers = Arrays.asList(3, 1, 2);
sort(numbers);  // OK

List<String> strings = Arrays.asList("c", "a", "b");
sort(strings);  // OK

Ошибки при работе с extends

// ✗ Ошибка — не можем писать в структуру с extends
List<? extends Number> numbers = new ArrayList<>();
numbers.add(42);  // Ошибка компиляции!

// Почему? Компилятор не знает, это List<Integer>, List<Double> или List<Number>
// Поэтому не может безопасно добавить Integer

// ✓ Правильно — можем только читать
Number num = numbers.get(0);  // OK

Когда использовать extends (правила)

1. Когда нужна ковариантность — возвращаем подтипы
2. Когда используем методы базового класса — нужны гарантии
3. Когда читаем из структуры — используй extends
4. Когда хочешь принять подтипы — используй extends

Заключение

Да, использование extends в дженериках — это не просто хорошая практика, это необходимо для написания правильного, гибкого и безопасного кода. Главное — понимать PECS правило (Producer Extends, Consumer Super) и использовать ограничения типов где они имеют смысл. Правильное использование extends в дженериках делает API более гибким и позволяет работать с иерархиями типов без потери типобезопасности.