Наследование в Generics

Generics в Java позволяют создавать гибкие и типобезопасные классы, методы и интерфейсы. Они помогают избежать ошибок с неправильным приведением типов и улучшают читабельность и поддерживаемость кода. Однако, с generics связано немало нюансов, которые могут быть неочевидными для новичков, особенно когда дело касается наследования и использования generics с интерфейсами.

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

Кстати, если вас интересуют качественные курсы программирования и более глубокое понимание темы generics, компания FoxmindEd предлагает отличные обучающие и продвинутые программы. Они специализируются на современных IТ-технологиях и помогут вам развить ваши профессиональные навыки.

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

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

Представим, что у нас есть класс Container, который может хранить некоторый элемент типа T. Мы можем создать различные классы коробок (Box), которые будут наследовать Container, но по-разному работать с обобщенными типами (generics). Каждый из этих классов будет наследовать Container и по-своему обрабатывать generics, что позволит реализовать различные подходы к хранению и работе с данными.

@Data

class Container<T> {

  private T item;

}

Если класс Box наследует Container без указания типа (Box extends Container), это вызовет предупреждение об использовании сырого типа Container. Java интерпретирует это как использование «сырых» типов, что может привести к проблемам с безопасностью типов.

public class Box extends Container{

   public Box(Object item) {

       super(item);

   }

}

public class Main {

   public static void main(String[] args) {

       Box box = new Box("Item"); // Box наследует сырой тип Container

       Object item = box.getItem(); // Повернеться Object, а не конкретний тип

       Box<String> box = new Box<>("Item"); // Будет ошибка компиляции, ведь мы не указали, что наш Box параметризован

   }

}

В этом случае класс Box1 наследует Container, но также поддерживает обобщенный тип T. Это наиболее безопасный и гибкий способ наследования, ведь при создании Box мы сможем указать тип, который там будет храниться.

class Box1<T> extends Container<T>{

public Box(T item) {

   super(item);

    }

}

public class Main {

   public static void main(String[] args) {

       Box1<String> box = new Box1<>("Item");

       String item = box.getItem(); // Вернётся тип String

   }

}

Box2 наследует Container, фиксируя тип T как String. Это означает, что все экземпляры Box2 будут хранить только строки (String):

public class Box2 extends Container<String>{

   public Box2(String item) {

       super(item);

   }

}

public class Main {

   public static void main(String[] args) {

       Box2 box = new Box2("Item");

       String item = box.getItem(); // Вернётся тип String

       Box2 box2 = new Box2(5); // будет ошибка компиляции, ведь Box2 сохраняет только тип String

   }

}

В данном классе Box3 поддерживает несколько обобщенных типов (T, V, K), но наследует Container с типом T. Это означает, что T будет использоваться для поля item, тогда как V и K могут использоваться для других целей

@Getter

@Setter

class Box3<T, V, K> extends Container<T> {

   private V extraValue;

   private K anotherValue;

   public Box3(T item, V extraValue, K anotherValue) {

       super(item);

       this.extraValue = extraValue;

       this.anotherValue = anotherValue;

   }

}

public class Main {

   public static void main(String[] args) {

       Box3<String, Integer, Double> box = new Box3<>("Hello", 42, 3.14);

       String item = box.getItem(); // Получим String

       Integer extra = box.getExtraValue(); // Получим Integer

       Double another = box.getAnotherValue(); // Получим Double

   }

}

Наследование с ограничениями

Мы рассмотрели стандартное наследование с использованием generics, где классы-потомки могут работать с любым типом данных, передаваемым в качестве параметра. Это обеспечивает гибкость и универсальность в использовании, но иногда возникает необходимость ограничить типы, с которыми может работать класс.

FoxmindEd — это учебный центр с большим выбором направлений курсов для новичков и программистов с опытом!

Начинаете свой путь в IТ? Попробуйте курсы Start

Имеете базовые навыки программирования? Тогда вам на курсы Junior

