Генерики Java — стирание типов, наследование и принцип PECS

Опытные программисты знают, что жесткая привязка кода к определенным типам данных может стать серьезным затруднением при развитии проекта. Происходит это по ряду причин: сначала одни типы данных, потом другие, но нет возможности сделать такой универсальный метод, который работал бы с ними всеми. Для решения этой проблемы были разработаны так называемые обобщенные структуры данных.

Вводя описание своих обобщенных структур данных, мы задаем имена так называемым типовым параметрам, и так или иначе объявляем, что этот параметр может быть замещен любым другим типом данных.

После такого объявления компилятор сочтет, что наличие в коде конкретного типа данных из объявленного множества не имеет принципиального значения. Будет происходить своеобразная «замена» всех конкретных типов на некий универсальный тип (то есть, универсальный для заданного множества). Этот процесс принято называть стиранием типов.

Такое стирание влечет за собой ряд очень важных следствий. Во-первых, обобщенные структуры работают со всеми совместимыми типами, во-вторых, они отлично наследуются, а в-третьих, легко переобразуются в другие обобщенные структуры.

Справочник по универсальным классам Java

Этот справочник призван помочь участникам ознакомиться с универсальными классами, их преимуществами и особенностями.

Универсальные классы позволяют разработчикам создавать повторно используемые классы, в которых тип данных может быть параметризирован.

Универсальные классы в Java стираются во время компиляции, что означает, что информация о типе для универсальных параметров типов, указанная в исходном коде, удаляется из скомпилированного байт-кода.

Использование универсальных классов

Чтобы использовать универсальные классы, необходимо указать тип параметра при создании экземпляра класса.

Например, можно создать универсальный список строк, указав тип параметра <String> при создании экземпляра ArrayList.

Классы, содержащие универсальные методы, должны указывать тип параметра в сигнатуре метода.

Универсальные классы обеспечивают большую гибкость и более безопасное программирование, гарантируя, что типы данных используются согласованно во всем коде.

Таблица типов параметров

Тип параметра	Описание
<T>	Тип параметра без ограничений
<? extends T>	Тип параметра, являющийся подтипом T
<? super T>	Тип параметра, являющийся супертипом T

Стирание типов

Анализируя эту тему, нельзя обойти стороной фундаментальный принцип, который лежит в основе типовой системы.

Его суть сводится к преобразованию типов в нечто более простое и универсальное.

В процессе этого преобразования происходит удаление дополнительной информации.

Чтобы понять, что под этим подразумевается, рассмотрим пример.

Когда мы объявляем список с элементами определенного типа, например, List numbers, во время компиляции происходит его преобразование в List, где тип элемента не указывается.

Таким образом, компилятор производит очистку, убирая из списка информацию о типе элементов.

Этот процесс и получил название «стирание типов».

Последствия стирания типов

Последствия стирания типов
Упрощает код
Делает возможной работу с типовыми переменными
Позволяет реализовывать общие алгоритмы
Может привести к небезопасности
Требует внимательного проектирования кода

Наследование обобщенных классов и интерфейсов

Родство играет существенную роль в мире объектов и даёт им новые возможности. Обобщённые классы и интерфейсы тоже могут доводиться друг от друга!

Расширение и реализация обобщенного суперкласса и интерфейса

Если мы разрабатываем производный класс, наследующий от обобщённого родительского класса, мы можем указать свой собственный тип параметра. Этот дочерний тип должен быть совместим с типом параметра родительского класса, то есть либо его подтипом, либо тем же самым типом.

Аналогично, при реализации обобщённого интерфейса производный класс должен предоставить реализацию с тем же типом параметра или его подтипом.

Классовая иерархия и иерархия типов

Когда мы создаем иерархию обобщенных классов и интерфейсов, мы устанавливаем отношения не только между самими классами и интерфейсами, но и между их типами параметров.

Эта иерархия типов позволяет нам присваивать производные классы и интерфейсы переменным с более общими типами параметров. Это мощный инструмент для повышения гибкости и повторного использования кода.

Пример: Коробки с фруктами

Рассмотрим класс FruitBox, обобщенный по типу фруктов (Fruit). Мы можем создать класс AppleBox, наследуемый от FruitBox и обобщенный по типу яблока (Apple).

Это позволяет нам легко создавать коробки с яблоками и использовать их как коробки с фруктами, пользуясь преимуществами обоих классов в зависимости от ситуации.

Принцип PECS (Производитель Расширяет, Потребитель Сужает)

Бывают ситуации, когда требуется обеспечить безопасный обмен данными между двумя компонентами с разными типами обобщений. Принцип PECS поможет решить эту задачу, обеспечивая согласованность типов и предотвращая ошибки.

Поясним суть принципа.

