Inferencia de tipo de variable local o LVTI en Java 10

¿Qué es la inferencia de tipos?

La inferencia de tipo se refiere a la detección automática del tipo de datos de una variable, generalmente realizada en el momento del compilador.

¿Qué es la inferencia de tipo de variable local?

La inferencia de tipo de variable local es una característica de Java 10 que permite al desarrollador omitir la declaración de tipo asociada con variables locales (aquellas definidas dentro de definiciones de métodos, bloques de inicialización, bucles for y otros bloques como if-else), y el tipo es inferido por el JDK. Entonces, será el trabajo del compilador averiguar el tipo de datos de la variable.

¿Por qué se ha introducido esta función?

Hasta Java 9, para definir variables locales de tipo clase, la siguiente era la única sintaxis correcta:

Class_name variable_name=new Class_name(arguments);

Por ejemplo:

// Sample Java local variable declaration
import java.util.ArrayList;
import java.util.List;
class A {
    public static void main(String a[])
    {
        List<Map> data = new ArrayList<>();
    }
}

O

class A {
    public static void main(String a[])
    {
        String s = " Hi there";
    }
}

Se ve bien, ¿verdad? Sí, porque así han sido las cosas desde el inicio de Java. Pero hay un problema: es bastante obvio que si el tipo de objeto se menciona claramente en el lado derecho de la expresión, mencionar lo mismo antes del nombre de la variable hace que sea redundante. Además, en el segundo ejemplo, puede ver que es obvio que después del signo ‘=’, es claramente una string, ya que nada, excepto una string, puede encerrarse entre comillas dobles. Por lo tanto, surgió la necesidad de eliminar esta redundancia y hacer que la declaración de variables sea más breve y conveniente.

Cómo declarar variables locales usando LVTI:

En lugar de mencionar el tipo de datos de la variable en el lado izquierdo, antes de la variable, LVTI le permite simplemente poner la palabra clave ‘var’. Por ejemplo,

// Java code for Normal local 
// variable declaration
import java.util.ArrayList;
import java.util.List;
class A {
    public static void main(String ap[])
    {
        List<Map> data = new ArrayList<>();
    }
}

Se puede reescribir como:

// Java code for local variable 
// declaration using LVTI
import java.util.ArrayList;
import java.util.List;
class A {
    public static void main(String ap[])
    {
        var data = new ArrayList<>();
    }
}

Casos de uso

Estos son los casos en los que puede declarar variables usando LVTI:

1. En un bloque de inicialización estático/de instancia

   // Declaration of variables in static/init  // block using LVTI in Java 10 class A {     static     {         var x = "Hi there";         System.out.println(x)'     }     public static void main(String[] ax)     {     } }

       Output:
        Oh hi there
   

2. Como una variable local

   // Declaration of a local variable in java 10 using LVTI class A {     public static void main(String a[])     {         var x = "Hi there";         System.out.println(x)     } }

         Output:
         Hi there
   

3. Como variable de iteración en bucle for mejorado

   // Declaring iteration variables in enhanced for loops using LVTI in Java class A {     public static void main(String a[])     {         int[] arr = new int[3];         arr = { 1, 2, 3 };         for (var x : arr)             System.out.println(x + "\n");     } }

   Output:
   1
   2
   3
   

4. Como índice de bucle en bucle for

   // Declaring index variables in for loops using LVTI in Java class A {     public static void main(String a[])     {         int[] arr = new int[3];         arr = { 1, 2, 3 };         for (var x = 0; x < 3; x++)             System.out.println(arr[x] + "\n");     } }

   Output:
   1
   2
   3
   

5. Como valor de retorno de otro método

   // Storing the return value of a function in a variable declared with LVTI class A {     int ret()     {         return 1;     }     public static void main(String a[])     {         var x = new A().ret();         System.out.println(x);     }

   Output:
   1
   

6. Como valor de retorno en un método

   // Using a variable declared  //using the keyword 'var' as a return value of a function class A {     int ret()     {         var x = 1;         return x;     }     public static void main(String a[])     {         System.out.println(new A().ret());     } }

   Output:
   1
   

Casos de error:
Hay casos donde la declaración de variables locales usando la palabra clave ‘var’ produce un error. Se mencionan a continuación:

1. No permitido en campos de clase

   // Sample java code to demonstrate  //that declaring class variables  //using 'var' is not permitted class A {     var x; /* Error: class variables can't be declared             using 'var'. Datatype needs              to be explicitly mentioned*/ }

2. No permitido para variables locales no inicializadas

   // Sample java code to demonstrate  //that declaring uninitialized  //local variables using 'var' produces an error class A {     public static void main(String a[])     {         var x; /* error: cannot use 'var'                  on variable without initializer*/     } }

3. No permitido como parámetro para ningún método.

   // Java code to demonstrate that // var can't be used in case of  //any method parameters class A {     void show(var a) /*Error: can't use 'var'                        on method parameters*/     {     } }

4. No permitido en el tipo de devolución del método

   // Java code to demonstrate // that a method return type // can't be 'var' class A {     public var show() /* Error: Method return type                                       can't be var*/     {         return 1;     } }

5. No permitido con variable inicializada con ‘NULL’

   // Java code to demonstrate that local  variables initialized with 'Null'  can't be declared using 'var'*/ class A {     public static void main(String a[])     {         var x = NULL; // Error: variable initializer is 'null'     }

Nota : Todas estas piezas de código se ejecutan solo en Java 10.