• Java9-17新特性一览，了解少于3个你可能脱节了

    前言

    Java8出来这么多年后，已经成为企业最成熟稳定的版本，相信绝大部分公司用的还是这个版本，但是一眨眼今年Java19都出来了，相信很多Java工程师忙于学习工作对新特性没什么了解，有的话也仅限于某一块。

    本篇就是博主对自己感觉有用的新特性做了一个案例验证及简要说明，整合起来分享给大家。

    特别说明：Java17是继Java8之后的一个重要里程碑，像SpringBoot3.0、IDEA2022、Jenkins新版、Kafka4.0等等很多生态都强制绑定支持这个版本，等于是给它背书，博主建议大家有必要花时间去了解一下。

    如果没时间看，可以先收藏一下，闲下来一边喝茶一边品读。

    你的收获

    首先，你能通过一篇简单、连续、直观的文章就明白Java8之后Java未来整体发展的趋势，为之后几年适应Java相关工作打下基础；

    其次，你可以通过了解Java9-17的新特性，为以后的面试加分，毕竟一个爱学习有态度的程序员会更受企业青睐；

    最后，你可以看看博主对Java未来发展趋势的粗浅看法，也许能给迷茫的你带来收获。

    准备工作

    首先，你要安装Java17版本，环境变量配置还是和以前没区别，这是我的版本。

    其次，建议安装IDEA2022.3，新版IDEA占用内存比以前少很多，而且有一些增强支持。

    安装好后，需要做一个对Java17的配置，看图。

    setting配置

    Project Structure配置

    这里特别说明一下，最好选择预览版本，因为Java17包含一些预览功能，这里不选预览版本会编译报错。

    新特性

    一共分为了8个，按照版本顺序来讲述的，最后一个是因为几个版本连续有增强，所以单独拿出来。

    1、接口private

    1）、说明

    Java9新特性，在接口中声明private方法，不会被外部实现。

    2）、案例

    声明一个接口，一个default方法，两个private方法。

    1. /**
    2.  * 
    3.  * 用户信息接口
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 15:03
    8.  */
    9. public interface UserInterface {
    10.    private void getUsername() {
    11.       System.err.println("你好，我是王小飞！");
    12.    }
    13.  
    14.    private void getPassword() {
    15.       System.err.println("你好，我是徐西圆！");
    16.    }
    17.  
    18.    default void getData() {
    19.       getUsername();
    20.       getPassword();
    21.    }
    22. }
    23. 复制代码

    实现这个接口，可以看到只能实现default方法，无法实现private方法。

    1. /**
    2.  * 
    3.  * JDK9新特性：接口private方法
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 15:10
    8.  */
    9. public class UserImpl implements UserInterface {
    10.  
    11.    @Override
    12.    public void getData() {
    13.       UserInterface.super.getData();
    14.    }
    15.  
    16.    public static void main(String[] args) {
    17.       UserImpl user = new UserImpl();
    18.       user.getData();
    19.    }
    20. }
    21. 复制代码

    Ctrl+Insert可以查看要实现的方法

    3）、注意

    private接口自动是default的，所以要有方法体，否则编译不通过。

    2、类型推断

    1）、说明

    Java11新特性，在方法内部用var关键字声明一个属性或对象，可以被编译器自动判断类型。

    2）、案例

    案例包含两个测试，一个是直接测试var声明的变量是否能自己推断类型，一个是在循环中使用的效果。

    1. /**
    2.  * 
    3.  * JDK11新特性：类型推断
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 11:52
    8.  */
    9. public class TypeInferenceDemo {
    10.  
    11.    public static void main(String[] args) {
    12.       TypeInferenceDemo demo = new TypeInferenceDemo();
    13.       // 测试类型推断
    14. //    demo.testVar();
    15.  
    16.       // 循环中使用
    17.       List<UserInfo> userList = new ArrayList<>();
    18.       UserInfo userInfo = new UserInfo();
    19.       userInfo.setUsername("张三");
    20.       userInfo.setPassword("123456");
    21.       userList.add(userInfo);
    22.       for (var user : userList) {
    23.          System.err.println(user.getUsername() + " | " + user.getPassword());
    24.       }
    25.    }
    26.  
    27.    public void testVar() {
    28.       var name = "张三";
    29.       var age = 33;
    30.       var id = 1001L;
    31.       var amount = BigDecimal.ZERO;
    32.       var user = new UserInfo();
    33.       System.err.println("-------------------------------------------------");
    34.       System.err.println(name);
    35.       System.err.println(age);
    36.       System.err.println(id);
    37.       System.err.println(amount);
    38.       System.err.println(user);
    39.    }
    40.  
    41.    public static class UserInfo {
    42.       private String username;
    43.       private String password;
    44.  
    45.       public String getUsername() {
    46.          return username;
    47.       }
    48.  
    49.       public void setUsername(String username) {
    50.          this.username = username;
    51.       }
    52.  
    53.       public String getPassword() {
    54.          return password;
    55.       }
    56.  
    57.       public void setPassword(String password) {
    58.          this.password = password;
    59.       }
    60.    }
    61. }
    62. 复制代码

    测试的效果如图

    3）、注意

    1）、只能在方法内部使用（局部变量）；

    2）、必须有初始化值且不能为null；

    3）、不能定义为方法的返回类型。

    3、空指针优化

    1）、说明

    Java15新特性，就是把NullPointerException异常的日志做了优化打印的更人性化。

    2）、案例

    可以看到，提示会更有指向性，意味着以后在复杂的生产环境排错过程中，你很可能不会再被空指针异常所困扰。

    3）、注意

    没什么可注意的

    4、文本块

    1）、说明

    JDK15新特性，就是替代了以前String中一堆换行符和双引号的简洁版写法，相信你很难不喜欢。

    2）、案例

    可以看到，就是三引号取代了双引号，因为双引号的内容会夹带一堆换行符，而三引号里面就单纯是内容，很清晰，而且双引号换行需要杠n，而三引号直接换行即可生效。

    1. /**
    2.  * 
    3.  * JDK15新特性：文本块
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 23:36
    8.  */
    9. public class TextBlockDemo {
    10.    private static final String str =
    11.          "本以为大S和汪小菲的事情就这样告一段落，彼此都过着属于自己的幸福小日子，但是，被骂9天后，汪小菲口中的“窝囊废”，终于有所行动了！\n"
    12.          + "\n"
    13.          + "也许具俊晔再也忍受不了别人骂自己窝囊废，更不愿意住在别人房子内，所以11月30日，据媒体爆料，具俊晔这次要男人一把，决定买一套属于自己的房子，"
    14.          + "属于自己的床垫，搬出汪小菲买的豪宅，来证明自己的实力。";
    15.  
    16.    private static final String newStr = """
    17.             本以为大S和汪小菲的事情就这样告一段落，彼此都过着属于自己的幸福小日子，但是，被骂9天后，汪小菲口中的“窝囊废”，终于有所行动了！
    18.             
    19.             也许具俊晔再也忍受不了别人骂自己窝囊废，更不愿意住在别人房子内，所以11月30日，据媒体爆料，具俊晔这次要男人一把，决定买一套属于自己的房子，
    20.             属于自己的床垫，搬出汪小菲买的豪宅，来证明自己的实力。
    21.          """;
    22.  
    23.    public static void main(String[] args) {
    24.       System.err.println(str);
    25.       System.err.println("------------------------------------------------");
    26.       System.err.println(newStr);
    27.    }
    28. }
    29. 复制代码

    3）、注意

    文本块只有一个要注意的地方，就是默认三引号内的内容没有缩进，想要缩进的话要以末尾三引号为参照物向后偏移来确定缩进量。

    下面一张图会直接展示给你效果：

    5、智能转型

    1）、说明

    Java16新特性，就是帮你对instanceof做了增强，智能转换变量类型。

    2）、案例

    可以对比old和new两种写法，第二种就是将第一种简化了，类型转换+声明变量+后续逻辑判断一起搞定。

    1. /**
    2.  * 
    3.  * JDK16新特性：智能转型
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/3 14:02
    8.  */
    9. public class InstanceofMatching {
    10.    /**
    11.     * 旧写法
    12.     * @param obj 未知对象
    13.     */
    14.    static void testOld(Object obj) {
    15.       if (obj instanceof String) {
    16.          String s = (String) obj;
    17.          if ("模式匹配".equals(s)) {
    18.             System.err.println(s);
    19.          }
    20.       }
    21.    }
    22.  
    23.    /**
    24.     * 新写法
    25.     * @param obj 未知对象
    26.     */
    27.    static void testNew(Object obj) {
    28.       if (obj instanceof String s && "模式匹配".equals(s)) {
    29.          System.err.println(s);
    30.       }
    31.    }
    32.  
    33.    public static void main(String[] args) {
    34.       testOld("Hello, Java!");
    35.       testNew("模式匹配");
    36.    }
    37. }
    38. 复制代码

    3）、注意

    instanceof后面若需要增强判断必须要用&&，不能用||，因为instanceof本来就是做类型匹配的，Java可以确保&&后面的变量一定存在，但无法判断||后面的变量一定存在，所以会报错。

    6、record类

    1）、说明

    Java16新特性，简单讲，就是有了它，声明一个final类变得更简洁和可读。

    2）、案例

    先来看下写法

    1. /**
    2.  * 
    3.  * JDK16新特性：record类
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 21:52
    8.  */
    9. public record RecordDemo(int type, String typeName) {
    10.    private void test() {
    11.       System.err.println(type + " | " + typeName);
    12.    }
    13.    public static void main(String[] args) {
    14.       // 这里new的时候带的参数其实就是类的属性，等于声明属性+访问构造方法二合一。
    15.       RecordDemo recordDemo = new RecordDemo(100, "葡萄牙");
    16.       recordDemo.test();
    17.    }
    18. }
    19. 复制代码

    上面的新写法等同于下面这种老的写法，一看就懂。

    1. /**
    2.  * 
    3.  * RecordDemo的写法等同于这个类
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 21:55
    8.  */
    9. public final class RecordCustomDemo {
    10.    final int type;
    11.    final String typeName;
    12.  
    13.    public int type() {
    14.       return type;
    15.    }
    16.  
    17.    public String name() {
    18.       return typeName;
    19.    }
    20.  
    21.    public RecordCustomDemo(int type, String typeName) {
    22.       this.type = type;
    23.       this.typeName = typeName;
    24.    }
    25.  
    26.    @Override
    27.    public boolean equals(Object o) {
    28.       if (this == o)
    29.          return true;
    30.       if (o == null || getClass() != o.getClass())
    31.          return false;
    32.       RecordCustomDemo that = (RecordCustomDemo) o;
    33.       return type == that.type && Objects.equals(typeName, that.typeName);
    34.    }
    35.  
    36.    @Override
    37.    public int hashCode() {
    38.       return Objects.hash(type, typeName);
    39.    }
    40. }
    41. 复制代码

    3）、注意

    没什么可注意的，就跟使用正常的类差不多，只是自动生成了以下内容：

    1）、括号里的参数就是该类的属性，且是final类型；

    2）、自动生成一个带有该属性的构造器；

    3）、自动生成该属性的访问器，如xx.type()、xx.typeName()；

    4）、生成了equals和hashCode方法。

    如果还是不懂，就理解成lombok中的@Data注解即可，同样的意思。

    7、密封类和接口

    1）、说明

    Java17新特性，密封类和密封接口。

    使用sealed关键字声明的类，可以通过设置permits关键字来控制哪些子类可以继承它。

    使用sealed关键字声明的接口，可以通过设置permits关键字来控制哪些类可以实现它。。

    简单来讲，就是爸爸规定哪个儿子能继承财产。

    2）、案例

    看下密封类的写法

    用sealed声明一个类，设置permits授权哪几个子类可以继承它。

    1. /**
    2.  * 
    3.  * JDK17新特性：密封类
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 17:20
    8.  */
    9. public sealed class Daddy permits Son1, Son2 {
    10. }
    11. 复制代码

    第一个儿子可以继承

    1. /**
    2.  * 
    3.  *
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 17:22
    8.  */
    9. public final class Son1 extends Daddy {
    10. }
    11. 复制代码

    第二个儿子可以继承

    1. /**
    2.  * 
    3.  *
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 17:23
    8.  */
    9. public final class Son2 extends Daddy {
    10. }
    11. 复制代码

    第三个儿子估计是不孝子

    可以看到IDEA是有错误提示的，意思是没有被sealed声明的父类所允许。

    然后，我们来看看密封接口。

    其实和密封类差不多，但还可以结合前面讲过的record来简化代码。

    1. /**
    2.  * 
    3.  * JDK17新特性：密封接口
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 18:03
    8.  */
    9. public sealed interface DaddyInterface permits Son4, Son5 {
    10.    void test();
    11. }
    12. 复制代码

    第四个儿子可以实现父亲的愿望，用了record之后简化了变量声明及一些内置方法的实现。

    1. /**
    2.  * 
    3.  *
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 17:23
    8.  */
    9. public record Son4(int age, String name) implements DaddyInterface {
    10.    @Override
    11.    public void test() {
    12.  
    13.    }
    14. }
    15. 复制代码

    第五个儿子可以实现父亲的愿望

    1. /**
    2.  * 
    3.  *
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/2 17:23
    8.  */
    9. public record Son5(int age, String name) implements DaddyInterface {
    10.    @Override
    11.    public void test() {
    12.  
    13.    }
    14. }
    15. 复制代码

    第六个儿子有点傻，不能实现父亲的愿望，可以看到错误提示和前面密封类一样。

    3）、注意

    1）、sealed声明的父类，它的子类只能用final、sealed、non-sealed来修饰；

    2）、sealed声明的父类，至少要有一个子类；

    3）、没有在permits中授权的子类，无法继承父类；

    4）、密封接口和密封类的注意点没什么区别；

    4）、密封接口结合record来完成可以少写更多代码变得更加简洁。

    这里特别说一点，sealed和record其实在Java新特性模式匹配中很有意义，但是我认为模式匹配对于从未了解过的Java程序员来讲有些晦涩，结合sealed后有种套娃传销的感觉，如果难于理解就不是我们本来的目的，因此没有专门花费章节赘述，结尾会简单说一下我对模式匹配的看法。

    8、switch增强

    1）、说明

    为什么把switch单独放最后讲，因为Java14-17分别对其做了增强，放在最后汇总起来讲更直观。

    一共有三个改变：

    1）、支持箭头语法；

    2）、支持表达式；

    3）、支持case null。

    2）、案例

    箭头语法，其实就是把旧写法中的冒号和break直接换成了箭头来代替，更简洁。

    1. /**
    2.  * 
    3.  * JDK14新特性：switch箭头语法
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/3 11:05
    8.  */
    9. public class SwitchDemo1 {
    10.    private static void foods(int i) {
    11.       switch (i) {
    12.          case 1:
    13.             System.err.println("青椒肉丝");
    14.             break;
    15.          case 2:
    16.             System.err.println("番茄炒蛋");
    17.             break;
    18.          default:
    19.             System.err.println("米饭");
    20.       }
    21.    }
    22.  
    23.    private static void fruits(int i) {
    24.       switch (i) {
    25.          case 1 -> System.err.println("香蕉");
    26.          case 2 -> System.err.println("猕猴桃");
    27.          default -> System.err.println("苹果");
    28.       }
    29.    }
    30.  
    31.    public static void main(String[] args) {
    32.       foods(1);
    33.       fruits(3);
    34.    }
    35. }
    36. 复制代码

    支持表达式，其实就是能写单个或多个表达式来return。

    1. /**
    2.  * 
    3.  * JDK14新特性：switch支持表达式
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/3 11:05
    8.  */
    9. public class SwitchDemo3 {
    10.  
    11.    /**
    12.     * 单表达式
    13.     */
    14.    private static String fruits(int i) {
    15.       return switch (i) {
    16.          case 1 -> "香蕉";
    17.          case 2 -> "猕猴桃";
    18.          default -> "苹果";
    19.       };
    20.    }
    21.  
    22.    /**
    23.     * 多表达式
    24.     */
    25.    private static String fruitsNew(int i) {
    26.       return switch (i) {
    27.          case 1, 2 -> {
    28.             System.err.println("----------------------------------");
    29.             System.err.println("来一个香蕉");
    30.             yield "香蕉来咯";
    31.          }
    32.          case 3, 4 -> {
    33.             System.err.println("----------------------------------");
    34.             System.err.println("来一个猕猴桃");
    35.             yield"猕猴桃来咯";
    36.          }
    37.          default -> {
    38.             System.err.println("----------------------------------");
    39.             System.err.println("没的选就来个苹果吧");
    40.             yield "苹果来咯";
    41.          }
    42.       };
    43.    }
    44.  
    45.    public static void main(String[] args) {
    46. //    System.err.println(fruits(2));
    47. //    System.err.println(fruits(3));
    48.  
    49.       System.err.println(fruitsNew(2));
    50.       System.err.println(fruitsNew(4));
    51.       System.err.println(fruitsNew(5));
    52.    }
    53. }
    54. 复制代码

    支持case null，其实就是case可以接收null值了。

    1. /**
    2.  * 
    3.  * JDK17新特性(预览)：switch支持case null
    4.  * 
    5.  *
    6.  * @author 程序员济癫，公众号：【Java分享客栈】
    7.  * @since 2022/12/3 11:05
    8.  */
    9. public class SwitchDemo2 {
    10.    private static void foods(String s) {
    11.       if (s == null) {
    12.          return;
    13.       }
    14.       switch (s) {
    15.          case "1":
    16.             System.err.println("青椒肉丝");
    17.             break;
    18.          case "2":
    19.             System.err.println("番茄炒蛋");
    20.             break;
    21.          default:
    22.             System.err.println("米饭");
    23.       }
    24.    }
    25.  
    26.    private static void fruits(String s) {
    27.       switch (s) {
    28.          case "1" -> System.err.println("香蕉");
    29.          case null -> System.err.println("null");
    30.          default -> System.err.println("苹果");
    31.       }
    32.    }
    33.  
    34.    public static void main(String[] args) {
    35.       foods("1");
    36.       fruits(null);
    37.    }
    38. }
    39. 复制代码

    可以看下效果，直接传null也不会报错。

    3）、注意

    1）、箭头语法，冒号和箭头不能同时存在；

    2）、表达式，多个表达式时要使用花括号并使用yield关键字返回；

    3）、case null是预览功能，在IDEA - Project Structure - Modules中选择Language Level为17(Preview)才能编译通过，参考前面的准备工作。

    总结

    1）、Java9-17的新特性不仅于此，还有一些挺有特点的内容，比如不可变集合、模块化、String和Stream的API增强等等，但是我个人认为不具有代表性，要么是工具能直接帮你转换，要么就是你大概率用不到，所以就没列出来；

    2）、模式匹配，是不少Java程序员关注的内容，本篇中record、switch、密封类和接口的内容其实都是模式匹配的基础，但模式匹配对Java来讲并不成熟，《Thinking In Java》的作者也说过可能要好几年才会看到完整形式的Java模式匹配，所以没必要现在就花太多心思去研究一个残缺版本，这个特性和Python、Kotlin、Scala相比其实还差得远。

    Java发展趋势

    最后稍微说下不少人关心的这个问题，我觉得只要你了解过Java8之后这些版本的新特性和预览特性，你一定可以发现Java在尝试改变，这是一个很好的信号。

    就比如上面的这些新特性，你甚至能找到不少Python、JavaScript等语言的影子，Go语言作为新语言就是站在巨人肩膀上发展起来的，吸纳了很多语言的优秀特点。

    现在，Java也在走类似的路，能明显看到它在将一些优秀语言的亮点容纳到自己的新版本中，这种趋势代表着一个意义：Java在不断进步。

    网上一直充斥着一些看衰Java的言论，没必要当真，你必须自己去体会生态和了解国内的IT公司动态才能有所感受。

    Java依然是国内使用最广泛的语言，并且具备最庞大的生态，这不是一朝一夕可以替代的，是市场规律发展的结果。

    SpringBoot3.0支持Java17，Jenkins新版支持Java17，Kafka4.0直接抛弃Java8，ElasticSearch8.x最低支持JDK17，还有IDEA2022默认支持Java17，等等之类的开源社区和生态都在给新版的Java背书，更有微软宣布全面拥抱Java，这里面不单单是技术层面的提高，更有利益的诉求和捆绑。

    从这一点来说，学习Java完全是值得的，作为一门成熟优秀且严谨的语言，它就像一个白领一样正襟危坐。

    我还认为现在学习和掌握Java的工程师，未来转去其他语言也不会有压力，上面的新特性就说明了这种方向，它在吸纳其他语言的亮点。

    未来可以预期的是，你转到其他语言会逐渐变的没有那么陌生和晦涩，这是我看到的一个方向，未来的编程语言发展大方向就是大融合(大抄袭，咳咳)，你中有我，我中有你。

  • 相关阅读:
    【Try to Hack】john哈希破解工具
    漏洞复现----43、Spring Cloud Function SpEL 代码注入 (CVE-2022-22963)
    企业公司项目开发好一部分基础功能，重要的事保存到线上第一a
    设置系统缩放比，适配各分辨率
    程序员的专属浪漫——用3D Engine 5分钟实现烟花绽放效果
    介绍 TensorFlow 的基本概念和使用场景。
    【深度学习】——损失函数（均方差损失和交叉熵损失）
    5.2 EF Core性能优化
    《微信小程序-基础篇》带你了解小程序中的生命周期（二）
    Java浅谈随笔，你都会了吗?
  • 原文地址：https://blog.csdn.net/BASK2311/article/details/128198161