Что такое принцип PECS в Java?
Напишите метод static double sum(List<Number> list) и передайте в него List<Integer> — компилятор откажет: List<Integer> cannot be converted to List<Number>. Хотя Integer — наследник Number, список целых чисел не является списком чисел. Чинится это одной строкой: List<? extends Number>. Когда писать extends, а когда super, и отвечает принцип PECS.
Принцип PECS (Producer Extends, Consumer Super) — правило выбора границы wildcard для параметра обобщённого типа в Java. Если параметр — производитель (источник данных), из которого метод только читает элементы типа T, объявляйте его как <? extends T>. Если параметр — потребитель (приёмник), в который метод только записывает T, — как <? super T>. Если метод и читает, и пишет — нужен точный тип T без wildcard. Название ввёл Джошуа Блох в книге «Effective Java» (3-е издание, Item 31).
Что такое PECS: extends и super в одной таблице
PECS расшифровывается как Producer Extends, Consumer Super: коллекция, из которой метод берёт элементы, объявляется с ? extends T, а коллекция, в которую метод кладёт элементы, — с ? super T. Граница wildcard определяет сразу две вещи: какие коллекции можно передать в метод и что с ними можно делать внутри.
Сводная таблица для иерархии Person ← Employee ← Manager (она используется во всех примерах урока):
| Объявление параметра | Какие списки можно передать | Что вернёт get() | Что можно add() | Роль |
|---|---|---|---|---|
List<Employee> | Только List<Employee> | Employee | Employee, Manager, null | Читает и пишет |
List<? extends Employee> | List<Employee>, List<Manager> | Employee | Только null | Producer (источник) |
List<? super Employee> | List<Employee>, List<Person>, List<Object> | Object | Employee, Manager, null | Consumer (приёмник) |
List<?> | Любой список | Object | Только null | Чтение как Object |
Короткое правило: достаёте — extends, кладёте — super, делаете и то и другое — без wildcard.
Как определить роль параметра
Смотрите не на тип коллекции, а на то, что метод делает с параметром. Тот же принцип в книге Нафталина и Вадлера «Java Generics and Collections» называется Get and Put Principle. Он работает не только для коллекций: Comparator<T> принимает объекты в метод compare(), то есть потребляет их, поэтому в JDK его объявляют как Comparator<? super T>.
Три вида wildcard и иерархия для примеров
Wildcard (метасимвол) — это вопросительный знак в угловых скобках, который означает «какой-то неизвестный тип». В Java есть три формы: неограниченный <?>, ограниченный сверху <? extends T> и ограниченный снизу <? super T>. PECS отвечает на вопрос, какую из двух ограниченных форм выбрать.
List<?> anyList = ...; // unbounded wildcard
List<? extends Employee> employees = ...; // upper bounded wildcard
List<? super Employee> staff = ...; // lower bounded wildcard Все примеры урока используют простую иерархию: Employee наследует Person, а Manager наследует Employee.

