При помощи чего можно указать ограничение

При помощи чего можно указать ограничение

Введение в типизацию и ограничения

В Java ограничения на типовые параметры (type bounds) — это мощный механизм, который позволяет создавать гибкие и безопасные обобщённые типы. Без ограничений дженерики работают только с Object. Ограничения позволяют сузить диапазон допустимых типов и получить доступ к методам конкретного класса или интерфейса.

1. Ограничение сверху (Upper Bound) с extends

Это наиболее часто используемый вид ограничения. Тип должен быть подтипом указанного класса или реализовывать интерфейс:

// Ограничение на класс
public class Box<T extends Number> {
    private T value;
    
    public void printValue() {
        System.out.println(value.doubleValue()); // можем вызвать методы Number
    }
}

// Использование
Box<Integer> intBox = new Box<>();  // OK
Box<Double> doubleBox = new Box<>();  // OK
Box<String> stringBox = new Box<>();  // ОШИБКА: String не наследует Number

2. Ограничение на интерфейс

public class DataProcessor<T extends Serializable> {
    public void process(T data) {
        // T гарантированно Serializable
        // можно приводить типы, зная что T это Serializable
    }
}

// Использование
DataProcessor<String> processor = new DataProcessor<>();  // OK, String реализует Serializable

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

Тип может одновременно наследовать класс и реализовывать несколько интерфейсов:

// T должен наследить класс C и реализовать интерфейсы I1 и I2
public class Complex<T extends C & I1 & I2> {
    // T имеет все методы из C, I1 и I2
}

// Класс может быть только один (он идёт первым), интерфейсов может быть много
public class Service<T extends AbstractService & Comparable<T> & Serializable> {
    // ...
}

4. Wildcards (подстановочные символы)

Upper Bounded Wildcard (? extends Type)

// Можем читать элементы (они будут как минимум Type)
public void printList(List<? extends Number> list) {
    for (Number n : list) {
        System.out.println(n.doubleValue());
    }
}

// Использование
List<Integer> intList = Arrays.asList(1, 2, 3);
List<Double> doubleList = Arrays.asList(1.0, 2.0);
printList(intList);   // OK
printList(doubleList);  // OK

Lower Bounded Wildcard (? super Type)

// Можем добавлять элементы Type в список
public void addNumbers(List<? super Integer> list) {
    list.add(10);  // OK
    list.add(20);  // OK
}

// Использование
List<Integer> intList = new ArrayList<>();
List<Number> numberList = new ArrayList<>();
addNumbers(intList);    // OK
addNumbers(numberList);  // OK

5. Unbounded Wildcard (? без ограничения)

// Принимает List любого типа, но можем только читать как Object
public void printAnyList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

// Использование
List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
printAnyList(strings);   // OK
printAnyList(integers);  // OK

6. Ограничения на методах

// Типовой параметр ограничен в сигнатуре метода
public <T extends Comparable<T>> T findMax(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

// Использование
Integer maxInt = findMax(5, 10);  // OK
String maxStr = findMax("apple", "banana");  // OK
List<Integer> list = new ArrayList<>();  // ОШИБКА: List не реализует Comparable

7. Рекурсивные типовые ограничения (CRTP)

// Класс ограничен быть подтипом самого себя
public class Node<T extends Node<T>> {
    public T next() {
        return (T) this;  // безопасно вернуть себя как T
    }
}

public class SpecialNode extends Node<SpecialNode> {
    // SpecialNode ограничен быть Node<SpecialNode>
}

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

// Безопасная работа с коллекциями
public <T extends Comparable<T>> void sort(List<T> list) {
    Collections.sort(list);
}

// Фабричный метод
public <T> T create(Class<T> clazz) throws InstantiationException {
    return clazz.getDeclaredConstructor().newInstance();
}

// Ограничение для работы с Enum
public <E extends Enum<E>> String getEnumName(E enumValue) {
    return enumValue.name();
}

Сравнение разных подходов

Ключевые правила

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

Ограничения — это залог безопасности типов и выразительности API в Java.