Siehe https://wiki.eclipse.org/Java9/Examples
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) 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.
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. 
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)
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 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 
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 pack1references 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 Xin directiveuses X; in file first -> module-info.java is shown, similar to other Xreferences 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 Xto 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
package packsafe;
import java.util.ArrayList;
import java.util.List; public class SafeVar {
private int getLen(List<String>...list) {
List<String>[] l = list;
return l.length;
} public static void main(String[] args) {
SafeVar x = new SafeVar();
List<String> l = new ArrayList<>();
int len = x.getLen(l); // Use Quick Assist of SafeVarargs here<br>
System.out.println("Length:" + len);
}
}
@SafeVarargsinserted 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 .
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.
public class Dia {
@SuppressWarnings("unused")
public static void main(String[] args) {
Y<?> y1 = new Y(){}; // Change this to new Y<>(){}
}
}
class Y<T> {}
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
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() {}< default void foo() {
worker();
} default void bar() {
worker();
}
}
Code compiles with privateas well. Note that this is a useful feature if two default methods wants to share the worker code and does not want the worker to be an public interface method.