Для производящего компонента, который создает или возвращает обобщенную коллекцию, расширяется тип обобщения.

Например, для метода, возвращающего список объектов класса Animal:

public List getAnimals() { ... }

Для потребляющего компонента, который обрабатывает обобщенную коллекцию, сужается тип обобщения.

Например, для метода, принимающего список объектов класса Animal и добавляющего в него объект Dog:

public void addDog(List dogs) { ... }

Таким образом, принцип PECS гарантирует, что производящий компонент не может добавить в коллекцию объекты несовместимого типа, а потребляющий компонент может безопасно обрабатывать подтипы указанного типа обобщения.

Отличия ковариантных и контравариантных типов

Ковариантные типы позволяют заменять подтип на его супертип, в то время как контравариантные типы позволяют заменять супертип на его подтип.

Рассмотрим пример класса ‘Коробка’, который может хранить значение любого типа.

Если мы определим класс ‘Коробка’ как ковариантный по отношению к типу ‘Значение’, то мы можем присвоить переменной типа ‘Коробка<Число>‘ переменную типа ‘Коробка<Целое>‘.

Это имеет смысл, потому что ‘Целое’ является подтипом ‘Числа’, и мы можем безопасно поместить ‘Целое’ в ‘Коробку<Число>‘.

С другой стороны, если мы определим класс ‘Коробка’ как контравариантный по отношению к типу ‘Значение’, то мы не сможем присвоить переменной типа ‘Коробка<Целое>‘ переменную типа ‘Коробка<Число>‘.

Это также имеет смысл, потому что ‘Число’ является супертипом ‘Целого’, и мы не можем безопасно поместить ‘Число’ в ‘Коробку<Целое>‘, так как ‘Число’ может содержать значение, которое не является целым числом.

Ковариантность коллекций

Коллекции «последовательного порядка», такие как List, Set и Queue, могут быть ковариантными.

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

Иными словами, Список подтипа может быть присвоен переменной Список супертипа без потери безопасности типов.

Например, Список собак можно присвоить переменной Список животных.

Это связано с тем, что Список собак может содержать только собак, которые являются подтипом животных.

Таким образом, ковариантность позволяет легко обрабатывать иерархии классов с использованием коллекций.

Контравариантность методов

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

Точно так же вы можете определить метод, который принимает в качестве параметра родительский тип и возвращает дочерний тип.

Это называется контравариантностью.

Взглянем на простую аналогию:

У вас есть коробка с карандашами. Коробка с карандашами – это родительский тип. Вы можете вставить в эту коробку любые карандаши, независимо от их типа.

Допустим, вы хотите получить карандаш из этой коробки. Вы можете извлечь из коробки любой карандаш, потому что все карандаши являются дочерними типами коробки с карандашами.

Это и есть контравариантность в действии.

Пример

Рассмотрим следующий код:

interface Контейнер<Т> {
void добавить(Т объект);
}
class КонтейнерКарандашей implements Контейнер<Карандаш> {
...
}
class КонтейнерРучек extends Контейнер<Ручка> {
...
}

В этом примере у нас есть интерфейс Контейнер, который может содержать объекты любого типа Т.

У нас также есть два класса, КонтейнерКарандашей и КонтейнерРучек, которые расширяют интерфейс Контейнер для конкретных типов Карандаш и Ручка соответственно.

Обратите внимание, что КонтейнерКарандашей и КонтейнерРучек являются контравариантными по отношению к своему параметру типа.

Это означает, что мы можем назначить КонтейнерКарандашей для переменной типа Контейнер<КанцелярскийПринадлежность>, потому что Карандаш является дочерним типом КанцелярскийПринадлежность.

И наоборот, мы не можем назначить КонтейнерРучек для переменной типа Контейнер<Карандаш>, потому что Карандаш не является дочерним типом Ручка.

Контравариантность	Определение
От родительского к дочернему	Конкретизация типа
Раскрытие конкретных деталей	Ограничение возможностей

Иерархия классов и обобщения

Обобщенные типы бывают полезны при работе с иерархиями классов. Они позволяют определять классы и интерфейсы, которые могут работать с различными типами данных, связанными друг с другом. Например, можно создать класс, который принимает параметр типа и использует его для хранения и обработки объектов указанного типа.

При использовании обобщений с иерархиями классов необходимо учитывать правила, определяющие, какие типы данных допустимы для использования в качестве параметров типа.

Правило подстановки для расширяющихся классов (PECs) определяет, что для типов, являющихся подклассами других типов, допускается использование более конкретных типов в качестве параметров типа. Например, если у вас есть класс, принимающий параметр типа Animal, вы можете использовать в качестве фактического параметра тип Cat, являющийся подклассом Animal.

