Explication détaillée de neuf nouvelles fonctionnalités de Java

Plus de trois ans après la sortie de Java 8, la date de sortie de la prochaine version en juillet 2017 approche. Vous avez peut-être entendu parler du système de modules de Java 9, mais cette nouvelle version contient de nombreuses autres mises à jour. Voici neuf nouvelles fonctionnalités intéressantes fournies avec Java 9. Les amis qui en ont besoin peuvent s’y référer pour référence. Jetons un coup d’œil ci-dessous.

Cet article partage principalement avec vous neuf nouvelles fonctionnalités de Java 9, qui ont une certaine valeur de référence et d'apprentissage pour tout le monde. Jetons un coup d'œil à l'introduction détaillée :

. 1. Système de modules au niveau de la plate-forme Java

La fonction déterminante de Java 9 est un tout nouveau système de modules. À mesure que les bases de code s’agrandissent, les chances de créer un « code spaghetti » complexe et alambiqué augmentent de façon exponentielle. À l’heure actuelle, vous devez faire face à deux problèmes fondamentaux : il est difficile d’encapsuler véritablement le code et le système n’a pas une idée claire des dépendances entre les différentes parties (c’est-à-dire les fichiers JAR). Chaque classe publique est accessible par n'importe quelle autre classe publique sous le chemin de classe, ce qui peut conduire à une utilisation accidentelle de API qui n'est pas destinée à être accessible au public. De plus, il y a des problèmes avec le chemin de classe lui-même : comment savoir que tous les JAR requis sont déjà là, ou s'il y a des entrées en double ? Le système de modules résout les deux problèmes ? Les fichiers JAR

Modulaires contiennent un descripteur de module supplémentaire. Dans ce descripteur de module, les dépendances sur d'autres modules sont exprimées par des "requires". De plus, l'instruction "exports" contrôle quels packages sont accessibles par d'autres modules. Tous les packages qui ne sont pas exportés sont encapsulés dans des modules par défaut. Voici un exemple de descripteur de module, présent dans le fichier « module-info.java » :

module blog {
 exports com.pluralsight.blog;

 requires cms;
}

On peut afficher le module comme suit :

Veuillez noter : Les deux modules contiennent des packages encapsulés car ils ne sont pas exportés (visualisés à l'aide d'un bouclier orange). Personne n'utilise les classes de ces packages par accident. La plateforme Java elle-même est également modularisée à l'aide de son propre système de modules. En encapsulant les classes internes du JDK, la plateforme est plus sécurisée et l'amélioration continue est plus facile.

2. Liaison

De nouvelles possibilités apparaissent lorsque vous utilisez des modules avec des dépendances explicites et un JDK modulaire. Votre module d'application va désormais déclarer ses dépendances sur les autres modules d'application et sur les modules JDK qu'il utilise. Pourquoi ne pas utiliser ces informations pour créer un environnement d'exécution minimal contenant uniquement les modules nécessaires à l'exécution de l'application ? Ceci est possible avec le nouvel outil jlink de Java 9. Vous pouvez créer une image d'exécution minimale optimisée pour votre application sans utiliser une version installation du JDK entièrement chargée.

3. JShell : Java interactif REPL

De nombreuxlangages multiplesont déjà uneprogrammation interactive Environnement, Java rejoint désormais le club. Vous pouvez lancer jshell depuis la console et lancer directement la saisie et l'exécution du code Java. Les commentaires instantanés de jshell en font un excellent outil pour explorer les API et tester les fonctionnalités du langage.

Test d'une expression régulière Java est un excellent exemple de la façon dont jshell peut vous faciliter la vie. Les coques interactives peuvent également fournir un excellent environnement pédagogique et augmenter la productivité. Vous pouvez en savoir plus ici. Dans le processus d'enseignement aux gens comment écrire Java, il n'est plus nécessaire d'expliquer le non-sens "public static void main(String [] args)".

4. Javadoc amélioré

Parfois, de petites choses peuvent faire une grande différence. Êtes-vous comme moi et utilisez Google pour trouver la bonne page Javadoc ? Ce n’est plus nécessaire. Javadoc prend désormais en charge la recherche dans la documentation de l'API. De plus, la sortie Javadoc est désormais conforme à la norme HTML5. De plus, vous remarquerez que chaque page Javadoc contient des informations sur la source d'une classe de module JDK ou d'une interface.

五、集合工厂方法

