Параметрический полиморфизм - возможность использовать один и тот же код с разными типами данных, не меняя его логику. В Java это реализовано через дженерики, позволяющие передавать тип данных (например, String или Integer) в качестве параметра для классов, интерфейсов и методов.
// Один класс SimpleObject<T> работает с любым типом
SimpleObject<String> stringObj = new StringObject();
SimpleObject<Integer> intObj = new IntegerObject();
// P.S. Да, в задачке "Параметризованный интерфейс"
// внутри переопределённого метода SimpleObject<String>
// возвращаем новый объект StringObject, который реализует этот интерфейс
Ключевая идея: код работает с типами как с параметрами - вы указываете, с каким типом будет работать код, когда его используете.
Аналогия из жизни. Представьте коробку для вещей:
• Коробка для книг - хранит только книги
• Коробка для игрушек - хранит только игрушки
• Коробка для инструментов - хранит только инструменты
Но сама коробка универсальная - ее форма и функции одинаковы, меняется только содержимое.
// Один класс Box<T> работает с любым типом
Box<Book> bookBox = new Box<>();
Box<Toy> toyBox = new Box<>();
Box<Tool> toolBox = new Box<>();
С точки зрения компилятора подобная практика приводит к «стиранию типов»: компилятор проверяет типы, а потом стирает их в байт-коде. Таким образом ошибка находится сразу на этапе компиляции.
Box<String> box = new Box<>(); // "Я хочу коробку для строк!"
// Компилятор думает:
// "Ага, сейчас я проверю, что ты везде правильно используешь строки (в ином случае я выведу ошибку)"
// "А потом в байт-коде я просто напишу: Box box = new Box();"
// "И всё! Без всяких <String>"
Главный пример параметрического полиморфизма - коллекции Java
List<String> names = new ArrayList<>();
List<Integer> scores = new ArrayList<>();
List<User> users = new ArrayList<>();
Map<String, Integer> nameToScore = new HashMap<>();
Map<Integer, String> idToName = new HashMap<>();
Map<User, List<String>> userToHobbies = new HashMap<>();
Преимущества параметрического полиморфизма:
• Типобезопасность: не допускаем ненужные или опасные операции с данными разных типов
• Нет кастов: в коде теперь не обязательно приводить один тип данных к другому типу данных
• Один код - много типов: можем работать с разными типами без изменения исходного кода
Ограничения параметрического полиморфизма:
• Нельзя создать массив обобщённого типа
• Нельзя использовать примитивы
T[] array = new T[10]; // Ошибка! Используем конкретный тип
Box<int> intBox; // Ошибка! Используйте Box<Integer>
Однако можно использовать ограничения типа данных через ключевое слово extends:
class NumberBox<T extends Number> { // Работаем только с числами
private T number;
}
Более того существуют инструменты, позволяющие упростить работу с типами данных:
• ? (Wildcard) - неизвестный тип. Используется, когда мы не знаем точно, с каким типом будет работать метод, но хотим сделать его универсальным. Предназначен только для чтения, когда нам доступны лишь методы класса Object, а конкретный тип данных не важен.
public void printList(List<?> list) {
for (Object obj : list) {
System.out.println(obj); // Только чтение
}
}
• ? extends T (Producer Extends). Используется, когда мы хотим именно прочитать данные из коллекции. По правилу PECS (Producer Extends, Consumer Super) ? extends T выступает в роли поставщика данных (Producer): мы только читаем из него объекты типа T.
public double sum(List<? extends Number> list) {
double sum = 0;
for (Number n : list) {
sum += n.doubleValue(); // Чтение (Producer)
}
return sum;
}
• ? super T (Consumer Super). Используется, когда мы хотим записать данные в коллекцию. Согласно принципу проектирования PECS ? super T является потребителем данных (Consumer): здесь мы только записываем данные типа T.
public void addNumbers(List<? super Integer> list) {
list.add(1); // Запись (Consumer)
list.add(2);
}
PECS - это принцип работы с дженериками в Java, помогающий безопасно управлять коллекциями при их чтении и записи:
• Producer - Extends (поставщик данных использует extends)
• Consumer - Super (потребитель данных использует super)
Сравнение всех вариантов:
Тип Можно читать Можно писать Когда использовать?
List<T> ✅ как T ✅ T и подтипы Когда и читаем, и пишем
List<?> ✅ как Object ❌ (кроме null) Когда тип не важен
List<? extends T> ✅ как T ❌ (кроме null) Producer - читаем данные
List<? super T> ✅ как Object ✅ T и подтипы Consumer - пишем данные
Теперь вооружаемся IntelliJ IDEA и пишем примеры 😏
Пример обобщенного класса. Используется универсальный класс-контейнер Box, принимающий любой тип T (String, Integer, User и т.п.).
class Box<T> {
private T item;
public void set(T item) {
this.item = item;
}
public T get() {
return item;
}
}
class User {
private String name;
public User(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{name='" + name + "'}";
}
}
public class Main {
public static void main(String[] args) {
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String str = stringBox.get();
System.out.println(str);
Box<Integer> intBox = new Box<>();
intBox.set(42);
Integer num = intBox.get();
System.out.println(num);
Box<User> userBox = new Box<>();
userBox.set(new User("Neo"));
User user = userBox.get();
System.out.println(user);
}
}
Пример обобщённых методов. В классе Utils используются универсальные методы для вывода массивов (printArray) и сравнения объектов (isEqual), принимающие любой тип T.
class Utils {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
public static <T> boolean isEqual(T obj1, T obj2) {
return obj1.equals(obj2);
}
}
public class Main {
public static void main(String[] args) {
String[] words = {"Java", "Python", "C++"};
Integer[] numbers = {1, 2, 3, 4, 5};
Double[] doubles = {1.1, 2.2, 3.3};
Utils.printArray(words);
Utils.printArray(numbers);
Utils.printArray(doubles);
System.out.println(Utils.isEqual("Hello", "Hello"));
System.out.println(Utils.isEqual(10, 10));
System.out.println(Utils.isEqual("10", 10));
}
}
Пример параметризованного интерфейса. Используем интерфейс Processor, отражающий процесс обработки того или иного объекта (приведение к верхнему регистру, умножение и т.п.).
interface Processor<T> {
T process(T input);
}
class StringProcessor implements Processor<String> {
@Override
public String process(String input) {
return input.toUpperCase();
}
}
class NumberProcessor implements Processor<Integer> {
@Override
public Integer process(Integer input) {
return input * 2;
}
}
class UserProcessor implements Processor<User> {
@Override
public User process(User input) {
return new User(input.name.toUpperCase(), input.age);
}
}
class User {
String name;
int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "User{name='" + name + "', age=" + age + "}";
}
}
public class Main {
public static void main(String[] args) {
Processor<String> strProc = new StringProcessor();
Processor<Integer> numProc = new NumberProcessor();
Processor<User> userProc = new UserProcessor();
System.out.println(strProc.process("hello"));
System.out.println(numProc.process(21));
System.out.println(userProc.process(new User("max", 21)));
}
}
return new StringObject(); - кто сделал так и не понял
Интерфейс требует, чтобы метод возвращал SimpleObject<T> (в нашем случае SimpleObject<String>).
Реализация возвращает new StringObject(), а StringObject — это не SimpleObject<String>, а класс, который реализует этот интерфейс.
Но это корректно! Потому что в Java объект класса StringObject является также объектом типа SimpleObject<String> поооооооолиморфизм.
SimpleObject<String> obj = new StringObject();
Ну, на самом деле это грустно. Я, например, в лекциях читаю и большую часть информации понимаю. Но вот в задачах, как-то слабо. Самая главная проблема -- это отсутствие навыка анализировать задачу. Я вот бывает совсем не понимаю, с чего начать анализировать, куда смотреть, хотя теорию вдоль и поперёк перечитал, и даже могу пересказать. Если, задачи идут по теме лекции, то могу большую часть сам решить. Но если подкидывают с других тем, то уже теряюсь. Если подсмотрю решение, то понимаю, но сам бы не догадался...
Для меня на данном этапе большой трудностью является чтение чужого кода. Порой смотришь на эти строки и как будто на китайском всё. А потом начинаешь вдумываться, вчитываться, разбираться, какой объект как и с чем взаимодействует и вроде легче что ли на душе становится) Как там на 28?
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