Inferencia tipo con operador Diamante en Java

Avanzado

A partir de JDK 7, es posible acortar la sintaxis utilizada para crear una instancia de un tipo genérico. Para comenzar, piense en la clase DosGen que se mostró anteriormente aquí.

1. Inferencia tipo

class DosGen<T, V>{
    // Usa dos parámetros de tipo
    T ob1; //Declara un objeto de tipo T
    V ob2; //Declara un objeto de tipo V
    //Pase al constructor una referencia a un objeto de tipo T y V.
    DosGen(T o1, V o2){
        ob1=o1;
        ob2=o2;
    }
    T getOb1(){
        return ob1;
    }
    V getOb2(){
        return ob2;
    }
    //Muestra el tipo de T y V
    void mostrarTipo(){
        System.out.println("El tipo de T es: "+ob1.getClass().getName());
        System.out.println("El tipo de V es: "+ob2.getClass().getName());
    }
}
//Demostración de clase DosGen
class Genericos {
    public static void main(String[] args) {
       DosGen<Integer,String> dosGen= new DosGen<Integer, String>(28,"Genericos");
       //Mostrar los tipos
        dosGen.mostrarTipo();
        //Obtener y mostrar los valores
        int v=dosGen.getOb1();
        System.out.println("Valor: "+v);
        String str=dosGen.getOb2();
        System.out.println("Valor: "+str);
    }
}

Una porción se muestra aquí por conveniencia. Observe que usa dos tipos genéricos.

class DosGen<T, V>{
    T ob1; //Declara un objeto de tipo T
    V ob2; //Declara un objeto de tipo V
    //Pase al constructor una referencia a un objeto de tipo T y V.
    DosGen(T o1, V o2){
        ob1=o1;
        ob2=o2;
    }
//...
}

Para las versiones de Java anteriores a JDK 7, para crear una instancia de DosGen, debe usar una declaración similar a la siguiente:

DosGen<Integer, String> dgOb=
          new DosGen<Integer, String>(42,"prueba");

Aquí, los argumentos de tipo (que son Integer y String) se especifican dos veces: primero, cuando se declara dgOb, y segundo, cuando se crea una instancia de DosGen a través de new. Si bien no hay nada de malo, con esta forma, es un poco más detallado de lo que necesita ser. Dado que, en la nueva cláusula, el tipo de los argumentos de tipo se puede inferir fácilmente, realmente no hay ninguna razón por la que deba ser especificado por segunda vez. Para solucionar esta situación, JDK 7 agregó un elemento sintáctico que le permite evitar la segunda especificación.

2. Operador Diamante

Actualmente, la declaración anterior se puede reescribir como se muestra aquí:

DosGen<Integer, String> dgOb=
          new DosGen<>(42,"prueba");

Tenga en cuenta que la parte de creación de la instancia simplemente usa <>, que es una lista de argumentos de tipo vacío. Esto se conoce como el operador de diamantes. Le dice al compilador que infiera los argumentos de tipo necesarios para el constructor en la nueva expresión. La principal ventaja de esta sintaxis de inferencia de tipos es que acorta lo que a veces son declaraciones bastante largas. Esto es especialmente útil para los tipos genéricos que especifican límites.

El ejemplo anterior puede ser generalizado. Cuando se usa la inferencia de tipo, la sintaxis de declaración para una referencia genérica y creación de instancia tiene esta forma general:

nombre-clase<lista-argumento-tipo> nombre-var = 
     new nombre-clase<>(lista-argumento-tipo);

Aquí, la lista de argumentos de tipo de la cláusula new está vacía.

Aunque principalmente para su uso en declaraciones, la inferencia de tipo también se puede aplicar al paso de parámetros. Por ejemplo, si se agrega el siguiente método a DosGen:

boolean esIgual(DosGen<T,V> o){
        if (ob1==o.ob1 && ob2== o.ob2) return true;
        else return false;
    }

entonces la siguiente llamada es legal:

if(dgOb.esIgual(new DosGen<>(42, "prueba"))) System.out.println("Igual");

En este caso, los argumentos de tipo para los argumentos pasados a esIgual() se pueden inferir a partir de los tipos de parámetros. No necesitan ser especificados de nuevo.

Aunque el operador de diamante ofrece comodidad, en general, los ejemplos restantes de genéricos en este libro continuarán usando la sintaxis completa al declarar instancias de clases genéricas. Hay dos razones para ello. En primer lugar, el uso de la sintaxis completa deja muy claro lo que se está creando, lo que es útil cuando se muestra el código de ejemplo. Segundo, el código funcionará en entornos que estén usando un compilador más antiguo. Por supuesto, en tu propio código, el uso de la sintaxis de inferencia de tipo agilizará tus declaraciones.

Genéricos en Java
  • Inferencia tipo con operador Diamante

Sobre el Autor:

Hey hola! Yo soy Alex Walton y tengo el placer de compartir conocimientos hacía ti sobre el tema de Programación en Java, desde cero, Online y Gratis.

Deja una Respuesta

*

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.