通常，您希望在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 “add” 调用，使得代码重复。 Java 9，添加了几种集合工厂方法：

Set<Integer> ints = Set.of(1, 2, 3);
List<String> strings = List.of("first", "second");

除了更短和更好阅读之外，这些方法也可以避免您选择特定的集合实现。 事实上，从工厂方法返回已放入数个元素的集合实现是高度优化的。这是可能的，因为它们是不可变的：在创建后，继续添加元素到这些集合会导致 “UnsupportedOperationException” 。

六、改进的 Stream API

长期以来，Stream API 都是 Java 标准库最好的改进之一。通过这套 API 可以在集合上建立用于转换的申明管道。在 Java 9 中它会变得更好。Stream 接口中添加了 4 个新的方法：dropWhile, takeWhile, ofNullable。还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代：

IntStream.iterate(1, i -> i < 100, i -> i + 1).forEach(System.out::println);

第二个参数是一个 Lambda，它会在当前 IntStream 中的元素到达 100 的时候返回 true。因此这个简单的示例是向控制台打印 1 到 99。

除了对 Stream 本身的扩展，Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 `stram` 将一个 Optional 对象转换为一个(可能是空的) Stream 对象：

Stream<Integer> s = Optional.of(1).stream();

在组合复杂的 Stream 管道时，将 Optional 转换为 Stream 非常有用。

七、私有接口方法

Java 8 为我们带来了接口的默认方法。 接口现在也可以包含行为，而不仅仅是方法签名。 但是，如果在接口上有几个默认方法，代码几乎相同，会发生什么情况？ 通常，您将重构这些方法，调用一个可复用的私有方法。 但默认方法不能是私有的。 将复用代码创建为一个默认方法不是一个解决方案，因为该辅助方法会成为公共API的一部分。 使用 Java 9，您可以向接口添加私有辅助方法来解决此问题：

public interface MyInterface {

  void normalInterfaceMethod();

  default void interfaceMethodWithDefault() { init(); }

  default void anotherDefaultMethod() { init(); }

  // This method is not part of the public API exposed by MyInterface
  private void init() { System.out.println("Initializing"); }
}

如果您使用默认方法开发 API ，那么私有接口方法可能有助于构建其实现。

八、HTTP/2

Java 9 中有新的方式来处理 HTTP 调用。这个迟到的特性用于代替老旧的 `HttpURLConnection` API，并提供对 WebSocket 和 HTTP/2 的支持。注意：新的 HttpClient API 在 Java 9 中以所谓的孵化器模块交付。也就是说，这套 API 不能保证 100% 完成。不过你可以在 Java 9 中开始使用这套 API：

HttpClient client = HttpClient.newHttpClient();

HttpRequest req =
  HttpRequest.newBuilder(URI.create("http://www.google.com"))
       .header("User-Agent","Java")
       .GET()
       .build();


HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandler.asString());

除了这个简单的请求/响应模型之外，HttpClient 还提供了新的 API 来处理 HTTP/2 的特性，比如流和服务端推送。

九、 多版本兼容 JAR

我们最后要来着重介绍的这个特性对于库的维护者而言是个特别好的消息。当一个新版本的 Java 出现的时候，你的库用户要花费数年时间才会切换到这个新的版本。这就意味着库得去向后兼容你想要支持的最老的 Java 版本 (许多情况下就是 Java 6 或者 7)。这实际上意味着未来的很长一段时间，你都不能在库中运用 Java 9 所提供的新特性。幸运的是，多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本：

multirelease.jar
├── META-INF
│  └── versions
│    └── 9
│      └── multirelease
│        └── Helper.class
├── multirelease
  ├── Helper.class
  └── Main.class

在上述场景中， multirelease.jar 可以在 Java 9 中使用, 不过 Helper 这个类使用的不是顶层的 multirelease.Helper 这个 class, 而是处在“META-INF/versions/9”下面的这个。这是特别为 Java 9 准备的 class 版本，可以运用 Java 9 所提供的特性和库。同时，在早期的 Java 诸版本中使用这个 JAR 也是能运行的，因为较老版本的 Java 只会看到顶层的这个 Helper 类。

如你所见，Java 9 提供了一大堆或大或小的功能特性，你准备好了么?

Résumé

[Recommandations associées]

1 Recommandation spéciale : "programmeur php Télécharger. la version V0.1 de "Toolbox"

2 Tutoriels vidéo Java gratuits

3 Analyse complète des annotations Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!