[关闭]
@levinzhang 2020-08-11T06:13:26.000000Z 字数 9685 阅读 550

Java的新未来

摘要

本文分析了JVM上语言的发展历史，探讨了不同语言的特点。来自不同语言的竞争促使Java不断吸收新的特性，更加适应时代和开发人员的新需求。

本文最初发表于The Bored Dev网站，由InfoQ中文站翻译分享。

我们行业始终有一个热门话题，那就是对Java的批判，这种批判很大程度上来源于Java的繁琐性以及它所生成的大量样板式代码，而这些代码在很多场景下是根本不需要的。虽然我一直以来都很喜欢Java，但是我不能说这些指责是错误的。的确，Java的繁琐性以及数量不菲的杂乱代码在很多情况下会很烦人。在大多数情况下，我们不得不接受我们生活在一个不完美的世界这一现实，很多时候，我们必须两害相权取其轻。我们都知道，Java并不完美，但是主要的问题在于在此之前为什么没有采取任何措施来解决这些问题呢。

我认为，变更需要耗费这么长时间的唯一原因就是Java缺乏足够的竞争。Java语言之所以能够主导市场，可能就是因为缺乏真正的竞争对手，也要归功于Sun和Oracle先后做出的巨大努力。

Java提供的强类型安全性以及作为一个结构良好的语言所带来的其他特性使其成为大型项目中的非常流行的语言。通过使用Java，我们很少会让事情变得难以收拾。Java的另外一个重要特点是作为多平台语言，它运行在自己的虚拟机上，这使其能够完美契合很多的组织。如果你通过著名的JIT编译器启用了其自动性能优化的固有能力，那么在很多情况下都能将糟糕代码所带来的影响最小化，那么我们有了一组使用Java的坚实理由。

但是，后来发生了什么呢？接下来的事情就是，能够像Java那样运行在相同JVM中的新语言推向了市场，这些语言消除了Java中最令人挠头的问题，并为开发人员提供了更好的环境，在很多情况下，它们的学习曲线非常平坦。

在继续下面的内容之前，我们简要回顾一下JVM语言的历史。

JVM语言的历史

在开始之前，我想澄清一点，那就是我省略掉了一些现有的JVM语言，这主要是因为它们从来没有具备足够强的吸引力，不能视为我们行业中广泛使用的候选语言。那么，我们就开始快速回顾一下JVM语言的历史。

java_code.jpg?resize=768%2C513&ssl=1未知大小

图片出自Unsplash站点，作者为Maximilian Weisbecker

我们的旅程当然要从Java开始，它是JVM领域最古老和最流行的语言。

Java语言最初是在1996年1月份正式发布的，所以它已经有24年的历史了，怎么样，还不错吧？最初，Java是一种命令式的语言，遵循纯粹的面向对象程序风格，同时也是强类型语言。Java的语法在某种程度上与C++和C语言很相似，但它被认为是一个改进版本，因为使用Java编写代码要比使用C或C++容易得多。另外，在它的批评者中，最大的争议在于其繁琐性。

第二个发布的JVM语言是Groovy，它最早出现于2003年，不过其第一个官方和标准版本1.0是在2007年才发布的。Groovy的好处在于，它还可以用作脚本语言。Groovy是一种动态类型语言，所以类型检查是在运行时进行的；这也是一些开发人员不喜欢Groovy的原因之一。我们使用Groovy编写代码，在编译时看起来它是正确的，但是在运行时，我们才会发现其中有问题。

groovy.png?resize=768%2C383&ssl=1未知大小
图片来源：维基百科

接下来出现了另外一种流行的语言，也就是我们要讨论的Scala。Scala在2004年正式发布，它为JVM领域带来了一种新的编程模型，也就是函数式编程和它的声明式方法。我们可以确定Scala率先引入了不可变性（immutability）的理念，所以它对Java的转变做出了重要贡献。但另一方面，Scala的批评者并不喜欢它，因为它语法复杂，可读性一般比较差。

scala.png?w=493&ssl=1未知大小

图片来源：维基百科

