JDK 10 主要新特性在于支持 var 申明 的局部变量,相当于一个泛型

 

1 package com.lomi.jdk10;
 2 
 3 import org.junit.Test;
 4 
 5 import java.awt.print.Book;
 6 import java.util.*;
 7 import java.util.function.Supplier;
 8 
 9 /**
10  *
11  * jdk10 新特性
12  * @author ZHANGYUKUN
13  * @date 2022/6/17
14  */
15 public class JDK10NewTest {
16 
17 
18     /**
19      * 1 局部变量类型推断(通过右边推断,右边必须是明确的类型)
20      * 2 var 不是关键字,而是一个特殊的类型( 或者把它当做一个特殊的泛型 )
21      * 3 var 编译以后会变成明确的类型
22      */
23     @Test
24     public void test1(){
25         // var 不是关键字,而是一个特殊的类型
26         var var = "var";
27 
28 
29         var a  = 1L;
30         System.out.println(  a );
31 
32         //修改别的类型是不允许的,但是可以自动转化的类型是可以
33         //a = "";
34         a = 2;
35 
36 
37         //var 右边不是lamdda 表达式。lamdda 表达式是通过左边的接口函数的类型推断出来的。是不确定的类型
38         Supplier f =  ()->{ return 1; };
39         //var f2 =  ()->{ return 1; };
40 
41         //右边的泛型参数如果不指定就是Object
42         Collection<String> colle1 = Set.of("1","2","3");
43         var colle2 = new HashSet<>();
44 
45         //省略类型的静态数组不能指向 var(我个人觉得这个应该允许,右边的是明确的值)
46         String[] array0 = new String[]{"1","2","3"};
47         String[] array1 = {"1","2","3"};
48         Object[] array11 = {1,"2", Long.parseLong("1" ) };
49         //var array2 = {"1","2","3"};
50 
51         //var 不能指向空值,因为空值是不明确的类型
52         Integer int1 = null;
53        // var int2 = null;
54 
55 
56         //var 定义返回值类型,和形参类型,返回值和形参本来就是用来约束类型的。
57 
58 
59         //var 不能是 成员变量,因为成员变量有默认值。var 不是明确的类型,不能知道默认值,
60         // 而且成员变量应该是明确的类型,var 的 使用场景是类似于 循环遍历之类的类型明确 ,使用者毫不关心,不需要手动声明的场景
61 
62 
63         //var的正确使用姿势(我们其实不关心内循环遍量的类型,因为它只能是那个确定类型,相当于 idea的 new Object().var+回车 自动推断变量类型)
64         Map<String, String> map = Map.ofEntries(Map.entry("key1", "value1"), Map.entry("key2", "valu2"));
65         for(var entry : map.entrySet()){
66             System.out.println(  entry.getKey() );
67             System.out.println(  entry.getValue() );
68         }
69 
70     }
71 
72 
73 
74     /**
75      *
76      *   Optional 添加 orElseThrow 方法, 取不到 直接 抛出异常,而不是在在使用的时候才抛出异常
77      *
78      */
79     @Test
80     public void test2(){
81 
82         var optional =   Optional.of("");
83         optional.orElseThrow();
84 
85 
86     }
87 
88 
89 
90 
91 
92 
93 
94 }
95
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.