Хотите углубить свои знания в IТ? У нас есть курсы Middle/Senior

Именно для таких случаев generics позволяют применять наследование с ограничениями, используя ключевое слово extends. Это особенно полезно, когда нужно работать только с определенной группой типов, например, всеми классами, которые наследуются от конкретного суперкласса или реализуют определенный интерфейс. Такой подход называется ограничением параметра типа (bounded type parameter) и позволяет создавать более безопасный и структурированный код, ограничивая использование generics определенными рамками.

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

class Animal {}

class Dog extends Animal {}

class Cat extends Animal {}

class Container<T extends Animal> {

   private T item;

   public Container(T item) {

       this.item = item;

   }

   public T getItem() {

       return item;

   }

}

В этом примере класс Container параметризован типом T, который ограничен классом Animal. Это означает, что T может быть либо Animal, либо любым его подтипом, таким как Dog или Cat. Таким образом, мы можем создавать экземпляры контейнера только для животных:

Container<Dog> dogContainer = new Container<>(new Dog());

Container<Cat> catContainer = new Container<>(new Cat());

Container<Animal> animalContainer = new Container<>(new Animal());

Однако, если мы попытаемся передать тип, который не является подклассом Animal, это приведет к ошибке компиляции:

Container<Book> book Container = new Container<>(new Book()); // будет ошибка компиляции

Наследование с несколькими ограничениями

В Java также можно установить несколько ограничений на параметр типа. Это делается с помощью ключевого слова&, которое позволяет ограничивать типы классами и интерфейсами одновременно. Например, мы можем ограничить параметр типа таким образом, чтобы он был подтипом определенного класса и одновременно реализовывал один или несколько интерфейсов:

interface Flyable {

   void fly();

}

Это простой интерфейс с методом fly(). Классы, которые реализуют этот интерфейс, должны предоставлять свою собственную реализацию этого метода. Интерфейс обозначает, что объект может летать.

class Parrot extends Animal implements Flyable {

   @Override

   public void fly() {

       System.out.println("Parrot is flying");

   }

}

class Lion extends Animal {

}

class Sparrow extends Animal implements Flyable {

   @Override

   public void fly() {

       System.out.println("Sparrow is flying");

   }

}

Все классы животных наследуют класс Animal, однако не все имплементируют Flyable и предоставляют собственную реализацию метода fly.

class FlyingContainer<T extends Animal & Flyable> {

   private T item;

   public FlyingContainer(T item) {

       this.item = item;

   }

   public void letFly() {

       item.fly();

   }

}

В этом примере класс FlyingContainer ограничивает тип T так, что он должен быть подтипом Animal и реализовывать интерфейс Flyable. Это означает, что можно использовать только те классы, которые наследуются от Animal и реализовывают интерфейс Flyable (например, Parrot или Sparrow):

FlyingContainer<Parrot> parrotContainer = new FlyingContainer<>(new Parrot());

parrotContainer.letFly(); // Выведет "Parrot is flying"

FlyingContainer<Sparrow> sparrowContainer = new FlyingContainer<>(new Sparrow());

sparrowContainer.letFly(); // Выведет "Sparrow is flying"

FlyingContainer<Lion> lionContainer = new FlyingContainer<>(new Lion()); // будет ошибка компиляции

Передать в контейнер тип Lion мы уже не можем, ведь хотя наш Lion и животное, однако он не имплементирует интерфейс Flyable.

Этот пример показывает, как generics можно использовать для ограничения типов с помощью T extends Animal & Flyable, обеспечивая, что только те классы, которые являются подтипами определенного класса (в данном случае Animal) и одновременно реализуют определенный интерфейс (Flyable), могут быть переданы в generics-класс. Это позволяет гарантировать типобезопасность и избегать ошибок во время компиляции. FoxmindEd предлагает комплексный курс JAVA, где вы можете узнать больше об использовании generics, а также многие другие аспекты программирования на Java.