JVM领域出现的下一个语言是Clojure，它是一个纯函数式的语言，最近它变得非常流行，但是它最早出现于2007年。Clojure是一种基于LISP的语言，其特点是简单和使用纯函数。在它的缺点中，值得一提的是动态类型（与Groovy相同），而且学习曲线更陡峭，因为它的语法与其他JVM语言完全不同。如果你对学习Clojure感兴趣的话，那么应该阅读如下这两本好书：“The joy of Clojure”和“Programming Clojure（第三版）”。

clojure.png?resize=300%2C300&ssl=1未知大小

图片来源：维基百科

最后但同样重要的是Kotlin！Kotlin在2016年2月份首次发布，从那时开始，它就变得不断流行起来。该语言是由JetBrains公司设计的，它有一个明确的目标：消除Java中所有常见的问题。它的设计方式保留了Java中所有的优点，但是消除了它的大多数问题，这也是它为何如此流行的原因，很多人甚至认为在未来的几年中它有可能会击败Java。如果你想要了解Kotlin的更多内容的话（我鼓励你这样做，因为它是一门伟大的语言），那么我推荐你阅读“Kotlin in Action”一书，对于Java开发人员来说，这是一本入门Kotlin的优秀图书。

kotlin.jpg?resize=768%2C576&ssl=1未知大小

图片出自Unsplash站点，作者为Louis Tsai

这就是最重要的JVM语言，我们省略了一些不太流行的JVM语言，但是我们可以提一下它们的名字：Jython、JRuby、Ceylon、Fantom等等。你可以通过该地址获取现有JVM语言的全部列表。

我们可以发现，在最初的八年或十年间，Java并没有太多的竞争对手，但从那之后，Java就面临一些竞争了，那么有竞争是一件好事儿还是坏事儿呢？

竞争加剧所带来的好处

正如我们在前文所述，Java在早期并没有太多的改变，这很可能是因为没有这种必要性，尽管它远远称不上完美，但是得到了广泛的使用。

但是，新的竞争者出现了，这些更现代的语言带来了新的特性，解决了长期困扰Java开发人员的一些痛点。

举例来说，我们看一下Scala语言，自2009年以来，Scala变得越来越受欢迎，开发人员欢迎这种新的函数式风格，它能够让他们的编码更灵活，也能安全轻松地编写出并行代码。我们可以在下面的谷歌趋势图中看到这个趋势：

Screenshot-2020-07-23-at-21.11.59.png?resize=768%2C408&ssl=1未知大小
图片来源：theboreddev.com

那Oracle对这种新趋势的反应是什么呢？那就是在2014年发布了Java Lambdas和Streams。我觉得我们都同意当时这是Java击败Scala的最大举措。目前行业中的每个人都能感受到最近几年Scala因为缺少流所遭受的损失。

JVM领域中存在竞争者的另外一个好处就是JIT编译器和JVM本身正在经历的持续改进。现在，有更多的人对JVM优化和性能改善感兴趣。所以，竞争对每个人都是好事。

在这个领域，最新的竞争者是Kotlin，Kotlin非常重要，因为它在一定程度上为Oracle指明了前进方向。Kotlin表明它能够保持Java好的组成部分,同时创建一个更简洁和快速的编码语言。

如果看一下谷歌趋势的话，我们能够看到在过去的几年间，Kotlin的流行程度：

Screenshot-2020-07-24-at-08.52.50.png?resize=768%2C407&ssl=1未知大小

图片来源：theboreddev.com

从图中可以看出，Kotlin迅速变得非常流行，但是在最近几年，它似乎稳定了下来。

Oracle很好地记录了业界对Kotlin的反应，如果你看一下JDK 15的发布说明的话，就会发现Java的一些新特性基本上就是对Kotlin变更的复制。例如，新的Java record、文本块（使用三个引号的多行字符串）以及switch语句（或多或少借鉴了Kotlin的when语句）。我们可以通过该地址查阅JDK 15的发布说明。

刚才提到的这些，我都将其称为“Java的Kotlin化（Kotlinisation）”。Kotlin通过成为Java有史以来最强的竞争对手，为Java指明了发展的方向。在我看来，Kotlin是我见过的唯一一种能够战胜Java，并成为行业领导者的语言。

Java的“Kotlin”化

