你可能未曾使用的新Java特性

 Java 是在过去 20 年中一直在市场流行的编程语言。

蒙山网站制作公司哪家好，找创新互联！从网页设计、网站建设、微信开发、APP开发、成都响应式网站建设公司等网站项目制作，到程序开发，运营维护。创新互联2013年开创至今到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联。

但是最近几年各种替代 Java 的声音不断。

与 Python，Kotlin，Swift 等现代编程语言相比，开发人员抱怨 Java 过时的编程语法。

但是很多人不知道的是，Java 新版做了很多改进，并为开发人员提供了更有效的方式来编写代码。

如果您想用 Java 更轻松编写简洁和优雅的代码，可以参考以下一些建议，这些语法在 JDK 14 已经提供。

1 Try-with-resource 语句

使用 try-catch 块处理异常，通常需要通过 finally 块来添加清除代码。现在使用 try with resource 语法，开发人员就不用自己操心资源释放。

我们可以在 try 括号内添加资源，以便在 try-catch 块执行后关闭或清理该资源

旧语法

 
 
 
 
    
  
  
  
  
  1. Scanner scanner = null;
    2. 
  
  
  
  
  2. try {
    3. 
  
  
  
  
  3.     scanner = new Scanner(new File("foo.txt"));
    4. 
  
  
  
  
  4.     while (scanner.hasNext()) {
    5. 
  
  
  
  
  5.         System.out.println(scanner.nextLine());
    6. 
  
  
  
  
  6.     }
    7. 
  
  
  
  
  7. } catch (FileNotFoundException e) {
    8. 
  
  
  
  
  8.     e.printStackTrace();
    9. 
  
  
  
  
  9. } finally {
    10. 
  
  
  
  
  10.     if (scanner != null) scanner.close();
    11. 
  
  
  
  
  11. }
    12.

新语法

 
 
 
 
    
  
  
  
  
  1. try (Scanner scanner = new Scanner(new File("foo.txt"))) {
    2. 
  
  
  
  
  2.     while (scanner.hasNext()) {
    3. 
  
  
  
  
  3.         System.out.println(scanner.nextLine());
    4. 
  
  
  
  
  4.     }
    5. 
  
  
  
  
  5. } catch (FileNotFoundException e) {
    6. 
  
  
  
  
  6.     e.printStackTrace();
    7. 
  
  
  
  
  7. }
    8.

这将大大减少关闭流或数据库连接的代码行，并减少由于忘记关闭流/连接而导致各种错误的问题。

2 switch 表达式

开发人员经常遇到需要从条件块返回值的情况，但是旧的语法不好解决。

旧语法

 
 
 
 
    
  
  
  
  
  1. private String getUserRole(User user){
    2. 
  
  
  
  
  2.     String userRole = "";
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.     switch(user.getRole()){
    5. 
  
  
  
  
  5.         case 0:
    6. 
  
  
  
  
  6.             userRole = "Customer";
    7. 
  
  
  
  
  7.             break;
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.         case 1:
    10. 
  
  
  
  
  10.             userRole = "Editor";
    11. 
  
  
  
  
  11.             break;
    12. 
  
  
  
  
  12. 
  
  
  
  
  13.         case 2:
    14. 
  
  
  
  
  14.             userRole = "Admin";
    15. 
  
  
  
  
  15.             break;
    16. 
  
  
  
  
  16. 
  
  
  
  
  17.         default: throw new IllegalStateException("Unexpected value: " + user.getRole());
    18. 
  
  
  
  
  18.     }
    19. 
  
  
  
  
  19.     return userRole;
    20. 
  
  
  
  
  20. }
    21.

就像 Swift 这些现代语言一样，Java 12 引入了 switch 表达式，你可以根据条件返回值。

新语法

 
 
 
 
    
  
  
  
  
  1. private String getUserRoleV2(User user){
    2. 
  
  
  
  
  2. 
  
  
  
  
  3.     return switch(user.getRole()){
    4. 
  
  
  
  
  4.         case 0 -> "Customer";
    5. 
  
  
  
  
  5.         case 1 -> "Editor";
    6. 
  
  
  
  
  6.         case 2 :
    7. 
  
  
  
  
  7.             // for multi line expression use 'yield' keyword
    8. 
  
  
  
  
  8.             user.setRights(AuthRights.absolute);
    9. 
  
  
  
  
  9.             yield "Admin";
    10. 
  
  
  
  
  10.         default -> throw new IllegalStateException("Unexpected value: " + user.getRole());
    11. 
  
  
  
  
  11.     };
    12. 
  
  
  
  
  12. }
    13.