Напротив, для типов, являющихся суперклассами других типов, допускается использование более общих типов в качестве параметров типа. Это связано с тем, что суперклассы могут представлять собой более широкий спектр объектов, чем их подклассы.

Правильное использование обобщений с иерархиями классов позволяет создавать гибкие и многоразовые классы и интерфейсы, которые могут обрабатывать различные типы данных, сохраняя при этом корректность и безопасность типов.

Граничные типы

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

Граничный тип – это тип, располагающийся наверху иерархии, с которым нельзя работать напрямую.

Зато с ним можно работать через производные типы.

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

Он отделяет общие действия от операций, зависящих от конкретных типов.

Это повышает надёжность и предсказуемость кода.

Шаблоны проектирования — общие подходы с помощью обобщений

Выразительные возможности обобщений помогают реализовать общеприменимые шаблоны проектирования. Применяя их к обобщенным классам и методам, разработчики могут создавать гибкие и многоразовые решения. Рассмотрим некоторые распространенные шаблоны проектирования в обобщенном контексте.

Шаблоны проектирования в обобщенном контексте

* Коллекции: Обобщенные коллекции, такие как списки и множества, позволяют хранить и обрабатывать данные различных типов.

* Адаптеры: Обобщенные адаптеры обеспечивают унифицированный интерфейс для взаимодействия с объектами разных типов.

* Фабричные методы: Обобщенные фабричные методы создают объекты определенного типа, используя общую логику, адаптируемую к различным подтипам.

* Стратегии: Обобщенные стратегии позволяют динамически переключать поведение алгоритмов, поддерживая связь между интерфейсами и реализациями.

* Наблюдатели: Обобщенные наблюдатели регистрируют наблюдатели и уведомляют их об изменениях в обобщенном состоянии.

Использование обобщений в шаблонах проектирования повышает абстракцию и гибкость программ, позволяя им эффективно обрабатывать широкий спектр типов данных и алгоритмов.

Неоспоримые преимущества универсализированных типов

С появлением обобщённых классов и методов, разработчикам стал доступен целый ряд indisputably безусловных преимуществ, которые несомненно повышают эффективность, надежность и прозрачность пишущегося кода.

Во-первых, внедрение обобщенных типов позволяет избежать ненужного дублирования кода. Например, вместо того, чтобы писать отдельные методы для работы с целыми числами, строками и другими типами данных, может быть создан единый обобщенный метод, который обрабатывает все типы данных.

Во-вторых, они улучшают безопасность типов — обобщенные классы и методы принудительно определяют тип данных, который они принимают, что значительно снижает вероятность возникновения ошибок во время выполнения.

В-третьих, обобщения повышают читаемость и понятность кода. Они делают его более кратким и позволяют разработчикам сосредоточиться на логике программы, не отвлекаясь на низкоуровневые детали.

Таким образом, обобщенные классы и методы не только экономят время разработки, но и повышают качество кода, делая его более надежным и гибким.

Ограничения и подводные камни

Использование обобщений (generics) имеет свои ограничения и подводные камни, которые необходимо учитывать.

Одним из ключевых ограничений является невозможность виртуального вызова методов.

Например, метод equals(), объявленный в классе Object, не может быть вызван виртуально для экземпляров обобщенного класса.

Это связано с тем, что при компиляции обобщенных классов информация о типе параметра стирается из байт-кода.

Еще одним ограничением является невозможность отражения параметризованных типов.

В частности, невозможно получить доступ к параметру типа в рантайме или использовать его для проверки типов.

Кроме того, необходимо быть осторожными при использовании условных операторов с обобщенными типами.

Если условие оператора возвращает значение разного типа для разных ветвей, это может привести к ошибке компиляции.

Вопрос-ответ:

Что такое стирание типов в Java-дженериках?

В дженериках Java типы данных определяются как параметр типа, например, `List`. Во время компиляции эти типы данных удаляются (стираются) и заменяются на Object. Это позволяет классу или методу работать с различными типами данных без необходимости писать отдельный код для каждого типа.

Как реализуется наследование с дженериками?

Дженерики могут наследоваться от других дженериков. При этом дочерний дженерик может ограничить типы данных, которые может принимать родительский дженерик, используя ключевое слово extends. Например, если родительский дженерик определен как `List`, то дочерний дженерик может быть определен как `List`.

Что такое принцип PECS?

Принцип PECS (Producer Extends Consumer Super) определяет, какие типы данных могут быть переданы в и получены из дженериков. Для производителей (методов, возвращающих дженерики) разрешены расширяющие типы данных (`extends`). Для потребителей (методов, принимающих дженерики) разрешены сужающие типы данных (`super`).

В чем разница между `List` и `List`?

`List` — это список строк. Он может содержать только строки. `List` — это список, который может содержать строки или их подтипы (например, `List