devbox
小惠珠哦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java - JDK17语法新增特性（如果想知道Java - JDK17语法新增常见的特性的知识点，那么只看这一篇就足够了！）_java jdk 17 语法新特性

作者：小惠珠哦 | 2024-07-12 15:08:13

赞

踩

java jdk 17 语法新特性

        前言：Java在2021年发布了最新的长期支持版本：JDK 17。这个版本引入了许多新的语法特性，提升了开发效率和代码可读性。本文将简要介绍一些常见的新特性，帮助开发者快速掌握并应用于实际开发中。

✨✨✨这里是秋刀鱼不做梦的BLOG

✨✨✨想要了解更多内容可以访问我的主页秋刀鱼不做梦-CSDN博客

先让我们看一下本文大致的讲解内容：

1.yield关键词

        ——先让我们来了解一下yield关键词的作用：

yield关键字，用于增强switch表达式，使其能够返回值。yield允许switch表达式在不同的分支中返回特定的值，并将其赋给变量。

先让我们来看一个正常的switch的例子：

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         String data = "one";
  4.         int result = 0; // 接收数据的返回值
  5.         switch (data) {
  6.             case "one":
  7.                 result = 1; // 为result重新赋值
  8.                 break;
  9.             case "two":
  10.                 result = 2; // 为result重新赋值
  11.                 break;
  12.             default:
  13.                 result = -1; // 为result重新赋值
  14.                 break;
  15.         }
  16.         System.out.println(result);
  17.     }
  18. }

代码分析：

  1. 定义类和主方法：代码定义了一个名为Test的类，并包含一个main方法，这是程序的入口点。

  2. 初始化变量：声明并初始化了两个变量，data和result。data被赋值为字符串"one"，result被初始化为0。

  3. switch语句：

    • 根据data的值进行判断。

    • 如果data的值是"one"，则执行result = 1;，并通过break跳出switch语句。

    • 如果data的值是"two"，则执行result = 2;，并通过break跳出switch语句。

    • 如果data的值不是"one"或"two"，则执行default块，将result赋值为-1，并通过break跳出switch语句。

  4. 输出结果：通过System.out.println(result);将result的值输出到控制台。

现在让我们将上述的代码进行简化，简化后的switch：

  1. public static void main(String[] args) {
  2.     String data = "one";
  3.     int result = switch (data) {
  4.         case "one" -> 1;
  5.         case "two" -> 2;
  6.         default -> -1;
  7.     };
  8.     System.out.println(result);
  9. }

我们发现我们可以使用->来返回switch语句的值，当然有读者会问了，这和我们讲解的yield有什么关系呢？，接下来让我们将上述代码转换为yield的形式：

  1. public static void main(String[] args) {
  2.     String data = "one" ;
  3.     int result = switch (data) {
  4.         case "one" : yield 1;
  5.         case "two": yield 2;
  6.         default : yield -1;
  7.     };
  8.     System.out.println(result) ;
  9. }

我们可以发现我们也可以使用yield来返回switch的值，这就是yield语句。

2.var关键词

        var是Java 10中引入的一个新特性，用于局部变量类型推断。它允许编译器在编译时自动推断变量的类型，从而简化代码书写和增强代码可读性。

        接下来我们直接使用实例来进行讲解：

以下是一个使用var的示例：

  1. import java.util.ArrayList;
  2.  
  3. public class VarExample {
  4.     public static void main(String[] args) {
  5.         // 使用var声明整型变量
  6.         var number = 10;
  7.         System.out.println("Number: " + number);
  8.  
  9.         // 使用var声明字符串变量
  10.         var text = "Hello, Java 10!";
  11.         System.out.println("Text: " + text);
  12.  
  13.         // 使用var声明集合
  14.         var list = new ArrayList<String>();
  15.         list.add("Apple");
  16.         list.add("Banana");
  17.         System.out.println("List: " + list);
  18.  
  19.         // 使用var声明迭代器
  20.         for (var item : list) {
  21.             System.out.println("Item: " + item);
  22.         }
  23.     }
  24. }

        从上述的代码我们可以看到，我们使用var关键词来声明变量，其会自动的推断类型。这大大的方便了我们声明变量。

注意：

        虽然var关键词可以推断出变量的类型，但是不要什么时候都使用var关键词来声明变量，一般在类型名称非常长的时候，例如泛型，我们会使用var来简化代码。