Java的一些新特性主要在可读性方面进行了增强，并改善了其主要的一个弱点，那就是繁琐性。我们可以断言，它与某些Kotlin的特性具有相似性。

需要注意，这些特性大多数都是特性预览阶段，这意味着如果你安装JDK 14或JDK 15的时候，默认是不会启用它们的。

Java特性预览指的是一些在发布版本中包含的特性，但是默认是禁用的。在发行版中包含它们仅仅是为了收集社区开发人员的反馈，因此它们更易于发生变更，这也是为何不推荐在生产环境代码中使用它们的原因。

要在编译时启用它们，我们需要执行如下代码：

  1. javac --enable-preview --release 14

如果你想要在运行时启用它们的话，如下执行如下代码：

  1. java --enable-preview YourClass

当然，你也可以在IDE中启用它们，但是不要在你的新项目中默认启用预览功能。

我们看一看这些变更，在未来的Java版本中，它们会对我们的编码产生更大的影响。

Java record

Java record是我们长期以来一直要求的一项特性，我相信你早就多次遇到这样的场景了，那就是极不情愿地实现toString、hashCode、equals方法以及每个字段的getter（在这里，我假设你已经不再实现setter了，还记得我们在“Java中新的并发模型”一文中所讨论的不可变性吗？）。

Kotlin提供了数据类（data class）来解决这个问题，Java也通过发布record类来解决了这个问题，同样的问题，Scala是通过case类来解决的。

这些类的主要目的是在对象中保存不可变的数据。让我们通过一个示例来看看在Java中能够带来多么好的效果。我们实例化并对比Employee类，需要编写这么多的代码：

  1. package com.theboreddev.java14;
  3. import java.util.Objects;
  5. public class Employee {
  6.     private final String firstName;
  7.     private final String surname;
  8.     private final int age;
  9.     private final Address address;
  10.     private final double salary;
  12.     public Employee(String firstName, String surname, int age, Address address, double salary) {
  13.         this.firstName = firstName;
  14.         this.surname = surname;
  15.         this.age = age;
  16.         this.address = address;
  17.         this.salary = salary;
  18.     }
  20.     public String getFirstName() {
  21.         return firstName;
  22.     }
  24.     public String getSurname() {
  25.         return surname;
  26.     }
  28.     public int getAge() {
  29.         return age;
  30.     }
  32.     public Address getAddress() {
  33.         return address;
  34.     }
  36.     public double getSalary() {
  37.         return salary;
  38.     }
  40.     @Override
  41.     public boolean equals(Object o) {
  42.         if (this == o) return true;
  43.         if (o == null || getClass() != o.getClass()) return false;
  44.         Employee employee = (Employee) o;
  45.         return age == employee.age &&
  46.                 Double.compare(employee.salary, salary) == 0 &&
  47.                 Objects.equals(firstName, employee.firstName) &&
  48.                 Objects.equals(surname, employee.surname) &&
  49.                 Objects.equals(address, employee.address);
  50.     }
  52.     @Override
  53.     public int hashCode() {
  54.         return Objects.hash(firstName, surname, age, address, salary);
  55.     }
  57.     @Override
  58.     public String toString() {
  59.         return "Employee{" +
  60.                 "firstName='" + firstName + '\'' +
  61.                 ", surname='" + surname + '\'' +
  62.                 ", age=" + age +
  63.                 ", address=" + address +
  64.                 ", salary=" + salary +
  65.                 '}';
  66.     }
  67. }

