Constructores genéricos e interfaces en Java

Los genéricos hacen que una clase, una interfaz y un método consideren todos los tipos (de referencia) que se dan dinámicamente como parámetros. Esto garantiza la seguridad del tipo. Los parámetros de clase genéricos se especifican entre paréntesis angulares “<>” después del nombre de clase a partir de la variable de instancia.

Los constructores genéricos son lo mismo que los métodos genéricos. Para constructores genéricos, después de la palabra clave pública y antes del nombre de la clase, se debe colocar el parámetro de tipo. Los constructores se pueden invocar con cualquier tipo de parámetro después de definir un constructor genérico. Un constructor es un bloque de código que inicializa el objeto recién creado. Es un método de instancia sin tipo de retorno. El nombre del constructor es el mismo que el nombre de la clase. Los constructores pueden ser genéricos, a pesar de que su clase no sea genérica. 

Implementación: 

Ejemplo

// Java Program to illustrate Generic constructors
  
// Importing input output classes
import java.io.*;
  
// Class 1
// Generic class
class GenericConstructor {
    // Member variable of this class
    private double v;
  
    // Constructor of this class where
    // T is typename and t is object
    <T extends Number> GenericConstructor(T t)
    {
        // Converting input number type to double
        // using the doubleValue() method
        v = t.doubleValue();
    }
  
    // Method of this class
    void show()
    {
        // Print statement whenever method is called
        System.out.println("v: " + v);
    }
}
  
// Class 2 - Implementation class
// Main class
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        // Display message
        System.out.println("Number to Double Conversion:");
  
        // Creating objects of type GenericConstructor i.e
        // og above class and providing custom inputs to
        // constructor as parameters
        GenericConstructor obj1
            = new GenericConstructor(10);
        GenericConstructor obj2
            = new GenericConstructor(136.8F);
  
        // Calling method - show() on the objects
        // using the dot operator
        obj1.show();
        obj2.show();
    }
}

Number to Double Conversion:
v: 10.0
v: 136.8000030517578

Explicación de salida: aquí GenericConstructor() establece un parámetro de un tipo genérico que es una subclase de Número. Se puede llamar a GenericConstructor() con cualquier tipo numérico como Integer, Float o Double. Entonces, a pesar de que GenericConstructor() no es una clase genérica, su constructor es genérico.

Las interfaces genéricas en Java son las interfaces que se ocupan de los tipos de datos abstractos. Ayuda de interfaz en la manipulación independiente de colecciones de Java a partir de detalles de representación. Están acostumbrados a lograr herencia múltiple en java formando jerarquías. Se diferencian de la clase java. Estos incluyen solo todos los métodos abstractos, solo tienen variables estáticas y finales. La única referencia se puede crear para la interfaz , no para los objetos. A diferencia de la clase, estos no contienen constructores, variables de instancia. Esto involucra la palabra clave “ implementa ”. Son similares a las clases genéricas.

Los beneficios de la interfaz genérica son los siguientes:

1. Esto se implementa para diferentes tipos de datos.
2. Permite poner restricciones, es decir, límites en los tipos de datos para los que se implementa la interfaz.

Sintaxis:

interface interface-Name < type-parameter-list > {//....}

class class-name <type-parameter-list> implements interface-name <type-arguments-list> {//...}

Implementación: el siguiente ejemplo crea una interfaz ‘MinMax’ que involucra métodos muy básicos como min(), max() solo para ilustrar cómo devuelven los valores mínimo y máximo de objetos dados.

Ejemplo

// Java Program to illustrate Generic interfaces
  
// Importing java input output classes
import java.io.*;
  
// An interface that extends Comparable
interface MinMax<T extends Comparable<T> > {
    // Declaring abstract methods
    // Method with no body is abstract method
    T min();
    T max();
}
  
// Class 1 - Sub-class
// class extending Comparable and implementing interface
class MyClass<T extends Comparable<T> >
    implements MinMax<T> {
  
    // Member variable of 'MyClass' class
    T[] values;
  
    // Constructor of 'MyClass' class
    MyClass(T[] obj) { values = obj; }
  
    // Now, defining min() and max() methods
    // for MimMax interface computation
  
    // Defining abstract min() method
    public T min()
    {
        // 'T' is typename and 'o1' is object_name
        T o1 = values[0];
  
        // Iterating via for loop over elements using
        // length() method to get access of minimum element
        for (int i = 1; i < values.length; i++)
            if (values[i].compareTo(o1) < 0)
                o1 = values[i];
  
        // Return the minimum element in an array
        return o1;
    }
  
    // Defining abstract max() method
    public T max()
    {
        // 'T' is typename and 'o1' is object_name
        T o1 = values[0];
  
        // Iterating via for loop over elements using
        // length() method to get access of minimum element
        for (int i = 1; i < values.length; i++)
            if (values[i].compareTo(o1) > 0)
                o1 = values[i];
  
        // Return the maximum element in an array
        return o1;
    }
}
  
// Class 2 - Main class
// Implementation class
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        // Custom entries in an array
        Integer arr[] = { 3, 6, 2, 8, 6 };
  
        // Create an object of type as that of above class
        // by declaring Integer type objects, and
        // passing above array to constructor
        MyClass<Integer> obj1 = new MyClass<Integer>(arr);
  
        // Calling min() and max() methods over object, and
  
        // printing the minimum value from array elements
        System.out.println("Minimum value: " + obj1.min());
  
        // printing the maximum value from array elements
        System.out.println("Maximum value: " + obj1.max());
    }
}

Minimum value: 2
Maximum value: 8

Explicación de salida: aquí la interfaz se declara con el parámetro de tipo T, y su límite superior es Comparable, que está en java.lang. Esto establece cómo se comparan los objetos en función del tipo de objetos. Por encima de T es declarado por MyClass y luego pasado a MinMax ya que MinMax necesita un tipo que implemente Comparable y la clase de implementación (MyClass) debe tener los mismos límites.  

Nota: Una vez que se establece un límite, no es necesario volver a establecerlo en la cláusula de implementos. Si una clase implementa una interfaz genérica, entonces la clase debe ser genérica para que tome un parámetro de tipo pasado a la interfaz.