这大大减少了项目中的 LOC(代码行)，并使修改相对容易。

3 用 var 初始化

Java 本质上是严格类型的语言，使用严格类型定义是开发人员偏好的问题。但是支持类型推断可以降低代码复杂性，Java 10 增加了对局部变量的类型推断的支持。

 
 
 
 
    
  
  
  
  
  1. private void init(){
    2. 
  
  
  
  
  2.     var str = "Java 10"; // infers String
    3. 
  
  
  
  
  3.     var list = new ArrayList(); 
    4. 
  
  
  
  
  4.     var stream = list.stream(); // infers Stream
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. }
    7.

但 Java 仍然是一种静态类型的语言，仅在有足够的信息可用于初始化时才推断类型。因此如果变量满足以下条件，则使用 var 初始化是合法的：

  • 它只能是局部变量(类成员或函数参数不支持)
  • 声明后应立即定义(define)

4 记录 (record)

使用 Java 最常见的抱怨之一，需要编写大量代码来使类可用，例如一堆 toString 或 equals 定义，因此代码看起来很冗长。Java 14 提供了 Record 语法，使类型声明更加简洁，当我们需要在一个类名下绑定多个值时，它非常有用。

这是 Oracle 网站上的一篇文章示例，展示了使用记录的优势

 
 
 
 
    
  
  
  
  
  1. var order = new FXOrderClassic(1, 
    2. 
  
  
  
  
  2.         CurrencyPair.GBPUSD,
    3. 
  
  
  
  
  3.         Side.Bid, 1.25, 
    4. 
  
  
  
  
  4.         LocalDateTime.now(), 
    5. 
  
  
  
  
  5.         1000);
    6.

像这样的标准对象的调用，需要定义类型 FXOrderClassic。