它所包含的Address对象如下所示：

  1. package com.theboreddev.java14;
  3. import java.util.Objects;
  5. public class Address {
  6.     private final String firstLine;
  7.     private final String secondLine;
  8.     private final String postCode;
  10.     public Address(String firstLine, String secondLine, String postCode) {
  11.         this.firstLine = firstLine;
  12.         this.secondLine = secondLine;
  13.         this.postCode = postCode;
  14.     }
  16.     public String getFirstLine() {
  17.         return firstLine;
  18.     }
  20.     public String getSecondLine() {
  21.         return secondLine;
  22.     }
  24.     public String getPostCode() {
  25.         return postCode;
  26.     }
  28.     @Override
  29.     public boolean equals(Object o) {
  30.         if (this == o) return true;
  31.         if (o == null || getClass() != o.getClass()) return false;
  32.         Address address = (Address) o;
  33.         return Objects.equals(firstLine, address.firstLine) &&
  34.                 Objects.equals(secondLine, address.secondLine) &&
  35.                 Objects.equals(postCode, address.postCode);
  36.     }
  38.     @Override
  39.     public int hashCode() {
  40.         return Objects.hash(firstLine, secondLine, postCode);
  41.     }
  43.     @Override
  44.     public String toString() {
  45.         return "Address{" +
  46.                 "firstLine='" + firstLine + '\'' +
  47.                 ", secondLine='" + secondLine + '\'' +
  48.                 ", postCode='" + postCode + '\'' +
  49.                 '}';
  50.     }
  51. }

为了完成一件简单的事情，我们写了太多的代码，对不对？

接下来，我们看一下使用新的Java record之后，代码会是什么样子：

  1. public record EmployeeRecord(String firstName, String surname, int age, AddressRecord address, double salary) { 
  2. }

再看一下Address类：

  1. public record AddressRecord(String firstLine, String secondLine, String postCode) {
  2. }

这和我们前面所编写的一大堆代码是同样的效果，我们不得不承认：这非常棒！从要保存的代码数量和简洁性方面都是如此。

现在我们看看新的switch语句有什么不同！

改善switch语句

新的switch语句解决了在Java中使用switch语句的一些固有问题。现在，我们都被教导应该避免使用switch语句，因为它们很容易出错并会导致代码重复。举例来说，我们很容易遇到某个case条件覆盖不到的场景。

新的switch语句解决了这个问题，因为如果我们的switch语句没有涵盖我们所传递给它的领域类型的所有范围的话，它不会编译通过。

为了阐述该例子，我们使用Java创建一个DayOfTheWeek枚举：

  1. public enum DayOfTheWeek {
  2.     MONDAY,
  3.     TUESDAY,
  4.     WEDNESDAY,
  5.     THURSDAY,
  6.     FRIDAY,
  7.     SATURDAY,
  8.     SUNDAY
  9. }

我们的switch语句会告诉我们每周的某一天所对应的位置。我们看一下通过Java 11该怎么实现：

  1. final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY;
  3.         int position = 0;
  5.         switch (dayOfTheWeek) {
  6.             case MONDAY:
  7.                 position = 1;
  8.                 break;
  9.             case TUESDAY:
  10.                 position = 2;
  11.                 break;
  12.             case WEDNESDAY:
  13.                 position = 3;
  14.                 break;
  15.             case THURSDAY:
  16.                 position = 4;
  17.                 break;
  18.             case FRIDAY:
  19.                 position = 5;
  20.                 break;
  21.             case SATURDAY:
  22.                 position = 6;
  23.                 break;
  24.             case SUNDAY:
  25.                 position = 7;
  26.                 break;
  27.         }
  29.         System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week");

使用当前的switch语句时，我们必须要使用一个变量，而且如果我们遗漏了一周中的某一天的话，代码完全也能编译通过。这就是switch语句的问题之一，也就是非常易于出错。

Java 14会怎样改善这种场景呢？我们快速看一下：

  1. final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY;
  3.         int position = switch (dayOfTheWeek) {
  4.             case MONDAY -> 1;
  5.             case TUESDAY -> 2;
  6.             case WEDNESDAY -> 3;
  7.             case THURSDAY -> 4;
  8.             case FRIDAY -> 5;
  9.             case SATURDAY -> 6;
  10.             case SUNDAY -> 7;
  11.         };
  13.         System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week");

我们可以看到，新的switch语句可以用作表达式，而不仅仅是语句。

这样带来的结果就是更加简洁，也更具有表述性，这就足以说服我们使用它了。但是，现在的switch还有一个重要的改善，那就是如果在switch中没有涵盖所有的case的话，它将不会编译。它会显示如下的错误：

  1. Error:(9, 24) java: the switch expression does not cover all possible input values

现在，我们不会在switch语句中遗漏case了，这是一项非常棒的特性。

