---
title: 'Was Eclipse bisher bei Java 9 unterstützt'
url: 'https://tutego.de/blog/javainsel/2017/08/was-eclipse-bisher-bei-java-9-untersttzt'
markdown: 'https://tutego.de/blog/javainsel/2017/08/was-eclipse-bisher-bei-java-9-untersttzt.md'
date: '2017-08-10'
description: 'Siehe Feature / Steps Expected Result The Pre-requisite: Java 9 JRE Support Add Java 9 JRE Use Eclipse Preferences -> Java -> Installed JREs -> Add Java 9 JRE recognized as a valid JRE Project JRE In Package Explorer Use Project Context Menu and add Java 9 JRE JRE specific (eg Object) ge…'
taxonomy:
  category:
    - Entwicklungsumgebung
    - 'Java 9'
    - Eclipse
---

# Was Eclipse bisher bei Java 9 unterstützt

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://tutego.de/blog/javainsel/)

## Was Eclipse bisher bei Java 9 unterstützt

10.08.2017 · [Christian Ullenboom](https://tutego.de/blog/javainsel/author/admin/)

Siehe

**Feature** / Steps Expected Result

The Pre-requisite: Java 9 JRE Support

Add Java 9 JRE Use Eclipse Preferences -> Java -> Installed JREs -> Add

[![Addj9.jpg](https://wiki.eclipse.org/images/8/81/Addj9.jpg)](https://wiki.eclipse.org/File:Addj9.jpg)

Java 9 JRE recognized as a valid JRE

Project JRE In Package Explorer Use Project Context Menu and add Java 9 JRE JRE specific (eg `Object`) gets resolved in the project.

Package Explorer Go to Package Explorer and expand the Java 9 JRE Modules (eg `java.base` etc) are listed in the package explorer view

The First Step: Module Creation

Manual Context Menu of src -> New -> File – give the `module-info.java` as name no compiler errors

Automatic Context Menu of Project -> Cofigure -> Create module-info.

[![AutomoduleCreate.jpg](https://wiki.eclipse.org/images/0/01/AutomoduleCreate.jpg)](https://wiki.eclipse.org/File:AutomoduleCreate.jpg)

A default `module-info.java` with all packages exported should be created

Basic Necessity : Compilation, Module Dependency & Error Reporting

Unspecified Dependency create projects "first" and "second" and create `module-info.java` files in each of giving the module names "first" and "second" respectively.

In the first module add the directive `requires second;`. This initial configuration would look something similar to the one shown in the figure. [![Initmods.jpg](https://wiki.eclipse.org/images/9/99/Initmods.jpg)](https://wiki.eclipse.org/File:Initmods.jpg)

Compiler gives error "second cannot be resolved to a module"

Define Dependency In the above scenario, add Project second as a dependent project for project first Compiler error goes away

Duplicate Dependency Continuing from the above scenario, add a duplicate `requires second;` directive in the `module-info.java` file of the first Compiler gives error "Duplicate requires entry: second"

Circular Dependency add a circular dependency ie

add second project dependent on first add `requires first;` directive in the `module-info.java` file of the second project ie replace `// empty by design` comment by this directive

`Two` compiler errors " Cycle exists in module dependencies, Module second requires itself via first"

Editing with Ease: Completion in `module-info.java` file

Keyword Completion (1) In the `module-info.java` file of say second project, after `module first {`, press completion key (for eg, ctrl+space in windows)

[![Keycomplete1.jpg](https://wiki.eclipse.org/images/f/f2/Keycomplete1.jpg)](https://wiki.eclipse.org/File:Keycomplete1.jpg)

keywords `exports`, `opens`, `requires`, `provides` and `uses` shown

Keyword Completion (2) after `exports packagename`, or `opens packagename` press completion key keyword to is shown as an option

Package Completion after `exports`, `opens`, `provides` or `uses`, press completion key package completion shown.

Type Reference Completion after `exports`, `opens`, `provides` or `uses`, or optionally after a dot after a package, ie `exports packagename.` press completion key Type completion shown.

Implementation TypeRef Completion after `provides typename with` press completion key Type completion shown and these typereferences are implementations of the type given before with.

The Essential Utilities: Code Select, Hover, Navigate, Search and Rename

Module Select & Hover

In the `module-info.java` file of the first project, select `second` in the `requires second;` directive [![Hover.jpg](https://wiki.eclipse.org/images/5/5c/Hover.jpg)](https://wiki.eclipse.org/File:Hover.jpg)

Hover appears

Module Select, Hover & Navigate In the above scenario, after hover appears, click on the navigate `module-info.java` file of second opened

Module Select, & Search

In the `module-info.java` file of the second project, select second in module declaration `module second {` and search for references [![Modsearch2.jpg](https://wiki.eclipse.org/images/7/7f/Modsearch2.jpg)](https://wiki.eclipse.org/File:Modsearch2.jpg)

In the search view, the reference in directive `requires second;` in file first -> `module-info.java` is shown.

Package Search

create package `pack1` to the project first. add `exports pack1;` directive in `module-info.java` file of first. search for references of `pack1`

In the search view, the reference of `pack1` in directive `exports pack1;` in file first -> `module-info.java` is shown, similar to other `pack1`references if any

Type Search create Type `X` in the project first, add directive `uses X;` in `module-info.java` file of first, and search for references of X In the search view, the reference of `X`in directive`uses X;` in file first -> `module-info.java` is shown, similar to other `X`references if any

Code Select & Rename in `module-info.java` file of first, select `X` in directive `uses X;` and rename to `X11`rename exhibits usual behavior – renames definition and references of `X`to `X11`

The Outlier: Milling Project Coin Enhancements

```
@Safevarargs
```

`@SafeVarargs` is now allowed on private instance methods. There is even a support of quick assist for that. Use the following code which has warnings, and use the quick assist at the point mentioned in the comment

```java
package packsafe;
import java.util.ArrayList;
import java.util.List;   public class SafeVar {
    private int getLen(List...list) {
        List[] l = list;
        return l.length;
    }   public static void main(String[] args) {
        SafeVar x = new SafeVar();
        List l = new ArrayList();
        int len = x.getLen(l); // Use Quick Assist of SafeVarargs here
        System.out.println("Length:" + len);
    }
}
```

`@SafeVarargs`inserted before `getLen()` and the warnings go away

Effectively Final Autoloseables

Effectively-final variables are allowed to be used as resources in the try-with-resources statement. The code below has an error. Try removing the line `t1 = null; // Remove this code`.

```java
package packtry;
import java.io.Closeable;
import java.io.IOException;   class Two implements Closeable {
    @Override
    public void close() throws IOException {
        // nothing
    }
}
public class TryStmtTwo {   public void foo() throws IOException {
        Two t1 = new Two();
        try (t1; final Two t2 = new Two()) {
        // Empty by design
    }
    t1 = null; // Remove this code
    }
    public static void main(String[] args) {
        System.out.println("Done");
    }
}
```

Code without errors. For the more inquisitive, check the generated code to see that the close is generated for `t1` as well which is not a final variable but an effectively final variable.

Anonymous Diamond

In the following code, there is a warning about `Y` being a raw type and need to be parameterized. with Java 9 support, just add a diamond operator after `Y`.

```java
public class Dia {
@SuppressWarnings("unused")
    public static void main(String[] args) {
        Y y1 = new Y(){}; // Change this to new Y(){}
    }
}
class Y {}
```

Diamond operator ``accepted and code compiles without warning

Illegal Underscore

Underscore is an illegal identifier from Java 9 onwards. Uncomment the commented line in the following example

```java
public class UnderScore {
    //Integer _ ;
}
```

error: "’\_‘ should not be used as an identifier, since it is a reserved keyword from source level 1.8 on"

Private Methods

private interface methods are allowed. Change the `default` of worker to private

```

public interface I {
    default void worker() {}
```

Kategorien: [Entwicklungsumgebung](https://tutego.de/blog/javainsel/category/entwicklungsumgebung/), [Java 9](https://tutego.de/blog/javainsel/category/java-9/), [Eclipse](https://tutego.de/blog/javainsel/category/eclipse/)

[← Alle Beiträge](https://tutego.de/blog/javainsel/)

---

## Navigation

- Next: [Konstruktorreferenzen](https://tutego.de/blog/javainsel/2017/08/konstruktorreferenzen.md)