例如：

  1. public static void main(String[] args) {
  2.     Map<String, List<Map<Integer, String>>> complexMap = new HashMap<String,
  3.                 List<Map<Integer, String>>>();
  4.  
  5.     //使用var关键词进行简化 
  6.     var complexMap2 = new HashMap<String, List<Map<Integer, String>>>();
  7. }

我们可以发现这样我们的代码繁琐度大大的简化了。

注意事项：

  • var只能用于局部变量声明，不能用于成员变量、方法参数或返回类型。

  • 变量必须在声明时初始化，因为编译器需要根据初始化值来推断变量类型。

  • var不能用于没有初始化值的变量声明。

  • var不能用于null初始化，因为无法推断类型。

以上就是Java中的var关键词的使用了。

3.密封类 - sealed

        在讲解sealed关键词之前，先让我们讲解一下什么是密封类：

        密封类（Sealed Classes）是一项语言特性，旨在更好地控制类层次结构中的继承关系。通过使用密封类，开发者可以明确指定哪些类可以继承某个类，从而增强类型安全性和代码可维护性。

我们知道，在Java中使用final修饰的类为密封类，其作用就是不能被其他类所继承，如果被继承就会报错，例如：

  1. // 定义一个final类
  2. public final class FinalClass {
  3.     private String message;
  4.  
  5.     public FinalClass(String message) {
  6.         this.message = message;
  7.     }
  8.  
  9.     public String getMessage() {
  10.         return message;
  11.     }
  12.  
  13.     public void setMessage(String message) {
  14.         this.message = message;
  15.     }
  16. }
  17.  
  18. // 尝试继承final类
  19. public class SubClass extends FinalClass {  // 这行会导致编译错误
  20.     public SubClass(String message) {
  21.         super(message);
  22.     }
  23. }

        当然，在JDK17中提供了一个新的关键字： sealed 。它允许你显式地列出可以扩展某个类或实现某个接口的类，从而增强了类型安全性和可维护性。

     

         —— 那么怎么使用sealed关键词呢？

     

使用sealed关键字的步骤如下：

  1. （1）声明一个sealed类或接口。

  2. （2）使用permits关键字明确允许哪些类可以继承该sealed类或接口。

  3. （3）被允许的子类必须是final，sealed，或non-sealed的。

让我们直接使用案例来帮助你进行理解：（代码如下）

  1. // 定义一个sealed类
  2. public sealed class Shape permits Circle, Rectangle, Square {
  3.     // 声明一个抽象方法area，要求任何继承Shape的子类必须实现这个方法
  4.     public abstract double area();
  5. }
  6.  
  7. // 定义一个final子类
  8. public final class Circle extends Shape {
  9.     // 声明一个私有的最终变量radius，用于存储圆的半径
  10.     private final double radius;
  11.  
  12.     // Circle类的构造方法，接收一个半径参数并初始化radius
  13.     public Circle(double radius) {
  14.         this.radius = radius;
  15.     }
  16.  
  17.     // 实现Shape类中声明的抽象方法area，计算并返回圆的面积
  18.     @Override
  19.     public double area() {
  20.         return Math.PI * radius * radius;
  21.     }
  22. }
  23.  
  24. // 定义一个sealed子类
  25. public sealed class Rectangle extends Shape permits FilledRectangle {
  26.     // 声明两个私有的最终变量width和height，用于存储矩形的宽和高
  27.     private final double width;
  28.     private final double height;
  29.  
  30.     // Rectangle类的构造方法，接收矩形的宽和高参数并初始化width和height
  31.     public Rectangle(double width, double height) {
  32.         this.width = width;
  33.         this.height = height;
  34.     }
  35.  
  36.     // 实现Shape类中声明的抽象方法area，计算并返回矩形的面积
  37.     @Override
  38.     public double area() {
  39.         return width * height;
  40.     }
  41. }
  42.  
  43. // 定义一个non-sealed子类
  44. public non-sealed class Square extends Shape {
  45.     // 声明一个私有的最终变量side，用于存储正方形的边长
  46.     private final double side;
  47.  
  48.     // Square类的构造方法，接收一个边长参数并初始化side
  49.     public Square(double side) {
  50.         this.side = side;
  51.     }
  52.  
  53.     // 实现Shape类中声明的抽象方法area，计算并返回正方形的面积
  54.     @Override
  55.     public double area() {
  56.         return side * side;
  57.     }
  58. }
  59.  
  60. // 进一步定义一个final子类
  61. public final class FilledRectangle extends Rectangle {
  62.     // 声明一个私有的最终变量color，用于存储填充矩形的颜色
  63.     private final String color;
  64.  
  65.     // FilledRectangle类的构造方法，接收矩形的宽、高和颜色参数，并调用父类Rectangle的构造方法进行初始化
  66.     public FilledRectangle(double width, double height, String color) {
  67.         super(width, height);
  68.         this.color = color;
  69.     }
  70.  
  71.     // 添加一个额外的方法getColor，用于获取填充矩形的颜色
  72.     public String getColor() {
  73.         return color;
  74.     }
  75. }