旧语法

 
 
 
 
    
  
  
  
  
  1. public final class FXOrderClassic {
    2. 
  
  
  
  
  2.     private final int units;
    3. 
  
  
  
  
  3.     private final CurrencyPair pair;
    4. 
  
  
  
  
  4.     private final Side side;
    5. 
  
  
  
  
  5.     private final double price;
    6. 
  
  
  
  
  6.     private final LocalDateTime sentAt;
    7. 
  
  
  
  
  7.     private final int ttl;
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     public FXOrderClassic(int units,
    10. 
  
  
  
  
  10.                           CurrencyPair pair,
    11. 
  
  
  
  
  11.                           Side side,
    12. 
  
  
  
  
  12.                           double price,
    13. 
  
  
  
  
  13.                           LocalDateTime sentAt,
    14. 
  
  
  
  
  14.                           int ttl) {
    15. 
  
  
  
  
  15.         this.units = units;
    16. 
  
  
  
  
  16.         this.pair = pair; // CurrencyPair is a simple enum
    17. 
  
  
  
  
  17.         this.side = side; // Side is a simple enum
    18. 
  
  
  
  
  18.         this.price = price;
    19. 
  
  
  
  
  19.         this.sentAt = sentAt;
    20. 
  
  
  
  
  20.         this.ttl = ttl;
    21. 
  
  
  
  
  21.     }
    22. 
  
  
  
  
  22. 
  
  
  
  
  23.     public int units() {
    24. 
  
  
  
  
  24.         return units;
    25. 
  
  
  
  
  25.     }
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.     public CurrencyPair pair() {
    28. 
  
  
  
  
  28.         return pair;
    29. 
  
  
  
  
  29.     }
    30. 
  
  
  
  
  30. 
  
  
  
  
  31.     public Side side() {
    32. 
  
  
  
  
  32.         return side;
    33. 
  
  
  
  
  33.     }
    34. 
  
  
  
  
  34. 
  
  
  
  
  35.     public double price() { return price; }
    36. 
  
  
  
  
  36. 
  
  
  
  
  37.     public LocalDateTime sentAt() {
    38. 
  
  
  
  
  38.         return sentAt;
    39. 
  
  
  
  
  39.     }
    40. 
  
  
  
  
  40. 
  
  
  
  
  41.     public int ttl() {
    42. 
  
  
  
  
  42.         return ttl;
    43. 
  
  
  
  
  43.     }
    44. 
  
  
  
  
  44. 
  
  
  
  
  45.     @Override
    46. 
  
  
  
  
  46.     public boolean equals(Object o) {
    47. 
  
  
  
  
  47.         if (this == o) return true;
    48. 
  
  
  
  
  48.         if (o == null || getClass() != o.getClass())
    49. 
  
  
  
  
  49.             return false;
    50. 
  
  
  
  
  50. 
  
  
  
  
  51.         FXOrderClassic that = (FXOrderClassic) o;
    52. 
  
  
  
  
  52. 
  
  
  
  
  53.         if (units != that.units) return false;
    54. 
  
  
  
  
  54.         if (Double.compare(that.price, price) != 0)
    55. 
  
  
  
  
  55.             return false;
    56. 
  
  
  
  
  56.         if (ttl != that.ttl) return false;
    57. 
  
  
  
  
  57.         if (pair != that.pair) return false;
    58. 
  
  
  
  
  58.         if (side != that.side) return false;
    59. 
  
  
  
  
  59.         return sentAt != null ?
    60. 
  
  
  
  
  60.                 sentAt.equals(that.sentAt) : that.sentAt == null;
    61. 
  
  
  
  
  61.     }
    62. 
  
  
  
  
  62. 
  
  
  
  
  63.     @Override
    64. 
  
  
  
  
  64.     public int hashCode() {
    65. 
  
  
  
  
  65.         int result;
    66. 
  
  
  
  
  66.         long temp;
    67. 
  
  
  
  
  67.         result = units;
    68. 
  
  
  
  
  68.         result = 31 * result +
    69. 
  
  
  
  
  69.                 (pair != null ? pair.hashCode() : 0);
    70. 
  
  
  
  
  70.         result = 31 * result +
    71. 
  
  
  
  
  71.                 (side != null ? side.hashCode() : 0);
    72. 
  
  
  
  
  72.         temp = Double.doubleToLongBits(price);
    73. 
  
  
  
  
  73.         result = 31 * result +
    74. 
  
  
  
  
  74.                 (int) (temp ^ (temp >>> 32));
    75. 
  
  
  
  
  75.         result = 31 * result +
    76. 
  
  
  
  
  76.                 (sentAt != null ? sentAt.hashCode() : 0);
    77. 
  
  
  
  
  77.         result = 31 * result + ttl;
    78. 
  
  
  
  
  78.         return result;
    79. 
  
  
  
  
  79.     }
    80. 
  
  
  
  
  80. 
  
  
  
  
  81.     @Override
    82. 
  
  
  
  
  82.     public String toString() {
    83. 
  
  
  
  
  83.         return "FXOrderClassic{" +
    84. 
  
  
  
  
  84.                 "units=" + units +
    85. 
  
  
  
  
  85.                 ", pair=" + pair +
    86. 
  
  
  
  
  86.                 ", side=" + side +
    87. 
  
  
  
  
  87.                 ", price=" + price +
    88. 
  
  
  
  
  88.                 ", sentAt=" + sentAt +
    89. 
  
  
  
  
  89.                 ", ttl=" + ttl +
    90. 
  
  
  
  
  90.                 '}';
    91. 
  
  
  
  
  91.     }
    92. 
  
  
  
  
  92. }
    93.

新语法

 
 
 
 
    
  
  
  
  
  1. public record FXOrder(int units,
    2. 
  
  
  
  
  2.                       CurrencyPair pair,
    3. 
  
  
  
  
  3.                       Side side,
    4. 
  
  
  
  
  4.                       double price,
    5. 
  
  
  
  
  5.                       LocalDateTime sentAt,
    6. 
  
  
  
  
  6.                       int ttl) {}
    7.

5 增强的 instance of

Java 14 引入了 instanceof 模式匹配的功能，这意味着在使用 instanceof 的实例类型检查时，不再需要显式的类型转换。

