Какие знаешь ограничения?

Ограничения типов в Java (Type Bounds)

Ограничения типов — это один из самых мощных механизмов в Java, позволяющих создавать гибкие и безопасные обобщённые типы (generics). Они ограничивают, какие типы можно использовать при параметризации класса или метода.

1. Верхнее ограничение (Upper Bound)

Extends ограничивает тип указанным классом или интерфейсом и его подклассами:

// Параметр T должен быть Number или его подклассом
public <T extends Number> void processNumber(T value) {
    System.out.println(value.doubleValue());
}

processNumber(5);      // Integer — OK
processNumber(5.5);    // Double — OK
processNumber("text"); // Ошибка компиляции

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

public <T extends Number & Comparable<T>> T findMax(List<T> list) {
    // T должен быть Number и реализовывать Comparable
    T max = list.get(0);
    for (T element : list) {
        if (element.compareTo(max) > 0) {
            max = element;
        }
    }
    return max;
}

Wildcard с верхним ограничением:

public void printNumbers(List<? extends Number> list) {
    for (Number n : list) {
        System.out.println(n);
    }
    // list.add(new Integer(5)); // Ошибка — нельзя добавлять
}

List<Integer> integers = Arrays.asList(1, 2, 3);
printNumbers(integers); // OK

2. Нижнее ограничение (Lower Bound)

Super ограничивает тип указанным классом и его суперклассами:

public void addNumbers(List<? super Integer> list) {
    // list может содержать Integer, Number, Object
    list.add(5);        // OK
    list.add(10);       // OK
}

List<Number> numbers = new ArrayList<>();
addNumbers(numbers); // OK

List<Object> objects = new ArrayList<>();
addNumbers(objects); // OK

Нижние ограничения используются для PECS правила: Producer Extends, Consumer Super

// Читаем данные (Producer) — используем extends
public void copy(List<? extends Number> source, List<Number> dest) {
    for (Number n : source) {
        dest.add(n);
    }
}

// Пишем данные (Consumer) — используем super
public void fill(List<? super Integer> list, int count) {
    for (int i = 0; i < count; i++) {
        list.add(i);
    }
}

3. Ограничения в классах

public class Repository<T extends Entity> {
    private List<T> items = new ArrayList<>();
    
    public void save(T entity) {
        entity.validate(); // Entity гарантирует наличие метода
        items.add(entity);
    }
    
    public List<T> findAll() {
        return new ArrayList<>(items);
    }
}

interface Entity {
    void validate();
}

class User implements Entity {
    @Override
    public void validate() {
        // Валидация пользователя
    }
}

Repository<User> userRepo = new Repository<>();

4. Рекурсивные ограничения

public class Node<T extends Comparable<T>> {
    private T value;
    private Node<T> next;
    
    public Node(T value) {
        this.value = value;
    }
    
    public boolean isGreater(T other) {
        return value.compareTo(other) > 0;
    }
}

Node<Integer> node = new Node<>(5);
System.out.println(node.isGreater(3)); // true

5. Ограничения на уровне массивов

public <T extends Number> void processArray(T[] array) {
    for (T element : array) {
        System.out.println(element.doubleValue());
    }
}

Integer[] integers = {1, 2, 3};
Double[] doubles = {1.5, 2.5};
processArray(integers);
processArray(doubles);

6. Wildcard без ограничений

public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
    // list.add(new Object()); // Ошибка компиляции
}

public int getSize(List<?> list) {
    return list.size(); // OK — не зависит от типа элементов
}

7. Практические примеры

Generic Stream с ограничением:

public class Numbers {
    public static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T number : numbers) {
            total += number.doubleValue();
        }
        return total;
    }
}

List<Integer> integers = Arrays.asList(1, 2, 3);
System.out.println(Numbers.sum(integers)); // 6.0

Ограничение для коллекций:

public <T extends Serializable & Cloneable> List<T> processItems(
    List<? extends T> items) {
    List<T> result = new ArrayList<>();
    for (T item : items) {
        result.add(item);
    }
    return result;
}

8. Частые ошибки

Ошибка: Использование конкретного типа вместо ограничения

// ❌ Неправильно
public <T> void process(List<T> items) {
    Number n = (Number) items.get(0); // Опасная типизация
}

// ✅ Правильно
public <T extends Number> void process(List<T> items) {
    Number n = items.get(0); // Безопасно
}

Заключение

Ограничения типов критичны для:

• Type Safety — предотвращения ошибок на этапе компиляции
• Переиспользуемости кода — создания гибких обобщённых решений
• Чёткости намерения — явного указания требований к типам

Правильное использование верхних и нижних ограничений, вместе с PECS правилом, делает код безопаснее и более поддерживаемым.