Коллекции ·
‹ Предыдущий Следующий ›
⏱ 5 минут чтения Обновлено: 2026-10-27

Что такое принцип 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.

Иерархия классов для примеров PECS: Person, Employee extends Person, Manager extends 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.

  1. Producer (параметр-источник, метод только читает) — <? extends T>: принимает коллекции T и наследников, чтение как T, запись — только null.
  2. Consumer (параметр-приёмник, метод только пишет) — <? super T>: принимает коллекции T и предков, запись T и наследников, чтение — только как Object.
  3. Метод и читает, и пишет — точный тип T без wildcard.
  4. Wildcard используют в параметрах методов, а не в возвращаемых типах.
  5. Одна граница одновременно ограничивает, какую коллекцию можно передать или присвоить, и какие операции доступны внутри, — это не два разных правила.

Часто задаваемые вопросы

Чем 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 в стандартной библиотеке.

Видео объяснение

Предпочитаете видеоформат? Посмотрите этот урок с примерами и объяснениями.

Комментарии

Зарегистрируйтесь или войдите, чтобы иметь возможность оставить комментарий.