这非常类似于Kotlin的when语句，你可以通过该地址了解该语句的更多信息。

接下来，我们看一下文本块。

文本块

你有没有遇到过将一个大的blob JSON赋值给Java变量的场景？你是否也受够了这种丑陋的代码？Java将会引入多行字符串特性，我们可以通过将它们封装在三重引号中来定义它们。当这个功能被正式发布后，定义多行长字符串会更加容易。

我们来看一下两种模式的差异。此时，我们想要将一个格式化后的JSON存储到一个变量中，那么丑陋的代码如下所示：

  1. final String text = "{\"widget\": {\n" +
  2.                 "    \"debug\": \"on\",\n" +
  3.                 "    \"window\": {\n" +
  4.                 "        \"title\": \"Sample Konfabulator Widget\",\n" +
  5.                 "        \"name\": \"main_window\",\n" +
  6.                 "        \"width\": 500,\n" +
  7.                 "        \"height\": 500\n" +
  8.                 "    },\n" +
  9.                 "    \"image\": { \n" +
  10.                 "        \"src\": \"Images/Sun.png\",\n" +
  11.                 "        \"name\": \"sun1\",\n" +
  12.                 "        \"hOffset\": 250,\n" +
  13.                 "        \"vOffset\": 250,\n" +
  14.                 "        \"alignment\": \"center\"\n" +
  15.                 "    },\n" +
  16.                 "    \"text\": {\n" +
  17.                 "        \"data\": \"Click Here\",\n" +
  18.                 "        \"size\": 36,\n" +
  19.                 "        \"style\": \"bold\",\n" +
  20.                 "        \"name\": \"text1\",\n" +
  21.                 "        \"hOffset\": 250,\n" +
  22.                 "        \"vOffset\": 100,\n" +
  23.                 "        \"alignment\": \"center\",\n" +
  24.                 "        \"onMouseUp\": \"sun1.opacity = (sun1.opacity / 100) * 90;\"\n" +
  25.                 "    }\n" +
  26.                 "}} ";

在新的多行字符串功能发布之后，我们就可以更容易地编写整洁的代码了：

  1. final String multiLineText = """
  2.                 {"widget": {
  3.                     "debug": "on",
  4.                     "window": {
  5.                         "title": "Sample Konfabulator Widget",
  6.                         "name": "main_window",
  7.                         "width": 500,
  8.                         "height": 500
  9.                     },
  10.                     "image": {\s
  11.                         "src": "Images/Sun.png",
  12.                         "name": "sun1",
  13.                         "hOffset": 250,
  14.                         "vOffset": 250,
  15.                         "alignment": "center"
  16.                     },
  17.                     "text": {
  18.                         "data": "Click Here",
  19.                         "size": 36,
  20.                         "style": "bold",
  21.                         "name": "text1",
  22.                         "hOffset": 250,
  23.                         "vOffset": 100,
  24.                         "alignment": "center",
  25.                         "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
  26.                     }
  27.                 }}
  28.                 """;

我觉得这样的话就好太多了。这也是Kotlin所支持的，可以在这里的类型定义中找到。

因此，我们看到Java从它的竞争对手之一，也就是Kotlin，那里“继承”许多方案来解决自己的问题。我们不知道这次Oracle在对抗Kotlin的崛起方面是否及时做出了正确的反应，或许这有点太晚了。我个人认为Java正在朝着正确的方向前进，尽管这些变化是由它的竞争对手以某种方式触发的，而且可能来得有点迟了。

如前所述，如果这篇文章激发了你学习Kotlin语言的兴趣，我建议你阅读“Kotlin in Action”，对于Java开发人员来说，这是一门很棒的Kotlin入门图书。

结论

我认为竞争是Java语言有史以来所遇到的最好的事情。在我的印象中，如果不这样，Java就会作茧自缚。Java的竞争对手也表明了不同的编程方式是可行的，它表明了前进的方向，并让我们避免使用老式的、陈旧的编写代码的方式。

我最近在Java中看到了一些变化，以及所有即将发布的特性和改善，它们正在使Java变得比以往任何时候都更强大。它是一种适应当前时代的语言，一种希望发展并忘记传统做事方式的语言：Java的新未来！

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注