Jerarquías de clases genéricas en Java

Genérico significa tipos parametrizados introducidos en java5. Estos ayudan a crear clases, interfaces, métodos, etc. Una clase o método que funciona en un tipo parametrizado conocido como «clase genérica» ​​o «método genérico». Generics es una combinación de propiedades del lenguaje de la definición y el uso de tipos y métodos genéricos. Las colecciones se usaban antes de Generics, que contienen cualquier tipo de objetos, es decir, no genéricos. Con Generics, se ha vuelto posible crear una sola clase, interfaz o método que funciona automáticamente con todo tipo de datos (entero, string, flotante, etc.). Ha ampliado la capacidad de reutilizar el código de forma segura y sencilla. Los genéricos también brindan seguridad de tipo (garantizando que una operación se realiza en el tipo correcto de datos antes de ejecutar esa operación). 

Las clasificaciones jerárquicas están permitidas por Herencia. Superclase es una clase que se hereda. La subclase es una clase que hereda. Hereda todos los miembros definidos por la superclase y agrega sus propios elementos únicos. Estos usos se extienden como palabra clave para hacerlo.

A veces, la clase genérica actúa como superclase o subclase. En la jerarquía genérica, todas las subclases suben cualquiera de los tipos de parámetros que son esenciales por superclase de genéricos en la jerarquía. Esto es lo mismo que mover los parámetros del constructor hacia arriba en una jerarquía.

Ejemplo 1: superclase genérica

// Java Program to illustrate generic class hierarchies
 
// Importing all input output classes
import java.io.*;
 
// Helper class 1
// Class 1 - Parent class
class Generic1<T> {
    // Member variable of parent class
    T obj;
 
    // Constructor of parent class
    Generic1(T o1) { obj = o1; }
 
    // Member function of parent class
    // that returns an object
    T getobj1() { return obj; }
}
 
// Helper class 2
// Class 2 - Child class
class Generic2<T, V> extends Generic1<T> {
    // Member variable of child class
    V obj2;
    Generic2(T o1, V o2)
    {
        // Calling super class using super keyword
        super(o1);
 
        obj2 = o2;
    }
 
    // Member function of child class
    // that returns an object
    V getobj2() { return obj2; }
}
 
// Class 3 -  Main class
class GFG {
   
    // Main driver method
    public static void main(String[] args)
    {
        // Creating Generic2 (sub class) object
      // Custom inputs as parameters
        Generic2<String, Integer> x
            = new Generic2<String, Integer>("value : ",
                                            100);
 
        // Calling method and printing
        System.out.println(x.getobj1());
        System.out.println(x.getobj2());
    }
}

value : 
100

Nota: una subclase puede agregar libremente sus propios parámetros de tipo, si es necesario. 

Ejemplo 2: subclase no genérica de subclase genérica

import java.io.*;
// non-generic super-class
class NonGen {
    int n;
    NonGen(int i) { n = i; }
    int getval() { return n; }
}
// generic class sub-class
class Gen<T> extends NonGen {
    T obj;
    Gen(T o1, int i)
    {
        super(i);
        obj = o1;
    }
    T getobj() { return obj; }
}
 
class GFG {
    public static void main(String[] args)
    {
 
        Gen<String> w = new Gen<String>("Hello", 2021);
 
        System.out.println(w.getobj() + " " + w.getval());
    }
}

Hello 2021