在这个例子中：

1. Shape是一个sealed类，只有Circle，Rectangle和Square可以继承它。

2. Circle是一个final类，不能被进一步继承。

3. Rectangle是一个sealed类，只有FilledRectangle可以继承它。

4. Square是一个non-sealed类，可以被进一步继承

并且我们要注意：

        1. sealed修饰的类必须要有子类；

        2. 未被permits 允许的类型，则没办法继承；

        3. 子类使用final修饰则不可以继承发生继承；

        4. 子类使用 non-sealed 关键字修饰。表示不限制，任何类都可以继承；

        5. 子类使用sealed关键词的可以继承发生继承；

这样我们就大致的了解了sealed关键词了。

4.接口中的私有方法

        在接口中的私有方法常常用于对接口中的default修饰的方法和静态方法进行辅助，将其内部的代码进行封装简化。

例如：

  1. interface HelloService {
  2.     public void sayHello();
  3.     // 默认方法
  4.     default void saySomething(){
  5.         syaEngHello();
  6.         sayHello();
  7.     };
  8.     // 私有方法
  9.     private void syaEngHello(){
  10.         System.out.println("Hello!");
  11.     }

        接口的私有方法为Java语言引入了更多的灵活性和功能性，可以帮助编写更干净、更模块化的代码，提升了接口的设计和实现的效率和质量。

        这就是Java中接口中的私有方法的使用。

5.instanceof关键词

        在Java中，instanceof是一个关键字，用于测试一个对象是否是一个类的实例或者是其子类的实例。它的语法形式如下：

object instanceof type

        其中，object是要检查的对象，type是一个类名或接口名。instanceof操作符的作用是检查object是否是type类型的实例，或者是type类型的子类的实例。它返回一个布尔值，如果object是type类型或其子类的实例，则返回true；否则返回false。

        ——接下来让我们使用一个实例来进行对其进一步理解：

  1. class Animal {
  2.     // Animal 类的成员和方法
  3. }
  4.  
  5. class Dog extends Animal {
  6.     // Dog 类的成员和方法
  7. }
  8.  
  9. public class Main {
  10.     public static void main(String[] args) {
  11.         Animal animal = new Dog(); // 创建一个 Dog 对象并赋值给 Animal 类型的变量
  12.  
  13.         // 使用 instanceof 来检查对象的类型
  14.         if (animal instanceof Dog) {
  15.             System.out.println("animal 是 Dog 类的实例");
  16.         }
  17.         
  18.         if (animal instanceof Animal) {
  19.             System.out.println("animal 是 Animal 类的实例");
  20.         }
  21.         
  22.         if (animal instanceof Object) {
  23.             System.out.println("animal 是 Object 类的实例");
  24.         }
  25.     }
  26. }

解释：

  1. Animal是一个类，Dog是Animal的子类。

  2. 在main方法中，创建了一个Dog对象，并将其赋值给一个Animal类型的变量animal。

  3. 使用instanceof关键字，首先检查animal是否是Dog类的实例，结果为true，因为animal确实是Dog类的实例。

  4. 接着检查animal是否是Animal类的实例，同样为true，因为Dog类是Animal类的子类。

  5. 最后检查animal是否是Object类的实例，结果同样为true，因为所有类在Java中最终都是继承自Object类的。

        通过上面的讲解，我相信你已经对Java中instanceof关键词有了一定的理解，那么instanceof关键词有什么用处呢？

instanceof的用途：

  • 类型检查和转换：instanceof通常用于在运行时检查对象的类型，以便进行类型转换或根据对象的实际类型执行特定的操作。

  • 条件控制：可以根据对象的类型来决定执行不同的代码路径，以实现多态性和灵活的程序逻辑。

  • 安全性检查：在某些情况下，使用instanceof可以帮助避免类型转换异常（ClassCastException），在进行类型转换之前先检查对象的类型是否符合预期。

这样我们就大致的了解了Java中的instanceof关键词了。

以上就是本篇文章的全部内容了~~~

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/814523
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号