旧语法

 
 
 
 
    
  
  
  
  
  1. private Entries getEntries(User user){
    2. 
  
  
  
  
  2.     if (user instanceof Editor) {
    3. 
  
  
  
  
  3.         Editor editor = (Editor) user;
    4. 
  
  
  
  
  4. 
  
  
  
  
  5.         // use editor specific methods
    6. 
  
  
  
  
  6.         var entries = editor.getEntries();
    7. 
  
  
  
  
  7.         return entries;
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9.     
    10. 
  
  
  
  
  10.     return null;
    11. 
  
  
  
  
  11. }
    12.

新语法

 
 
 
 
    
  
  
  
  
  1. private Entries getEntries(User user){
    2. 
  
  
  
  
  2.     
    3. 
  
  
  
  
  3.     if (user instanceof Editor editor) {
    4. 
  
  
  
  
  4.         // use group specific methods
    5. 
  
  
  
  
  5.         var entries = editor.getEntries();
    6. 
  
  
  
  
  6.         return entries;
    7. 
  
  
  
  
  7.     }
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     return null;
    10. 
  
  
  
  
  10. }
    11.

6 文本块

支持文本块并不是什么新鲜事，但在 Java 中却是工程师期待已久的功能。Java 开发人员总是渴望以更简单的方式打印多行字符串文字，而不使用讨厌的串联。Java 新版支持多行字符串文字。

旧语法

 
 
 
 
    
  
  
  
  
  1. String html = "" +
    2. 
  
  
  
  
  2. "\n\t" + "" +
    3. 
  
  
  
  
  3. "\n\t\t" + "
    \"Hurray! Java 14 is here\"
    " +
    4. 
  
  
  
  
  4. "\n\t" + "" +
    5. 
  
  
  
  
  5. "\n" + "";
    6.

使用三引号 ，就可以使用此功能，该功能在使用结构化字符串时非常方便，例如以一定的对齐方式和间距编写文件或添加多行 html 块

新语法

 
 
 
 
    
  
  
  
  
  1. String html = """
    2. 
  
  
  
  
  2. 
  
  
  
  
  3.   
    4. 
  
  
  
  
  4.     
    "Hurray! Java 14 is here"
    5. 
  
  
  
  
  5.   
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. """;
    8.

7 有意义的 NPE (空指针)消息

空指针异常(NPE)一直是 Java 开发人员的噩梦，并且是开发人员遇到的最常见的问题。

但是 NPE 消息常常不能提供有关该问题的足够信息。

 
 
 
 
    
  
  
  
  
  1. var task = new Task();
    2. 
  
  
  
  
  2. final boolean isDataConsumed = task.getData().getBucket().isConsumed;
    3.

在代码段中，可能存在多个故障点，例如

  • getData()返回一个空值
  • getBucket()返回一个空值

但以下 NPE 报错未提供有关该问题的足够详细信息。

为了解决此问题，Oracle 添加 JEP 358，提供有用的 NullPointExceptions

NullPointerException 通过精确描述哪个变量来提高 JVM 生成错误信息的可用性。

你可以通过在 Java 命令中添加以下标志来使用此功能

-XX:+ShowCodeDetailsInExceptionMessages

使用该标志，JVM 将提供更多有意义的信息，以便跟踪确切的故障点

英文原文：

https://medium.com/swlh/working-with-new-generation-of-java-236e2dc38316

本文转载自微信公众号「高可用架构」，可以通过以下二维码关注。转载本文请联系高可用架构公众号。

当前题目：你可能未曾使用的新Java特性
网站URL：http://www.shufengxianlan.com/qtweb/news32/93532.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网页设计公司知识

分类信息网

温江服务器租用　　 　品牌设计　　 　广安网站建设　　 　创新互联重庆　　 　重庆做网站　　 　买链接　　 　成都外贸网站优化　　 　成都小程序开发公司　　 　成都艺考培训　　 　wap网站制作　　 　网站SEO优化　　 　产品包装设计　　 　成都网站制作公司　　 　成都做网站　　 　乐至网站建设　　 　微信服务号订阅号开发　　 　重庆水土双线托管　　 　云服务器　　 　成都工装公司　　 　成都网站维护