Java 10 中的局部变量类型推断或 LVTI

什么是类型推断？

类型推断是指自动检测变量的数据类型，通常在编译器时完成。

什么是局部变量类型推断？

局部变量类型推断是Java 10 中的一项功能，它允许开发人员跳过与局部变量相关的类型声明（在方法定义、初始化块、for 循环和其他块（如 if-else）中定义的那些），并且类型是由 JDK 推断。那么，编译器的工作就是找出变量的数据类型。

为什么要引入这个功能？

直到Java 9，要定义类类型的局部变量，以下是唯一正确的语法：

Class_name variable_name=new Class_name(arguments);

例如：

// Sample Java local variable declaration
import java.util.ArrayList;
import java.util.List;
class A {
    public static void main(String a[])
    {
        List

或者

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

看起来不错，对吧？是的，因为这就是自Java诞生以来的情况。但是有一个问题：很明显，如果在表达式的右侧清楚地提到了对象的类型，那么在变量名称之前提到相同的东西会使它变得多余。另外，在第二个示例中，您可以看到在 '=' 符号之后很明显，它显然是一个字符串，因为除了字符串之外什么都可以用双引号括起来。因此，需要消除这种冗余并使变量声明更短、更方便。

如何使用 LVTI 声明局部变量：

LVTI 没有在左侧提到变量数据类型，而是在变量之前，允许您简单地放置关键字“var”。例如，

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

可以重写为：

// 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<>();
    }
}

用例

以下是您可以使用 LVTI 声明变量的情况：

1. 在静态/实例初始化块中

   // 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. 作为局部变量

   // 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. 作为增强 for 循环中的迭代变量

   // 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. 作为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. 作为另一个方法的返回值

   // 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. 作为方法中的返回值

   // 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
   

错误案例：
在某些情况下，使用关键字“var”声明局部变量会产生错误。它们在下面提到：

1. 不允许在类字段中

   // 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. 不允许用于未初始化的局部变量

   // 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. 不允许作为任何方法的参数

   // 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. 方法返回类型中不允许

   // 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. 不允许使用“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'
       }
   

注意：所有这些代码仅在Java 10 上运行。