class Person {}
class Employee extends Person {}
class Manager extends Employee {} <? extends Employee>— upper bounded wildcard:Employee— верхняя граница, подходятEmployeeи все его наследники (Manager).Personвыше границы и не подходит.<? super Employee>— lower bounded wildcard:Employee— нижняя граница, подходятEmployeeи все его предки (Person,Object).Managerниже границы и не подходит.
Зачем вообще нужна типизация коллекций и чем опасны коллекции без параметра (raw types), разобрано в уроке Коллекции в Java, а общая теория обобщений — в уроке Дженерики в Java.
Producer: <? extends T> — только чтение
Параметр с <? extends T> — производитель: метод может читать из него элементы как T, но не может добавлять в него ничего, кроме null. Зато такой метод принимает коллекцию T и коллекцию любого наследника T.
public static void processUpperBounded(List<? extends Employee> employees) {
employees.add(new Employee()); // ошибка компиляции
employees.add(null); // компилируется
Employee employee = employees.get(0); // чтение как Employee — можно
} Строка с add(new Employee()) не скомпилируется с сообщением incompatible types: Employee cannot be converted to CAP#1. CAP#1 — так компилятор называет «неизвестный подтип Employee»: за параметром может стоять List<Manager>, и обычный Employee в него класть нельзя. null подходит к любому ссылочному типу, поэтому его добавить можно.
Какие коллекции можно передать в такой метод:
List<Person> persons = new ArrayList<>();
List<Employee> employees = new ArrayList<>();
List<Manager> managers = new ArrayList<>();
processUpperBounded(persons); // ошибка компиляции: Person выше границы
processUpperBounded(employees); // OK
processUpperBounded(managers); // OK Практический пример — среднее арифметическое для списка любых чисел. Без wildcard пришлось бы писать отдельные методы для List<Integer> и List<Double>. Метод только читает элементы, значит список — producer, и достаточно List<? extends Number>:
import java.util.List;
public class AverageDemo {
public static double getAverage(List<? extends Number> list) {
double sum = 0;
for (Number n : list) {
sum += n.doubleValue();
}
return sum / list.size();
}
public static void main(String[] args) {
List<Integer> iList = List.of(1, 5, 8, 9);
List<Double> dList = List.of(1.5, 2.5, 3.5, 4.5);
System.out.println(getAverage(iList)); // Вывод: 5.75
System.out.println(getAverage(dList)); // Вывод: 3.0
System.out.println(getAverage(List.of())); // Вывод: NaN
}
} Для пустого списка исключения нет: 0.0 / 0 в арифметике double даёт NaN. Если такой результат не подходит, проверьте list.isEmpty() заранее.
Consumer: <? super T> — только запись
Параметр с <? super T> — потребитель: метод может записывать в него объекты типа T и его наследников, а прочитать элемент может только как Object. Такой метод принимает коллекцию T и коллекцию любого предка T.
public static void processLowerBounded(List<? super Employee> employees) {
employees.add(new Person()); // ошибка компиляции
employees.add(new Employee()); // OK
employees.add(new Manager()); // OK
Object first = employees.get(0); // чтение возможно только как Object
if (first instanceof Employee e) { // проверка типа и приведение (Java 16+)
System.out.println("Это Employee: " + e);
}
Employee employee = employees.get(0); // ошибка компиляции
} Какие коллекции можно передать в такой метод:
processLowerBounded(persons); // OK
processLowerBounded(employees); // OK
processLowerBounded(managers); // ошибка компиляции: Manager ниже границы Последняя строка метода не компилируется, потому что за параметром может стоять List<Object>: гарантированно известно только, что элемент — Object. Чтение из consumer технически возможно, но бесполезно без проверки instanceof — поэтому такой параметр и называют приёмником, а не источником.
Почему List<Person> передать можно, а Person добавить нельзя
Граница ? super Employee одновременно разрешает передать List<Person> и запрещает add(new Person()). Это не исключение из PECS, а два следствия одного правила: компилятор допускает только операции, безопасные для любого списка, который может оказаться за параметром.
За List<? super Employee> во время выполнения может стоять List<Employee>, List<Person> или List<Object>. Проверим, что безопасно для всех трёх:
add(new Manager())иadd(new Employee())— объект является иEmployee, иPerson, иObject, поэтому подходит к любому из трёх списков.add(new Person())— вList<Person>подошёл бы, но если на самом деле переданList<Employee>, туда попал бы объект, который не являетсяEmployee. Компилятор не знает, какой список передан, и запрещает операцию.
Та же логика работает при присваивании переменных: граница ограничивает, какую коллекцию можно присвоить, а не только какую передать в метод.
List<? extends Employee> list1 = employees; // OK
List<? extends Employee> list2 = managers; // OK
List<? super Employee> list3 = persons; // OK
List<? super Employee> list4 = managers; // ошибка компиляции PECS в своём методе
Когда метод переносит данные из одной коллекции в другую, PECS применяется к каждому параметру отдельно: источник получает extends, приёмник — super. Так метод принимает максимум сочетаний типов и остаётся типобезопасным.
import java.util.ArrayList;
import java.util.List;
public class HireDemo {
static class Person {}
static class Employee extends Person {}
static class Manager extends Employee {}
// candidates — producer, staff — consumer
static void hireAll(List<? extends Employee> candidates, List<? super Employee> staff) {
for (Employee e : candidates) {
staff.add(e);
}
}
public static void main(String[] args) {
List<Manager> managers = List.of(new Manager(), new Manager());
List<Person> persons = new ArrayList<>();
hireAll(managers, persons);
System.out.println(persons.size()); // Вывод: 2
}
} Если объявить оба параметра как List<Employee>, вызов hireAll(managers, persons) не скомпилируется ни по первому, ни по второму аргументу.
PECS в стандартной библиотеке
Принцип PECS виден в сигнатурах JDK: все методы класса Collections и интерфейсов коллекций, которые читают из одного параметра и пишут в другой, объявлены по этому правилу. Если не помните, где ставить extends, а где super, — посмотрите на эти сигнатуры.
| Метод | Сигнатура | Кто producer, кто consumer |
|---|---|---|
Collections.copy | <T> void copy(List<? super T> dest, List<? extends T> src) | src — producer, dest — consumer |
Collections.addAll | <T> boolean addAll(Collection<? super T> c, T... elements) | c — consumer |
Collection.addAll | boolean addAll(Collection<? extends E> c) | Аргумент — producer |
List.sort | void sort(Comparator<? super E> c) | Компаратор — consumer элементов |
Collections.max | <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) | Коллекция — producer, компаратор — consumer |
Что выведет этот код?
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class PecsJdkDemo {
public static void main(String[] args) {
// copy: src = List<Integer> (producer), dest = List<Number> (consumer)
List<Integer> ints = List.of(3, 1, 2);
List<Number> numbers = new ArrayList<>(List.of(0, 0, 0, 0.5));
Collections.copy(numbers, ints);
System.out.println(numbers);
// addAll: строки кладутся в List<Object>
List<Object> objects = new ArrayList<>();
Collections.addAll(objects, "a", "b");
System.out.println(objects);
// sort: Comparator<Object> подходит для List<Integer>
Comparator<Object> byString = Comparator.comparing(Object::toString);
List<Integer> list = new ArrayList<>(List.of(10, 9, 100));
list.sort(byString);
System.out.println(list);
// copy в пустой список
Collections.copy(new ArrayList<Integer>(), ints);
}
} [3, 1, 2, 0.5]
[a, b]
[10, 100, 9]
Exception in thread "main" java.lang.IndexOutOfBoundsException: Source does not fit in dest Разбор: Collections.copy перезаписывает первые элементы dest, а хвост (0.5) оставляет. Список Integer отсортирован как строки, поэтому "100" стоит раньше "9" — один компаратор для Object работает с любым списком благодаря ? super E. Последний вызов падает: copy не увеличивает список-приёмник, размер dest должен быть не меньше размера src. Для копирования в пустой список используйте dest.addAll(src) или new ArrayList<>(src).
Остальные методы класса Collections описаны в уроке Методы класса Collections, а работа с компараторами — в уроке Comparable и Comparator.
get(0) или getFirst()
В примерах используется list.get(0). Метод getFirst() появился у List только в Java 21 (интерфейс SequencedCollection), и на Java 17 код с ним не скомпилируется. Правила PECS при этом одинаковы: getFirst() у List<? extends Employee> вернёт Employee, а у List<? super Employee> — Object.
На чём чаще всего ошибаются
Типичные промахи с PECS связаны с тем, что wildcard ставят по привычке, а не по роли параметра, или ожидают от него большего, чем он гарантирует. Ниже — ошибки, которые чаще всего встречаются в коде и на собеседованиях.
| Ошибка | Что происходит | Как правильно |
|---|---|---|
Ожидать, что List<Manager> — подтип List<Employee> | Обобщённые типы инвариантны: передача не компилируется | Параметр-источник объявить как List<? extends Employee> |
Добавлять в List<? extends T> | incompatible types: ... cannot be converted to CAP#1 | Если метод пишет в коллекцию — ? super T или точный T |
Считать ? extends защитой от изменений | remove(), clear(), add(null) работают | Для неизменяемости — List.copyOf() или Collections.unmodifiableList() |
Читать из List<? super T> как T | Ошибка компиляции: элемент имеет тип Object | Если нужно и читать как T, и писать — точный тип List<T> |
Wildcard в возвращаемом типе: List<? extends Number> load() | Вызывающий код не может ничего добавить в результат и вынужден сам разбираться с wildcard | Wildcard — только в параметрах; возвращать List<Number> или List<T> |
Выводы
Принцип PECS сводится к одному вопросу о каждом параметре метода: метод из него читает или в него пишет. Ответ определяет границу wildcard.
- Producer (параметр-источник, метод только читает) —
<? extends T>: принимает коллекцииTи наследников, чтение какT, запись — толькоnull. - Consumer (параметр-приёмник, метод только пишет) —
<? super T>: принимает коллекцииTи предков, записьTи наследников, чтение — только какObject. - Метод и читает, и пишет — точный тип
Tбез wildcard. - Wildcard используют в параметрах методов, а не в возвращаемых типах.
- Одна граница одновременно ограничивает, какую коллекцию можно передать или присвоить, и какие операции доступны внутри, — это не два разных правила.
Часто задаваемые вопросы
Чем List<?> отличается от List<Object>?
В параметр List<?> можно передать список любого типа: List<String>, List<Integer>, но добавить в него можно только null. В List<Object> можно добавлять что угодно, зато передать туда List<String> нельзя — это другой тип. List<?> подходит для методов, которым тип элементов не важен: size(), clear(), печать.
Как PECS связан с ковариантностью и контравариантностью?
? extends T делает тип ковариантным (List<Manager> подходит туда, где ждут List<? extends Employee>), а ? super T — контравариантным. Массивы в Java ковариантны всегда, и за это платят ошибкой во время выполнения: Object[] arr = new String[1]; arr[0] = 1; бросает ArrayStoreException. Обобщённые типы по умолчанию инвариантны, и PECS позволяет получить гибкость без таких исключений.
Можно ли указать extends и super в одном wildcard?
Нет: у wildcard только одна граница, <? extends A super B> не компилируется, как и <? extends A & B>. Несколько верхних границ допустимы только у параметра типа: <T extends Number & Comparable<T>>. А super у параметра типа, наоборот, запрещён — <T super Integer> не скомпилируется.
Почему Collections.copy() не работает с пустым списком-приёмником?
PECS отвечает только за типы, а не за размер. Collections.copy(dest, src) заменяет элементы dest по индексам и не добавляет новые, поэтому при dest.size() < src.size() бросает IndexOutOfBoundsException: Source does not fit in dest. Пример с выводом — в разделе PECS в стандартной библиотеке.
Видео объяснение
Предпочитаете видеоформат? Посмотрите этот урок с примерами и объяснениями.
Комментарии