Support free tutorials



vogella training Training Books

Eclipse IDE - Tutorial

Lars Vogel

Version 5.0

26.08.2015

Eclipse Java IDE

This tutorial describes the usage of Eclipse as a Java IDE. It describes the installation of Eclipse, the creation of Java programs and tips for using Eclipse. This tutorial is based on Eclipse 4.4 (Luna).


Table of Contents

1. What is Eclipse?
1.1. The Eclipse community and projects
1.2. A short Eclipse history
1.3. Eclipse releases
1.4. Learn about the Eclipse development process
2. Eclipse foundation and staff
2.1. Eclipse foundation
2.2. Staff of the Eclipse foundation
3. The Eclipse Public License
3.1. Source code and the Eclipse Public License
3.2. Intellectual property cleansing of Eclipse code
4. Different Eclipse IDE distributions
4.1. The Eclipse IDE for Java development
4.2. The Eclipse IDE distributions
5. Java requirements of the Eclipse IDE
6. Download the Eclipse IDE for Java Developers
7. Installation the Eclipse IDE
7.1. Install the Eclipse IDE
7.2. Solving exit code=13 while starting the Eclipse IDE
8. Getting started
8.1. Starting the Eclipse IDE
8.2. Appearance
9. Important Eclipse terminology
9.1. Workspace
9.2. Eclipse projects
9.3. Parts
9.4. Perspective
10. Eclipse Java development user interface
10.1. Perspectives in Eclipse
10.2. Resetting a perspective
10.3. Java perspective and Package Explorer
11. Eclipse Java perspective
11.1. Toolbar
11.2. Useful views
11.3. Package Explorer view
11.4. Outline view
11.5. Problems view
11.6. Javadoc view
11.7. Java editor
12. Create your first Java program
12.1. Target of this exercise
12.2. Create project
12.3. Create package
12.4. Create Java class
12.5. Run your project in Eclipse
13. Run Java program outside Eclipse
13.1. Create JAR file
13.2. Run your program outside Eclipse
14. Exporting and importing projects
14.1. Exporting projects
14.2. Importing projects
15. Navigating the Java source code
15.1. Package Explorer
15.2. Filter resources in the Package Explorer
15.3. Closing and opening projects
15.4. Link Package Explorer with editor
16. Navigate in the Java source code
16.1. Opening a class
16.2. Mouse and keyboard navigation
16.3. Quick Outline
16.4. Open Type Hierarchy
16.5. Search dialog
16.6. Incremental find
16.7. Find element based on current selection
16.8. Annotation navigations
16.9. Show in Breadcrumb
16.10. Shortcuts
17. Opening a resource
17.1. Via Package Explorer view
17.2. Open Resource dialog
18. Content Assist and Quick Fix
18.1. Content assist
18.2. Quick Fix
19. Java 8 support in Eclipse
19.1. Eclipse and Java 8
19.2. Example: Converting anonymous inner classes to lambda expressions and vice versa
20. Generating code
21. Exercise: code generation and content assists
21.1. Introduction
21.2. Create project
21.3. Create class
21.4. Create instances
21.5. Write a test class
21.6. Example implementation of TodoProviderTest
22. Refactoring
22.1. Refactoring
22.2. Refactoring in Eclipse
23. Exercise: Refactoring
23.1. Preparation
23.2. Extract method
23.3. Extract Constant
24. Eclipse Shortcuts
25. Using project dependencies
26. Using JARs (libraries) in Eclipse
26.1. Adding a Java library to the project classpath
26.2. Attach source code to a Java library
26.3. Add Javadoc for a JAR
27. Updates and installation of plug-ins
27.1. Eclipse update manager
27.2. Performing an update and install new features
27.3. See the installed components
27.4. Uninstalling components
27.5. Restarting Eclipse
28. Eclipse Marketplace
29. Advanced Eclipse Update manager options
29.1. Manual installation of plug-ins (dropins folder)
29.2. Exporting and importing the installed components
29.3. Installing features via the command line
30. Setting default preference values
30.1. What are preferences?
30.2. Opening the preference dialog
30.3. Configuring the preference values via the plugin_customization.ini file
30.4. Identifying preference setting values
30.5. Workspace Mechanics for configuring preferences settings
31. Eclipse Java development preferences
31.1. Automatic placement of semicolon
31.2. Auto-escape text pasted into Strings
31.3. Bracket highlighting
31.4. Activate Save Actions
31.5. Type Filters
31.6. Completion overwrites and insert guessed method arguments
31.7. Time delay before the code completion
31.8. Auto activation key for code completion
32. Eclipse code checks and cleanup
32.1. Java Development Toolkit code checks
32.2. Configuring the code settings
32.3. Annotation-based Null analysis
32.4. Automatic code cleanup and removal of trailing whitespace
33. More on preference settings
33.1. Launch Configuration
33.2. Configuring the editors for a file extension
33.3. Export and import preference settings
33.4. Preference settings per project
34. Using and configuring templates and the code formatter
34.1. Templates
34.2. Code Formatter
34.3. Code Templates
35. Eclipse command line configuration
35.1. Eclipse memory and performance settings
35.2. Eclipse startup parameters
36. Local history for files
36.1. Local history
36.2. Compare files based on local history
36.3. Replace files based on local history
37. Organizing your workspace
37.1. Working sets and tasks
37.2. Working sets
38. Tasks
38.1. Task management
38.2. Own tags
38.3. Mylyn
39. Eclipse online resources
39.1. Online documentations
39.2. Web resources
40. Reporting Eclipse bugs and asking questions
40.1. Asking (and answering) questions
40.2. Eclipse bug reports and feature requests
41. Next steps
42. About this website
43. Links and Literature
43.1. Eclipse Resources
43.2. vogella GmbH training and consulting support

Get the book Eclipse IDE book

1. What is Eclipse?

1.1. The Eclipse community and projects

Eclipse is an open source community. The Eclipse open source community consists of more than 150 projects covering different aspects of software development.

Eclipse projects cover lots of different areas, e.g., as a development environment for Java or Android applications. But the Eclipse project also provides very successful runtime components, like the popular Jetty webserver and the Hudson build server.

1.2. A short Eclipse history

The roots of Eclipse go back to 2001. The initial code base was provided by IBM. In November 2001, a consortium was formed to support the development of Eclipse as open source software. This consortium was controlled by IBM.

In 2004 it became the Eclipse Foundation, which is a vendor neutral foundation where no single company has control of the direction.

The Eclipse name at this time was viewed by many as declaration of war against Sun Microsystems, the company responsible for developing the Java programming language. IBM stated that the name was targeting at "Eclipsing" Microsoft. See Eclipse: Behind the Name for details.

With the purchase of Sun Microsystems by Oracle this conflict finally went away. Oracle is currently among the 5 largest contributor companies of the Eclipse project.

1.3. Eclipse releases

The Eclipse open source project has a simultaneous release every year. Eclipse projects can choose to join this release but must fulfill the requirements described in the Release requirements wiki.

This simultaneous release includes new versions of the Eclipse IDE distributions. Before 2012 Eclipse was released in version 3.x, e.g. Eclipse 3.6, Eclipse 3.7. These releases and the corresponding API are referred to as Eclipse 3.x.

As of 2012 the main Eclipse release carried the major version number 4, e.g., Eclipse 4.2 in the year 2012, Eclipse 4.3 in 2013, Eclipse 4.4. in 2014 and Eclipse 4.5 in 2015.

The following graphic depicts the number of projects and lines of code (measured in millions) joining this release over the years.

Luna projects and lines of code

1.4. Learn about the Eclipse development process

Eclipse projects follow a certain process. You can find more information about the development process at the eclipse.org website under the Eclipse Development Process Online link .

2. Eclipse foundation and staff

2.1. Eclipse foundation

The Eclipse projects are governed by the Eclipse Foundation. The Eclipse Foundation is a non-profit, member supported corporation that hosts the Eclipse Open Source projects and helps to cultivate both its open source community and its ecosystem of complementary products and services.

The Eclipse Foundation does not work on the Eclipse code base, i.e., it does not have employee developers working on Eclipse. The mission of the Eclipse Foundation is to enable the development by providing the infrastructure (Git, Gerrit, Hudson build server, the download sites, etc.) and a structured process.

There is also an Eclipse Foundation Europe based in Germany. See Eclipse Foundation Europe FAQ for details.

2.2. Staff of the Eclipse foundation

In 2015 the Eclipse Foundation had approximately 20 employees. See Eclipse Foundation Staff for details.

3. The Eclipse Public License

3.1. Source code and the Eclipse Public License

The Eclipse Public License (EPL) is an open source software license used by the Eclipse Foundation for its software. The EPL is designed to be business-friendly. EPL licensed programs can be used, modified, copied and distributed free of charge. The consumer of EPL-licensed software can choose to use this software in closed source programs.

Only modifications in the original EPL code must also be released as EPL code. This can for example be done by filling a bug report at the public Eclipse bug tracker and by uploading a Gerrit change.

3.2. Intellectual property cleansing of Eclipse code

The Eclipse Foundation validates that source code contributed to Eclipse projects is free of intellectual property (IP) issues. This process is known as IP cleansing. Contributions with more than 1000 lines of code require the creation of a Contribution Questionnaire, and a review and approval by the IP team.

The permissive EPL and the IP cleansing effort of the Eclipse Foundation makes reusing the source code of Eclipse projects attractive to companies.

4. Different Eclipse IDE distributions

4.1. The Eclipse IDE for Java development

Most people know Eclipse as an integrated development environment (IDE) for Java. In 2014 the Eclipse IDE is the leading development environment for Java with a market share of approximately 65%.

The Eclipse IDE can be extended with additional software components. Eclipse calls these software components plug-ins. Plug-in can be grouped into features.

Several open source projects and companies have extended the Eclipse IDE or created stand-alone applications (Eclipse Rich Client Platform) on top of the Eclipse framework.

4.2. The Eclipse IDE distributions

The Eclipse IDE is also available as an IDE for other languages, ranging from C, C++ to Lua, Python, Perl and PHP. Several pre-packaged Eclipse distributions are available for download.

5. Java requirements of the Eclipse IDE

To run the Eclipse IDE a Java 7 JRE/JDK is required for most of the Luna package downloads based on Eclipse 4.4.

The Eclipse IDE contains its custom Java compiler hence a JRE is sufficient for most tasks with Eclipse. The JDK version of Java is only required if you compile Java source code on the command line and for advanced development scenarios, for example, if you use automatic builds or if you develop Java web applications.

Please note that you need a 64 JVM to run a 64 bit Eclipse and a 32 bit JVM to run a 32 bit Eclipse.

6. Download the Eclipse IDE for Java Developers

The Eclipse IDE consists of several components. The Eclipse.org website provides pre-packaged Eclipse distributions to provide downloads for typical use cases.

The Eclipse IDE for Java Developers distribution is specifically designed for standard Java development. It contains typical required packages, like the Maven build system or support for the Git version control system.

Download the Eclipse IDE for Java Developers package from the following URL. Ensure that you download the correct version for your Java installation, e.g., 32 bit or 64 bit. See Section 7.2, “Solving exit code=13 while starting the Eclipse IDE” for details.

http://www.eclipse.org/downloads 

The following screenshot shows the Eclipse download website for a Linux system. Press on the link beside the package description, for example Linux 64-Bit to start the download. The links which are displayed depend on your operating system.

Eclipse Download page

The download is a zip file, which is a compressed archive of multiple files.

7. Installation the Eclipse IDE

7.1. Install the Eclipse IDE

After you downloaded the file with the Eclipse distribution, unpack it to a local directory. Most operating systems can extract zip or tar.gz files in their file browser (e.g., Windows 7) with a right-click on the file and selecting "Extract all...".

Note

As a developer person you probably know how to extract a compressed file but if in doubt, search with Google for "How to extract a zip (or tar.gz on Linux and Mac OS) file on ...", replacing "..." with your operating system.

Extract Eclipse to a directory without spaces in its path and do not use a mapped network drive (Windows). Also avoid path names longer than 255 characters under Microsoft Windows. Installations of the Eclipse IDE sometimes have problems with such a setup.

After you extracted the compressed file you can start Eclipse, no additional installation procedure is required.

7.2. Solving exit code=13 while starting the Eclipse IDE

A common error is that the user downloads a 32 or a 64 bit version of Eclipse but tries to start it on a 64 or 32 JVM. Both versions must fit together as Eclipse contains native code. Unfortunately you can run a 32 bit JVM on a 64 bit operating system. Use java -version on the command line and if the output does not contain the word "Server" you are using the 32 bit version of Java and must use a 32 bit version of Eclipse.

8. Getting started

8.1. Starting the Eclipse IDE

To start Eclipse, double-click the eclipse.exe (Microsoft Windows) or eclipse (Linux / Mac) file in the directory where you unpacked Eclipse.

The Eclipse system prompts you for a workspace. The workspace is the location in your file system where Eclipse stores its preferences and other resources. For example your projects can be stored in the workspace.

Select an empty directory and click the OK button.

Selecting the Workspace

Eclipse starts and shows the Welcome page. Close this page by clicking the x beside Welcome.

Closing the Eclipse welcome screen

After closing the welcome screen, the application should look similar to the following screenshot.

Closing the Eclipse welcome screen

8.2. Appearance

The appearance of Eclipse can be configured. By default, Eclipse ships with a few themes but you can also extend Eclipse with new themes.

To change the appearance, select from the menu WindowPreferencesGeneralAppearance.

The Theme selection allows you to change the appearance of your Eclipse IDE. For example you can switch to the Dark theme of Eclipse.

Changing the theme

9. Important Eclipse terminology

Eclipse provides Perspectives, Views and Editors. Views and Editors are grouped into Perspectives.

9.1. Workspace

The workspace is the physical location (file path) you are working in. Your projects, source files, images and other artifacts can be stored and saved in your workspace. The workspace also contains preferences settings, plug-in specific meta data, logs etc.

You typically use different workspaces if you require different settings for your project or if you want to divide your projects into separate directories.

Note

It is not mandatory that a project resides within the workspace directory. It is possible to refer to external resources (e.g., projects) from the workspace.

You can choose the workspace during startup of Eclipse or via the menu (FileSwitch WorkspaceOthers) .

9.2. Eclipse projects

An Eclipse project contains source, configuration and binary files related to a certain task and groups them into buildable and reusable units. An Eclipse project can have natures assigned to it which describe the purpose of this project. For example, the Java nature defines a project as Java project. Projects can have multiple natures combined to model different technical aspects.

Natures for a project are defined via the .project file in the project directory.

Projects in Eclipse cannot contain other projects.

9.3. Parts

9.3.1. What are parts?

Parts are user interface components which allow you to navigate and modify data. A part can have a drop-down menu, context menus and a toolbar. The Parts can be stacked or positioned next to each other depending on the container into which they are dropped.

Eclipse application with a few parts

9.3.2. Parts behaving as views or as editors

Parts are typically classified into views and editors. The distinction between views and editors is not based on technical differences, but on a different concept of using these parts.

A view is typically used to work on a set of data, which might be a hierarchical structure. If data is changed via the view, this change is typically directly applied to the underlying data structure. A view sometimes allows the user to open an editor for the selected set of data.

An example for a view in the Eclipse IDE is the Package Explorer, which allows you to browse the files of Eclipse projects. If you change data in the Package Explorer, e.g., if you rename a file, the file name is directly changed on the file system.

Editors are typically used to modify a single data element, e.g., the content of a file or a data object. To apply the changes made in an editor to the data structure, the user has to explicitly save the editor content.

For example, the Java editor is used to modify Java source files. Changes to the source file are applied once the user selects the Save button. A dirty editor tab is marked with an asterisk left to the name of the modified file.

Editor marked as dirty

9.4. Perspective

A perspective is an optional container for part stacks and part sash container as well as for a set of parts. Perspectives can be used to store different arrangements of parts. For example, the Eclipse IDE uses them to layout the views appropriate to the task (development, debugging, review, ...) the developer wants to perform.

Open editors are typically shared between perspectives, i.e., if you have an editor open in the Java perspective for a certain class and switch to the Debug perspective, this editor stays open.

You can switch Perspectives via the WindowOpen PerspectiveOther... menu entry.

The main perspectives used for Java development are the Java perspective and the Debug perspective .

Switching perspectives in the Eclipse IDE

You can change the layout and content within a perspective by opening or closing parts and by re-arranging them.

To open a new part in your current perspective, use the WindowShow ViewOther... menu entry. The following Show View dialog allows you to search for certain parts.

Show View dialog

If you want to reset your current perspective to its default, use the WindowReset Perspective menu entry.

You can save the currently selected perspective via WindowSave Perspective As....

Save your perspective configuration

The WindowCustomize Perspective... menu entry allows you to adjust the selected perspective . For example, you can hide or show toolbar and menu entries.

Customize Perspective

10. Eclipse Java development user interface

10.1. Perspectives in Eclipse

Eclipse provides different perspectives for different tasks. The available perspectives depend on your installation.

For Java development you usually use the Java Perspective, but Eclipse has much more predefined perspectives, e.g., the Debug perspective.

Eclipse allows you to switch to another perspective via the WindowOpen PerspectiveOther... menu entry.

10.2. Resetting a perspective

A common problem is that you changed the arrangement of views and editors in your perspective and you want to restore Eclipse to its original state. For example, you might have closed a view .

You can reset a perspective to its original state via the WindowReset Perspective menu entry.

10.3. Java perspective and Package Explorer

The default perspective for Java development can be opened via WindowOpen PerspectiveJava.

On the left hand side, this perspective shows the Package Explorer view, which allows you to browse your projects and to select the components you want to open in an editor via a double-click.

For example, to open a Java source file, open the tree under src, select the corresponding .java file and double-click it. This will open the file in the default Java editor.

The following picture shows the Eclipse IDE in its standard Java perspective. The Package Explorer view is on the left. In the middle you see the open editors. Several editors are stacked in the same container and you can switch between them by clicking on the corresponding tab. Via drag and drop you can move an editor to a new position in the Eclipse IDE.

To the right and below the editor area you find more views which were considered useful by the developer of the perspective. For example, the Javadoc view shows the Javadoc of the selected class or method.

Eclipse Java Perspective

11. Eclipse Java perspective

11.1. Toolbar

The application toolbar contains actions which you typically perform, e.g., creating Java resources or running Java projects. It also allows you to switch between perspectives.

Java Perspective toolbar

11.2. Useful views

The Java perspective contains useful views for working with your Java project. The following description explains the most important ones.

11.3. Package Explorer view

The Package Explorer view allows you to browse the structure of your projects and to open files in an editor via a double-click on the file.

It is also used to change the structure of your project. For example, you can rename files or move files and folders via drag and drop. A right-click on a file or folder shows you the available options.

Package Explorer

For more info on the Package Explorer see Section 15.1, “Package Explorer” and Section 15.4, “Link Package Explorer with editor”.

11.4. Outline view

The Outline view shows the structure of the currently selected source file.

Outline View

11.5. Problems view

The Problems view shows errors and warning messages. Sooner or later you will run into problems with your code or your project setup. To view the problems in your project, you can use the Problems view which is part of the standard Java perspective. If this view is closed, you can open it via WindowShow ViewProblems.

Errors in the problem view

The messages which are displayed in the Problems view can be configured via the drop-down menu of the view . For example, to display the problems from the currently selected project, select Configure Contents and set the Scope to On any element in the same project.

Drop-down menu of the problems view

Customizing

The Problems view also allows you to trigger a Quick fix via a right mouse-click on several selected messages. See Section 18.2, “Quick Fix” for details on the Quick fix functionality.

Customizing

11.6. Javadoc view

The Javadoc view shows the documentation of the selected element in the Java editor.

Javadoc View

11.7. Java editor

The Java editor is used to modify the Java source code. Each Java source file is opened in a separate editor.

Java editor

If you click in the left column of the editor, you can configure its properties, for example, that line number should be displayed.

Java editor

12. Create your first Java program

12.1. Target of this exercise

The following section describes how to create a minimal Java application using Eclipse. It is tradition in the programming world to create a small program which writes "Hello World" to the console. We will adapt this tradition and will write "Hello Eclipse!" to the console.

12.2. Create project

This book uses the naming convention that the project is named the same as the top-level package in the project.

Select FileNewJava project from the menu. Enter de.vogella.eclipse.ide.first as the project name. Select the Create separate folders for sources and class files flag.

New Java Project Wizard

Press the Finish button to create the project. A new project is created and displayed as a folder. Open the de.vogella.eclipse.ide.first folder and explore the content of this folder.

12.3. Create package

In the following step you create a new package. A good convention for the project and package name is to use the same name for the top level package and the project. For example, if you name your project com.example.javaproject you should also use com.example.javaproject as the top-level package name.

To create the de.vogella.eclipse.ide.first package, select the src folder , right-click on it and select NewPackage.

Right mouse click to create a package

Tip

Reverse domain names should be used for packages to prevent name clashes. It is relatively unlikely that another company defines a class called test in the com.vogella package because this is the reverse URL of the vogella GmbH company.

Enter the name of your new package in the dialog and press the Finish button.

Create a package Dialog

12.4. Create Java class

Create a Java class. Right-click on your package and select NewClass.

Create a new class selection

Enter MyFirstClass as the class name and select the public static void main (String[] args) checkbox.

Create a new class selection

Press the Finish button.

This creates a new file and opens the Java editor. Change the class based on the following listing.

package de.vogella.eclipse.ide.first;

public class MyFirstClass {

  public static void main(String[] args) {
    System.out.println("Hello Eclipse!");
  }
  
} 

You could also directly create new packages via this dialog. If you enter a new package in this dialog, it is created automatically.

12.5. Run your project in Eclipse

Now run your code. Either right-click on your Java class in the Package Explorer or right-click in the Java class and select Run-asJava application.

Run project

Eclipse will run your Java program. You should see the output in the Console view .

Result of the running application

Congratulations! You created your first Java project, a package, a Java class and you ran this program inside Eclipse.

13. Run Java program outside Eclipse

13.1. Create JAR file

To run the Java program outside of the Eclipse IDE, you need to export it as a JAR file. A JAR file is the standard distribution format for Java applications.

Select your project, right-click it and select the Export menu entry.

Export wizard for Java project

Select JAR file and select the Next button. Select your project and enter the export destination and a name for the JAR file. I named it myprogram.jar.

Export wizard for Java project, Part II

Export wizard for Java project, Part III

Press The Finish button. This creates a JAR file in your selected output directory.

13.2. Run your program outside Eclipse

Open a command shell, e.g., under Microsoft Windows select StartRun and type cmd and press the Enter key. This should open a console window.

Switch to the directory which contains the JAR file , by typing cd path. For example, if your JAR is located in c:\temp, use the following command.

cd c:\temp 

To run this program, include the JAR file in your classpath. The classpath defines which Java classes are available to the Java runtime. You can add a JAR file to the classpath with the -classpath option.

java -classpath myprogram.jar de.vogella.eclipse.ide.first.MyFirstClass 

Type the above command in the directory you used for the export and you see the "Hello Eclipse!" output in your command shell.

Running application outside Eclipse

14. Exporting and importing projects

14.1. Exporting projects

You can export and import Eclipse projects. This allows you to share projects with other people and to import existing projects.

To export Eclipse projects, select FileExportGeneralArchive File and select the projects you want to export.

Exporting project

Exporting projects part 2

14.2. Importing projects

To import projects, select FileImportExisting Projects into Workspace. You can import from an archive file, i.e., zip file or directly import the projects in case you have extracted the zip file.

Importing projects

Importing projects from archive file

15. Navigating the Java source code

15.1. Package Explorer

The primary way of navigating through your project is the Package Explorer. You can open nodes in the tree and open a file in an editor by double-clicking on the corresponding entry in the Package Explorer.

Package Explorer display

15.2. Filter resources in the Package Explorer

The drop-down menu in the Package Explorer allows you to filter the resources which should be displayed or hidden.

Filter in the package explorer

Filter in the package explorer

15.3. Closing and opening projects

You can close projects via a right-click on it and by selecting the Close Project menu entry. Alternatively, if you work on a project, you can close all unrelated projects via a right-click on it and by selecting the Close Unrelated Projects menu entry.

Note

Closing projects saves memory in Eclipse and can reduce the build time.

To open a closed project double-click on it, or right-click it and select Open Project.

Eclipse ignores closed projects, e.g., the Problems view does only shows errors of opened projects. This typically helps you focus your attention on the project.

Tip

You can use the filter functionality for the Package Explorer view to hide the closed projects.

15.4. Link Package Explorer with editor

The Package Explorer view allows you to display the associated file from the currently selected editor. For example, if you are working on the Foo.java file in the Java editor and switch to the Java editor of the Var.java file, then the corresponding file will be selected in the Package Explorer view.

To activate this behavior, press the Link with Editor button in the Package explorer view as depicted in the following screenshot.

Synchronize the package explorer selectioni with the current selected editor

16. Navigate in the Java source code

You can also use other means than the Package Explorer to navigate your source code. The following description lists the most important ones.

16.1. Opening a class

You can navigate between the classes in your project via the Package Explorer view as described before. You can navigate the tree and open a file via a double-click.

In addition, you can open any class by positioning the cursor on the class in an editor and pressing F3. Alternatively, you can press Ctrl+Shift+T. This shows the following dialog in which you can enter the class name to open it.

Opening a class

You can also search for package names. Each part of the package name must end with a . (the dot character) so that the Open Type Dialog can identify it as a package.

Tip

You only need to specify part of each segment of the package name. Assume, for example, that you search for the org.eclipse.swt.widgets.Button class. To find this class, you can use the search term org.eclipse.swt.widgets.Button or o.e.s.w.Button or o.Button.

Opening a class with package name

The Open Type Dialog also supports CamelCase like search, e.g., it matches capital letters in the class name. For example, if you would search for the OnTouchListener class you could use OTL or OToList as search term.

Opening a class with CamelCase

Tip

To avoid suffix matching, you can add a space after the class name. For example, you can type Selection (there is a space after selection) to match the Selection class but not the SelectionListener class. Wildcards like * are also supported.

16.2. Mouse and keyboard navigation

In a lot of cases you can also use the mouse to navigate to or into an element if you press the Ctrl key. For example, press the Ctrl key and (left) click with the mouse on the name of a class to jump into the class declaration.

Similar to the left mouse click combined with the Ctrl, you can use the F3 key to go into a class.

16.3. Quick Outline

If you right-click in your Java editor, you can select the Quick Outline option which shows you an outline of your Java class with the option to filter.

Quickoutline

The shortcut for opening the Quick Outline is Ctrl+O. By default, Quick Outline shows only the direct members and fields of the class. Press Ctrl+O again to show also the inherited members and fields.

The default look of the Quick Outline option is similiar to the Quick Outline view of the Java perspective.

16.4. Open Type Hierarchy

The type hierarchy of a class shows you which classes it extends and which interfaces it implements. You can use the type hierarchy to navigate to one of these elements.

To open the type hierarchy of the selected class, right-click in the editor and select Open Type Hierarchy (Shortcut: F4) or Quick Type Hierarchy (Shortcut: Ctrl+T).

16.5. Search dialog

Via the SearchSearch menu (Shortcut: Ctrl+H) you can open the search dialog of Eclipse.

Use the Java Search tab to search for Java elements, e.g., methods.

Text search

The Search view shows the search results for the selected scope. You can double-click on a search entry to navigate to the corresponding position in the editor. The currently selected search result is also indicated via an arrow in the left border of the editor.

Text search

Use the File Search tab to search for text.

Text search

Eclipse associates file extensions with the default tab. You can customize the available search tabs via the Customize button in the Search dialog. Via the Remember the last used page you can configure Eclipse to use your last tab as default.

Customize search

Customize search

Tip

The Search view allows you to delete search results via the Delete key.

16.6. Incremental find

You can use the Ctrl+J shortcut to activate Incremental Find. This allows you to search in the current active editor for a text which is displayed in the status line as depicted by the following screenshot. Repeat Ctrl+J in order to move to the next occurrence of the current search term.

Incrementation search

The advantage of this search is that no pop-up dialog is opened which blocks other elements in the Eclipse IDE.

16.7. Find element based on current selection

If you have selected an element in the editor, you can use the Ctrl+K shortcut to search for the next occurrence of the selected text and Ctrl+Shift+K for the previous element.

16.8. Annotation navigations

You can also navigate via the annotation buttons, e.g., for jumping to the next error or warning in your source code.

Annotation navigation

By pressing the buttons you can navigate to the related annotations. You can also use the keyboard shortcut Ctrl+. (Ctrl plus the dot sign) for selecting the next annotation or Ctrl+, (Ctrl plus the comma sign) for selecting the previous annotation.

The following screenshot shows source code with two warnings and one error and you can navigate between the corresponding code via the annotation buttons.

Moving in the source code

Which annotations are relevant for navigation can be configured via the drop-down menu of the toolbar. This selection is highlighted in the following screenshot.

Annotation navigation

16.9. Show in Breadcrumb

You can also activate the breadcrumb mode for the Java editor which allows you to navigate the source code directly from the Java editor.

You can activate this mode via right-click in the editor and by selecting the Show in Breadcrumb entry.

Show in Breadcrumb

This allows you to navigate the source code from the editor as depicted in the following screenshot.

Breadcrumb view

To hide it again, right-click on a breadcrump entry and select Hide Breadcrumb.

Breadcrumb view

16.10. Shortcuts

There are a lot of shortcuts available for navigation. Please check the appendix of this book for these shortcuts or open Window+PreferencesGeneralKeys to find and redefine shortcuts at runtime.

17. Opening a resource

17.1. Via Package Explorer view

You can also navigate to non-Java source files via the Package Explorer view and open a file via a double-click on it.

17.2. Open Resource dialog

In addition to the Package Explorer view you can open any file in your projects via the Open Resource dialog which can be opened via the Ctrl+Shift+R shortcut. This shortcut opens a dialog in which you can enter the resource name to open it.

Open resources in Eclipse

18. Content Assist and Quick Fix

18.1. Content assist

Content assist is a functionality in Eclipse which allows the developer to get context-sensitive code completion in an editor upon user request.

It can be invoked by pressing Ctrl+Space.

For example, type syso in the editor of a Java source file and then press Ctrl+Space. This will replace syso with System.out.println("").

If you have a reference to an object, for example, the object person of the type Person and need to see its methods, type person. and press Ctrl+Space.

Content Assists

18.2. Quick Fix

Whenever Eclipse detects a problem, it will underline the problematic text in the editor. Select the underlined text and press Ctrl+1 to see proposals how to solve this problem. This functionality is called Quick Fix.

For example, type myBoolean = true; If myBoolean is not yet defined, Eclipse will highlight it as an error. Select the variable and press Ctrl+1. Eclipse will suggest creating a field or local variable.

Using Quickfix Example

Quick Fix is extremely powerful. For example, it allows you to create new local variables and fields as well as new methods and new classes. Or it can put try/catch statements around your exceptions. It can also assign a statement to a variable and much more.

Quick Fix also gives several options for code changes on code which does not contain errors, e.g., it allows you to convert a local variable to a field.

19. Java 8 support in Eclipse

19.1. Eclipse and Java 8

The Eclipse IDE has full support for Java 8. You can use content assists, quick fixes and refactoring for Java 8.

19.2. Example: Converting anonymous inner classes to lambda expressions and vice versa

This section demonstrates the quick fix for converting anonymous inner classes to lambda expressions.

package com.vogella.eclipse.ide.java8;

public class Java8Example {

  public static void main(String[] args) {
    Runnable runnable = new Runnable() {
      @Override
      public void run() {
        System.out.println("Hello Lambdas");
      }
    };
    
    new Thread(runnable);
  }
} 

You can use a quick fix for the conversion as demonstrated via the following screenshots.

20. Generating code

Eclipse has several possibilities to generate code for you. This can save significant time during development.

For example, Eclipse can override methods from superclasses and generate the toString(), hashcode() and equals() methods. It can also generate getter and setter methods for attributes of your Java class.

You can find these options in the Source menu.

Code generation

To test the source generation, create the following class in your de.vogella.eclipse.ide.first project.

package de.vogella.eclipse.ide.first;

public class Person {
  private String firstName;
  private String lastName;
  
} 

Select SourceGenerate Constructor using Fields..., mark both fields and click the OK button.

Generating

Select SourceGenerate Getter and Setter..., select all fields and afterwards click the OK button.

Select SourceGenerate toString()..., mark again all fields and click the OK button.

You created the following class:

package de.vogella.eclipse.ide.first;

public class Person {
  private String firstName;
  private String lastName;

  public Person(String firstName, String lastName) {
    super();
    this.firstName = firstName;
    this.lastName = lastName;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return "Person [firstName=" + firstName + ", lastName=" + lastName
        + "]";
  }

} 

21. Exercise: code generation and content assists

21.1. Introduction

In this exercise you practice the usage of code generation and the usage of the Content Assists functionality.

21.2. Create project

Create a project called com.vogella.ide.todo.

21.3. Create class

Create the com.vogella.ide.todo package and the following class.

package com.vogella.ide.todo;

import java.util.Date;

public class Todo {
  
  private long id;
  private String summary = "";
  private String description = "";
  private boolean done = false;
  private Date dueDate;

} 

Select SourceGenerate Constructor using Fields... to generate a constructor using all fields.

Use the SourceGenerate Getter and Setter to create getters and setters for all fields.

The resulting class should look like the following listing.

package com.vogella.ide.todo;

import java.util.Date;

public class Todo {
  
  private long id;
  private String summary = "";
  private String description = "";
  private boolean done = false;
  private Date dueDate;

  public Todo(long id, String summary, String description, boolean done,
      Date dueDate) {
    this.id = id;
    this.summary = summary;
    this.description = description;
    this.done = done;
    this.dueDate = dueDate;

  }

  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public String getSummary() {
    return summary;
  }

  public void setSummary(String summary) {
    this.summary = summary;
  }

  public String getDescription() {
    return description;
  }

  public void setDescription(String description) {
    this.description = description;
  }

  public boolean isDone() {
    return done;
  }

  public void setDone(boolean done) {
    this.done = done;
  }

  public Date getDueDate() {
    return dueDate;
  }

  public void setDueDate(Date dueDate) {
    this.dueDate = new Date(dueDate.getTime());
  }

} 

Use Eclipse to generate a toString() method for the Todo class based on the id and summary field. This can be done via the Eclipse menu SourceGenerate toString()....

Also use Eclipse to generate a hashCode() and equals() method based on the id field. This can be done via the Eclipse menu SourceGenerate hashCode() and equals()....

21.4. Create instances

Create a new class called TodoProvider. Create the following static method in your TodoProvider class.

package com.vogella.ide.todo;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class TodoProvider {
  private static int current = 0;

  // example data, change if you like
  public static List<Todo> createInitialModel() {
    ArrayList<Todo> list = new ArrayList<Todo>();
    list.add(createTodo("SWT", "Learn Widgets"));
    list.add(createTodo("JFace", "Especially Viewers!"));
    list.add(createTodo("DI", "@Inject looks interesting"));
    list.add(createTodo("OSGi", "Services"));
    list.add(createTodo("Compatibility Layer", "Run Eclipse 3.x"));
    return list;
  }

  private static Todo createTodo(String summary, String description) {
    return new Todo(current++, summary, description, false, new Date());
  }
} 

21.5. Write a test class

Write another TodoProviderTest class with a public static void main (String[] args) method.

In your main method call the createInitialModel method and validate that the returned number of items is 5.

If another number than 5 is returned, throw a RuntimeException. If the correct number is returned, write the String "Correct" to the Console view .

Use Content assist to create the System.out.println() based on syso for you.

Content Assists Input

Content Assists Result

21.6. Example implementation of TodoProviderTest

While this exercise was about code generation and content assits, you might be interested in a potential solution for this exercise. The following listing contains a potential solution.

package com.vogella.ide.todo;

import java.util.List;

public class TodoProviderTest {

  public static void main(String[] args) {
    List<Todo> model = TodoProvider.createInitialModel();
    if (model.size()!=5){
      throw new RuntimeException("size should be 5");
    } else {
      System.out.println("Correct");
    }
  }

} 

22. Refactoring

22.1. Refactoring

Refactoring is the process of restructuring the code without changing its behavior. For example, renaming a Java class or method is a refactoring activity.

22.2. Refactoring in Eclipse

Eclipse supports several refactoring activities, for example, renaming or moving.

For example, to use the Rename refactoring, you can right-click on your class (in the editor or Package Explorer) and select RefactorRename to rename your class. Eclipse will make sure that all calls in your Workspace to your class or method are renamed.

The following screenshot shows how to call the Rename refactoring for a class. The cursor is positioned on the class and the context menu is activated via a right-click on the class.

Renaming a class

The most important refactorings are listed in the following table.

Table 1. Refactoring

Refactoring Description
Rename Rename a variable or class
Extract Method Creates a method based on the selected code in the editor
Extract Constant Gives magic numbers or hard-coded strings a descriptive constant name and replaces all occurences.


Tip

Lots of refactorings are also available via the Ctrl+1 shortcut (quick fix). Select a certain part of your code and press Ctrl+1 to see possible refactorings for the selected position.

Eclipse has many more refactorings. The available options depend on the selection in the Java editor. In most cases you should get an idea of the performed action by the naming of the refactoring operation.

23. Exercise: Refactoring

23.1. Preparation

For the next examples change the MyFirstClass class to the following code.

package de.vogella.eclipse.ide.first;

public class MyFirstClass {

  public static void main(String[] args) {
    System.out.println("Hello Eclipse!");
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
      sum += i;
    }
    System.out.println(sum);
  }
} 

23.2. Extract method

A useful refactoring is to mark code and create a method from the selected code. To use this in this exercise, mark the coding of the "for" loop, right click on the selection and select Refactoring Extract Method. Use calculateSum as the name of the new method.

Extract Method refactoring

After this refactoring the class should look like the following code.

package de.vogella.eclipse.ide.first;

public class MyFirstClass {

  public static void main(String[] args) {
    System.out.println("Hello Eclipse!");
    int sum = 0;
    sum = calculateSum(sum);
    System.out.println(sum);
  }

  private static int calculateSum(int sum) {
    for (int i = 1; i <= 100; i++) {
      sum += i;
    }
    return sum;
  }
} 

23.3. Extract Constant

You can also extract strings and create constants based on the strings. Mark for this example the "Hello Eclipse!" string in your source code, right-click on it and select RefactorExtract Constant. Name your new constant HELLO.

Extract Constants

The string is now defined as a constant.

package de.vogella.eclipse.ide.first;

public class MyFirstClass {

  private static final String HELLO = "Hello Eclipse!";

  public static void main(String[] args) {
    System.out.println(HELLO);
    int sum = 0;
    sum = calculateSum(sum);
    System.out.println(sum);
  }

  private static int calculateSum(int sum) {
    for (int i = 1; i <= 100; i++) {
      sum += i;
    }
    return sum;
  }
} 

24. Eclipse Shortcuts

Eclipse provides a lot of shortcuts to work efficiently with the IDE. For a list of the most important Eclipse shortcuts please see Eclipse Shortcuts

25. Using project dependencies

You can define in Eclipse that a project is dependent on another project. To do this select your project, right-click on it and select Properties.

Select Java Build Path and the Projects tab.

Defining project dependencies

If you add a project to the build path of another project, you can use its classes in Eclipse.

This only works within Eclipse; outside of it you need to create Java libraries for the projects and add them to the classpath of your Java application.

26. Using JARs (libraries) in Eclipse

26.1. Adding a Java library to the project classpath

If the libraries should be distributed with your project, you can store the JAR files directly in your project.

For example, you can create a new Java project de.vogella.eclipse.ide.jars. Then create a new folder called lib by right-clicking on your project and selecting NewFolder.

Creating a new folder

From the menu select FileImportGeneralFile System. Select the Java library you want to import and select the lib folder as target. Alternatively, just copy and paste the jar file into the lib folder.

You can add this library to your classpath, right-click on the JAR file and select Build PathAdd to Build Path.

To manage your classpath, right-click on your project and select Properties. Under Java Build PathLibraries select the Add JARs button.

The following example shows how the result would look like if the junit-4.4.jar file had been added to the project.

Adding a jar to the current project

After adding it to the classpath, Eclipse allows you to use the classes contained in the JAR file in the project . Outside Eclipse you still need to configure your classpath, e.g., via the MANIFEST.MF file.

26.2. Attach source code to a Java library

You can open any class by positioning the cursor on the class in an editor and pressing F3. Alternatively, you can press Ctrl+Shift+T. This will show a dialog in which you can enter the class name to open it.

If the source code is not available, the editor will show the bytecode of that class.

This happens, for example, if you open a class from a the standard Java library without attaching the source code to it.

To see the source code of such a class, you can attach a source archive or source folder to a Java library. Afterwards, the editor shows the source instead of the bytecode.

Attaching the source code to a library also allows you to debug this source code.

The Source Attachment dialog can be reached in the Java Build Path page of a project. To open this page, right-click on a project and select PropertiesJava Build Path. On the Libraries tab, expand the library's node, select the Source Attachment attribute and click the Edit button.

In the Location path field, enter the path of an archive or a folder containing the source.

The following screenshot shows this setting for the standard Java library. If you have the Java Development Kit (JDK) installed, you should find the source in the JDK installation folder. The file is typically called src.zip.

Maintaining the location of the source attachment to an jar

26.3. Add Javadoc for a JAR

It is also possible to add Javadoc to a library which you use.

Download the Javadoc of the JAR file and put it somewhere in your filesystem.

To enter the location of the Javadoc, open the Java Build Path via a right-click on a project and select PropertiesJava Build Path. On the Libraries tab expand the library's node, select the Javadoc location attribute and press the Edit button.

Enter the location to the file which contains the Javadoc.

Enter the location to the Javadoc file for a jar file

27. Updates and installation of plug-ins

27.1. Eclipse update manager

The Eclipse IDE contains a software component called Update Manager which allows you to install and update software components. Installable software components are called features and consist of plug-ins.

These features are contained in so-called update sites or software sites. An update site contains installable software components and additional configuration files. It can be located in various places, e.g., on a web server or on the local filesystem.

The configuration files provide aggregated information about the software components in the update site. The update functionality in Eclipse uses this information to determine which software components are available in which version. This allows the Eclipse update functionality to download only components which are new or updated.

27.2. Performing an update and install new features

Warning

If you are behind a network proxy, you have to configure your proxy via the WindowPreferencesGeneralNetwork Connection preference setting. Otherwise, Eclipse may not able to reach the update sites.

To update your Eclipse installation, select HelpCheck for Updates. The system searches for updates of the already installed software components. If it finds updated components, it will ask you to approve the update.

To install a new functionality, select HelpInstall New Software....

Selecting an update site in the update manager

From the Work with list, select or enter a URL from which you would like to install new software components. Entering a new URL adds this URL automatically to the list of available update sites.

To explicitly add a new update site, press the Add... button and enter the new URL as well as a name for the new update site.

The following update sites contain the official Eclipse components.

# Eclipse 4.4 (Luna release)
http://download.eclipse.org/releases/luna

# Eclipse 4.3 (Kepler release)
http://download.eclipse.org/releases/kepler 

If you select a valid update site, Eclipse allows you to install the available components. Check the components which you want to install.

Selecting an update site in the update manager

If you can't find a certain component, uncheck the Group items by category checkbox because not all available plug-ins are categorized. If they are not categorized, they will not be displayed, unless the grouping is disabled.

27.3. See the installed components

To see which components are installed, use HelpAbout Eclipse SDKInstallation Details.

Installation details of Eclipse

27.4. Uninstalling components

If you select HelpAbout Eclipse SDK and then the Installation Details button, you can uninstall components from your Eclipse IDE.

27.5. Restarting Eclipse

After an update or an installation of a new software component, you should restart Eclipse to make sure that the changes are applied.

28. Eclipse Marketplace

Eclipse also contains a client which allows installing software components from the Eclipse Marketplace client. The advantage of this client is that you can search for components, discover popular extensions and see descriptions and ratings.

Compared to the update manager, you do not have to know the URL for the software site which contains the installable software components.

Not all Eclipse distributions contain the Marketplace client by default. You may need to install the Marketplace client software component into Eclipse before you can use it. The following screenshot shows how to install it from one of the official Eclipse update sites.

Installing the MPC

To open the Eclipse Marketplace, select HelpEclipse Marketplace.

Showing the Eclipse Marketplace Client

You can use the Find box to search for components. Pressing the Install button starts the installation process.

29. Advanced Eclipse Update manager options

29.1. Manual installation of plug-ins (dropins folder)

Eclipse plug-ins are distributed as jar files. If you want to use an Eclipse plug-in directly or do not know the update site for it, you can place it in the dropins folder of your Eclipse installation directory. Eclipse monitors this directory and during a (re-)start of your IDE, the Eclipse update manager installs and removes plug-in based on the files contained in this directory.

You should not modify the content of the Eclipse plugins directory directly. If you want to install plug-ins, put them into the dropins folder. If you want to remove it, delete the JAR from this folder.

Plug-ins are typically distributed as jar files. To add a plug-in to your Eclipse installation, put the plug-in .jar file into the Eclipse dropins folder and restart Eclipse. Eclipse should detect the new plug-in and install it for you.

If you remove plug-ins from the dropins folder and restart Eclipse, these plug-ins are automatically removed from your Eclipse installation.

29.2. Exporting and importing the installed components

Eclipse allows you to export a file which describes the installed Eclipse components. During the export the user can select which components should be included into this description file.

Other users can import this description file into their Eclipse installation and install the components based on this file.

This way, Eclipse installation can be kept in sync with each other.

To export a description file, select FileExportInstallInstalled Software Items to File and select the components which should be included in your description file.

Exporting a description file for p2

To install the described components in another Eclipse installation, open the exported file with FileImportInstallInstall Software Items from File and follow the wizard. The wizard allows you to specify the components which should be installed.

29.3. Installing features via the command line

The Eclipse update manager has a component called director which allows you to install new features via the command line.

For example, the following command will install the components EGit, Mylyn and EMF into an Eclipse instance. You need to start this command in the command line and it assumes that you are in a directory which contains your Eclipse installation in a folder called eclipse.

eclipse/eclipse \
-application org.eclipse.equinox.p2.director \
-noSplash \
-repository \
http://download.eclipse.org/releases/luna \
-installIUs \
org.eclipse.egit.feature.group,\
org.eclipse.jgit.feature.group,\
org.eclipse.emf.sdk.feature.group,\
org.eclipse.mylyn_feature.feature.group,\
org.eclipse.wst.xml_ui.feature.feature.group,\
org.eclipse.mylyn.java_feature.feature.group,\
org.eclipse.mylyn.pde_feature.feature.group 

The feature names which you need for this operation can be seen on the second page of the standard installation dialog of the Eclipse update manager.

Getting the feature name

30. Setting default preference values

30.1. What are preferences?

The behavior of the Eclipse IDE can be controlled via key value pairs stores as preference settings. Each Eclipse software component can define such perferences and use the values to configure itself. This allows you for example to configure how long the Eclipse waits before the code completion or if the import statements in your source code should be automatically adjusted if you save your source code.

Which preferences are key values stored on the file system, the Eclipse IDE allows the user to configure most of these values via the preference dialog.

30.2. Opening the preference dialog

Select WindowPreferences to open the preference dialog. You can use the filter box to search for specific settings.

Preference settings

Correctly configuring Eclipse to your needs can largely improve your productivity. Most of these preference settings are specific to your workspace but some are also valid for all workspaces.

30.3. Configuring the preference values via the plugin_customization.ini file

You can specify default values for preferences via a file which is typically called plugin_customization.ini.

In this file you enter default values for preference settings. For example, the following will setup a default type filter for the java.awt and javax.swing package.

org.eclipse.jdt.ui/org.eclipse.jdt.ui.typefilter.enabled=java.awt.*;javax.swing.*; 

You link to this file via your eclipse.ini file in your Eclipse installation directory.

The following example eclipse.ini links to the file and it assumes that you created the plugin_customization.ini file in the Eclipse installation directory.

-pluginCustomization
plugin_customization.ini
-startup
plugins/org.eclipse.equinox.launcher_1.3.0.v20120522-1813.jar
--launcher.library
plugins/org.eclipse.equinox.launcher.gtk.linux.x86_64_1.1.200.v20120522-1813
-product
org.eclipse.epp.package.rcp.product
--launcher.defaultAction
openFile
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
--launcher.defaultAction
openFile
-vmargs
-Dosgi.requiredJavaVersion=1.5
-Dhelp.lucene.tokenizer=standard
-XX:MaxPermSize=256m
-Xms40m
-Xmx512m 

30.4. Identifying preference setting values

To identify a key for a certain preference setting you can export existing preference settings via the following approach.

  • start a new workspace

  • change the preference

  • export all preferences

  • search the key in the exported file

Note

You need to remove the scope (e.g., /instance/) before copying it into the plugin_customization.ini file.

30.5. Workspace Mechanics for configuring preferences settings

If you need a consistent setup of preferences for a development team or for multiple Eclipse instances, you can checkout the Workspace Mechanics open source project which is hosted under the following URL:

https://code.google.com/a/eclipselabs.org/p/workspacemechanic/ 

31. Eclipse Java development preferences

31.1. Automatic placement of semicolon

Eclipse can make typing more efficient by placing semicolons at the correct position in your source code.

In the Preference setting select JavaEditorTyping. In the Automatically insert at correct position selection enable the Semicolons checkbox.

Type Assists which allow setting the semicolon to the right position

Afterwards, you can type a semicolon in the middle of your code and Eclipse will position it at the end of the current statement.

31.2. Auto-escape text pasted into Strings

Eclipse allows you to escape text automatically if it is pasted into a String literal. For example, you can copy HTML code and paste it into a String in your Java source. Eclipse would escape the text automatically for you.

Activate this setting via WindowPreferencesJavaEditorTypingIn string literalsEscape text when pasting into string literal

Now you can paste text that should be escaped. The following code snippet shows an example for the resulting code if you paste HTML code containing a link into a string literal.

# paste <a href="tutorials/index.html">Tutorials</a>
# between "" of String s = ""

# results in:
String s = "<a href=\"tutorials/index.html\">Tutorials</a>"; 

31.3. Bracket highlighting

You can configure Eclipse to highlight the matching brackets of a code block in the source code editor.

Highlight the enclosing brackets in JDT

Before the change you would not see the enclosing brackets. Afterwards, they will be slightly highlighted. This helps to see in which block you are.

Without highlight the enclosing brackets in JDT

With highlight the enclosing brackets in JDT

31.4. Activate Save Actions

Eclipse can format your source code and organize your import statements automatically on each save of the Java editor. This is useful as the Save (shortcut: Ctrl+S) is easy to reach.

You can find this setting under JavaEditorSave Actions.

Save Actions

Import statements will only be automatically created if Eclipse finds only one valid import. If Eclipse determines more than one valid import, it will not add import statements automatically. In this case you still need to right-click in your editor and select SourceOrganize Imports (shortcut: Shift+Ctrl+O).

31.5. Type Filters

The Save Actions setting automatically adds required import statements to your source code if there is only one possible import.

Alternatively, or if there are several possible imports, you can use the Organize Imports (shortcut: Ctrl+Shift+O). If there are several alternatives, Eclipse suggests all available packages and the user has to select the right one.

The following shows the available packages for the List class in the Organize Imports dialog.

Dialog for selecting the correct import statement

If you never use certain packages, for example AWT or Swing, you can exclude these packages from Eclipse via the WindowPreferencesJavaAppearanceType Filters setting.

Press the Add packages button to add a specific package or the Add... button to use wildcards. The setting in the following screenshot excludes all AWT packages from the possible imports and other Java search functionality in Eclipse.

Filtering packages from the Eclipse import

Please note that Eclipse shows (in its default configuration) only the packages that are used in the current workspace. If you want to exclude standard Java packages, you have to create at least one Java project.

31.6. Completion overwrites and insert guessed method arguments

Eclipse can override existing method calls, in case you trigger a code completion in an existing statement. Eclipse can also try to guess the correct actual parameters for a method call.

JDT completion

With the first setting you can override methods in the middle of a statement via the Ctrl+Space code assists shortcut.

Trigger code completion

Without this setting you would get the following result, which results in a syntax error.

JDT completion

With this setting you get the following result.

Result

31.7. Time delay before the code completion

The Eclipse IDE is set conservative to give a code completion proposal after a delay of 200ms. On modern machines a good default is 50ms. Change Auto activation delay (ms) value to 50 under WindowPreferencesJavaEditorContent Assists.

Auto activation key for code completion

31.8. Auto activation key for code completion

The Eclipse IDE is configured to give you automatic code completion suggestion only after the . sign. Typically you want to have code completion on every character. Open again the WindowPreferencesJavaEditorContent Assists preference setting and enter .abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZ in the Auto activation trigger for Java.

Auto activation key for code completion

32. Eclipse code checks and cleanup

32.1. Java Development Toolkit code checks

You can define how the Java compiler should react to certain common programming problems, e.g., you can define that an assignment of a variable which has no effect, e.g., x=x, causes an error in Eclipse.

32.2. Configuring the code settings

You can configure these checks in the Eclipse preferences settings via the JavaCompilerErrors/Warnings entry.

Code settings

32.3. Annotation-based Null analysis

You can enable annotation-based null checks in Eclipse via the setting highlighted in the following screenshot.

Null annotations

After enabling this setting, you can use the @NonNull annotation on method parameters or variable definitions to indicate that these are not allowed to be NULL. You can also use the @Nullable annotation to define that a variable can be NULL.

32.4. Automatic code cleanup and removal of trailing whitespace

Eclipse has the option to perform cleanup actions on existing code. This includes the removal of trailing whitespace, the additional of missing annotations but also advanced cleanups like the conversion of code to Java 8 lambda expressions.

To trigger this cleanup, select the Java source file, package or project and select SourceClean-up... from the context menu.

Select Use custom profile and press Configure... to configure the actions which should be performed on your code.

Warning

Ensure to unselect any cleanup action which you do not want to perform.

After finishing the configuration, press OK and the Next button in the cleanup wizard to get a preview of the changes.

33. More on preference settings

33.1. Launch Configuration

Eclipse allows you to start an application via the Run button in the menu or via the Ctrl+F11 shortcut. By default, Eclipse determines if the currently selected file is executable and try to start that. This is sometimes confusing. You can configure the Eclipse IDE to always start the last started program.

To configure this, select WindowPreferencesRun/DebugLaunching and define that the previous launched application should always be launched.

Setting the previous launched application

33.2. Configuring the editors for a file extension

The Editors which are available to open a file can be configured via Window PreferencesGeneralEditorsFile Associations.

The Default button in this preference dialog allows you to set the default editor for a certain file extension, e.g., this is the editor which will be used by default if you open a new file with this extension.

The other configured editors can be selected if you right-click on a file and select Open With In the sub-menu you see the available editors. The available editors depend on your Eclipse installation.

Open With

Eclipse will remember the last editor you used to open a file and use this editor again the next time you open the file.

33.3. Export and import preference settings

You can export your preference settings from one workspace via FileExportGeneralPreferences.

Eclipse does allow you to export some preference settings separately, but for most of them you have to select the Export all flag.

Export your Eclipse preferences.

Similarly, you can import them again into another workspace via FileImportGeneralPreferences.

33.4. Preference settings per project

You can also configure certain preference settings on a per project basis. To do this, select your project, right-click on it and select Properties. For example, on the Java EditorSave Actions you can select the Enable project specific settings checkbox to configure the save action for the current project only.

Preference settings per project

This creates a .settings folder which you can add to your version control system to ensure that every developer uses the same setting.

34. Using and configuring templates and the code formatter

34.1. Templates

In Eclipse you can create templates for code snippets. This code snippets can be activated via autocomplete (Ctrl+Space).

For example, assume that you are frequently creating public void name(){} methods. You could define a template which creates the method body for you.

To create a template for this, select the menu WindowPreferencesJavaEditor Templates.

Maintaining code templates

Press the New button. Create the template shown in the following screenshot.

Creating a new code template

${cursor} indicates that the cursor should be placed at this position after applying the template.

In this example the name npm is your keyword for code completion.

Now every time you type npm in the Java editor and press Ctrl+Space, the system will allow you to replace your keyword with your template.

Using code templates

34.2. Code Formatter

Eclipse allows you also to specify the rules for the code formatter. These rules are used by Eclipse to format your source code. This allows you, for example, to define the settings for the usage of whitespace or for line wrapping.

You find the settings under WindowPreferencesJavaCode StyleFormatter.

Press the New button to create a new set of formatting rules or press the Edit button to adjust an exising profile.

Code formatter

34.3. Code Templates

Eclipse can generate source code automatically. In several cases comments are added to the source code.

Select WindowPreferencesJavaCode Style Code Templates to change the code-generation templates.

In the code tree you have the templates. Select, for example, Code Method Body and press the Edit button to edit this template and to remove the "todo" comment.

Removing the todos from the Java code templates

Chapter . Exercise: Creating and using template

1. Create template for try/catch/finally

Create a template which creates the following block.

Try catch finally template

Place the cursor after the first bracket after the try statement.

2. Use template

Test your template in the Java editor and ensure that it works as expected.

35. Eclipse command line configuration

35.1. Eclipse memory and performance settings

Your Eclipse installation contains a file called eclipse.ini which allows you to configure the memory parameters for the Java virtual machine which runs the Eclipse IDE. For example, the -Xmx parameter can be used to define how large the Java heap size can get. -Xms defines the initial heap size of the Java virtual machine.

The following listing shows an example eclipse.ini file. The parameters after -vmargs configure the Java virtual machine. On a modern machine (with at least 8 Gigabyte available memory) assigning 2024 MB or more to the Java virtual machine is a good practice to run Eclipse faster.

-startup
plugins/org.eclipse.equinox.launcher_1.3.0.v20120522-1813.jar
--launcher.library
plugins/org.eclipse.equinox.launcher.gtk.linux.x86_64_1.1.200.v20120913-144807
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
--launcher.defaultAction
openFile
-vmargs
-Xms512m
-Xmx2024m
-XX:+UseParallelGC 

You can in additional also turn of class verification in the JVM. This avoids that the JVM checks if the class data which are loaded is not corrupt or invalid. This check is only really important if byte code in manipulated and adds 10-20% additional startup time. To disable this check add the -Xverify:none option option on your JVM.

Note

These options can also be specified per invocation of the Eclipse IDE, e.g., for desktop shortcuts. For example to start Eclipse with 2GB of memory, use the following command line: ./eclipse -vmargs -Xmx2024m.

35.2. Eclipse startup parameters

Eclipse allows you to configure it via startup parameters. This requires that you start Eclipse from the command line or that you configure your launcher links to include these parameters.

The following table shows important parameters.

Table 2. Workspace startup parameters

Parameter Description
-data workspace_path Predefine the Eclipse workspace
-showLocation Enables the display of the current workspace directory in the header of the running IDE


For example, if you want to start Eclipse under Microsoft Windows using the c:\temp directory as workspace, you can start Eclipse via the following command from the command line.

c:\eclipse.exe -data "c:\temp" 

Depending on your platform, you may have to put the path name into double quotes.

Note

You find all available runtime options in the Eclipse help if you search for the "Eclipse runtime options" term.

36. Local history for files

36.1. Local history

Eclipse keeps a local history of files which have changed. Every time an editable file is saved, the Eclipse runtime updates the local history of that file and logs the changes that have been made. This local history can then be accessed and used to revert the file changes or to compare against a previous version.

36.2. Compare files based on local history

To compare the current version of a file with a local version stored by Eclipse, right-click on the file and select Compare WithLocal History... from the context menu. Eclipse opens the History view.

If you double-click on an older version of the file, the Compare view shows the differences as depicted in the following screenshot.

Local compare view

36.3. Replace files based on local history

You can replace files based on the local history. Right-click on the file and select Replace WithLocal history... to start this action.

37. Organizing your workspace

37.1. Working sets and tasks

The Eclipse IDE allows you to organize your project into working sets so that you can hide certain resources.

37.2. Working sets

You will create more and more projects in your development career. Therefore, the data in your workspace grows and it is hard to find the right information.

You can use working sets to organize your displayed projects / data. To set up your working set, select the Package Exploreropen the drop-down menuSelect Working Set...

Showing the working set

Press the New button on the following dialog to create a working set.

Creating new working sets

On the next dialog select Resource, press the Next button and select the projects you would like to see and give it a name.

Creating new working sets

Creating new working sets

Creating new working sets

You can now filter the displayed files in the Package Explorer based on the created working set.

Filtering resources for the working set

Tip

You can also use the working set to structure your projects in your workspace. For this, select Working Sets from the context menu of the Package Explorer view.

Structure by working set

Structure by working set

38. Tasks

38.1. Task management

You can place markers in the code which you can later access via the Task view .

You can use // TODO, // FIXME or // XXX tags in your code to add task reminders.

This indicates a task for Eclipse. You find those in the Task view of Eclipse. Via double-clicking on the task, you can navigate to the corresponding code.

You can open this view via WindowShow ViewTasks.

For example, add a TODO to your MyFirstClass class to see it in the Tasks view .

package de.vogella.eclipse.ide.first;

public class MyFirstClass {

  private static final String HELLO = "Hello Eclipse!";

  public static void main(String[] args) {
    // TODO Provide user interface
    System.out.println(HELLO);
    int sum = 0;
    sum = calculateSum(sum);
    System.out.println(sum);
  }

  private static int calculateSum(int sum) {
    for (int i = 0; i <= 100; i++) {
      sum += i;
    }
    return sum;
  }
} 

Close the editor for the MyFirstClass class. If you now double-click on the tasks, the Java editor opens again and the TODO comment is selected.

Tip

The Task view shows only the tasks from the currently open projects. See Section 15.3, “Closing and opening projects”.

38.2. Own tags

You can also define your own tags in the Eclipse preferences via WindowPreferencesJavaCompilerTask Tags.

Defining new tasks tags

38.3. Mylyn

A more advanced tasks management system is available with the Mylyn plug-in.

39. Eclipse online resources

39.1. Online documentations

The Eclipse help system is available from within your Eclipse installation as well as online.

With your running Eclipse IDE you can access the online help via HelpHelp Contents. This will start a new window which shows you the help topics for your currently installed components.

Starting the Eclipse help

You find the online help for the current release of the Eclipse IDE under the following URL: Eclipse online help. The online help is version-dependent and contains the help for all Eclipse projects of the simultaneous release.

39.2. Web resources

The Eclipse webpage also contains a list of relevant resources about Eclipse and Eclipse programming. You find these resources under the following link: Eclipse resources and Eclipse corner wiki.

You also find lots of tutorials about the usage of the Eclipse IDE from the vogella GmbH on the following webpage: vogella Eclipse IDE tutorials.

Information about Eclipse plug-in and RCP development from the vogella GmbH can be found on the following webpage: Eclipse Plug-in and RCP tutorials.

40. Reporting Eclipse bugs and asking questions

40.1. Asking (and answering) questions

Due to the complexity and extensibility of Eclipse, you will need additional resources to help you solve your specific problems. Fortunately, the web contains several resources which can help you with your Eclipse problems.

Currently, the best places to find, ask and answer questions are the Eclipse forums and Stack Overflow. Try to stay polite with your postings, as the Eclipse community values polite behavior.

The Eclipse forums offer several topic-specific forums in which you can post and answer questions. To post or to answer questions in the Eclipse forums, you need a valid user account in the Eclipse bug tracker. The advantage of the Eclipse forums is that, depending on the topic, developers of Eclipse projects (Eclipse committers) are also active there and might directly answer your question.

Stack Overflow also requires a user account and its community is also very active. Stack Overflow does not have separate forum sections for specific questions. Stack Overflow allows to tag questions with the relevant keyword, e.g., Eclipse and people search for them or subscribe to these theses.

Note

Ensure that you search the forums and mailing lists for solutions for your problem since often somebody else has asked the same question earlier and the answer is already available.

40.2. Eclipse bug reports and feature requests

40.2.1. Reporting bugs and feature requests

If you encounter a problem with the Eclipse IDE or think about a potential improvement for it, you should report this to the Eclipse project. The Eclipse bug and feature tracker is using the open source Bugzilla project from Mozilla. In this system you enter error reports for bugs you encounter with the usage of Eclipse and also to request new feature or improvements of existing features.

Tip

Most Eclipse project receive lots of bug and feature requests. So if you want something fixed or enhanced you may have to provide a Gerrit review for it. If the Eclipse developer sees that you try to fix the problem yourself, you typically receive more support from them.

40.2.2. Using the Eclipse bugzilla system

This bug tracker can be found under Eclipse Bugzilla. Here you can search for existing bugs and review them.

To participate actively in the Eclipse bug tracker, you need to create a new account. This can be done by pressing the Create a New Account link.

Opening an account at Eclipse bugzilla

Once you have a user account, you can login to the Eclipse bug tracker. This allows you to comment on existing bugs and report new ones. The user data for the all Eclipse sites are the same, i.e, the forum, marketplace, bug tracker, etc. Only for the Gerrit access, different user data is used.

As example you can report bugs for the Eclipse platform via the following link: Bug report for the Eclipse platform .

40.2.3. Eclipse bug priorities

The Eclipse Bugzilla system allows you and the Eclipse committer to enter the bug priority. But overall, it is up to each project do decide how they handle bugs so some variation from project to project will occur. The following rules can be used as guideline.

Table 3. Bug priorities

Priority Description
blocker The bug blocks development or testing of the build and no workaround is known.
critical Implies "loss of data" or frequent crashes or a severe memory leak.
major Implies a "major loss of function".
normal This is the default value for new bug reports. Implies some loss of functionality under specific circumstances, typically the correct setting unless one of the other levels fit.
minor Something is wrong, but doesn't affect function significantly or other problem where easy workaround is present.
trivial This describes a cosmetic problem like misspelled words or misaligned text, but doesn't affect function.
enhancement Represents a request for enhancement (also for "major" features that would be really nice to have).


41. Next steps

To learn how to debug Eclipse Java programs, you can use Eclipse Debugging.

To learn Java Web development, you can use with Servlet and JSP development. If you want to develop rich stand-alone Java clients, you can use Eclipse RCP. You can also extend Eclipse with Eclipse Plug-ins.

Good luck in your journey of learning Java!

42. About this website

43. Links and Literature

43.1. Eclipse Resources

43.1.2. Eclipse Bug Tracker and Eclipse forum

Eclipse Forum for asking questions and providing feedback.

Eclipse Bug Tracker for reporting errors or feature requests.

43.1.3. Eclipse additional themes

Very flexible Eclipse Theme by Jeeeyul

43.2. vogella GmbH training and consulting support

TRAINING SERVICE & SUPPORT
The vogella company provides comprehensive training and education services from experts in the areas of Eclipse RCP, Android, Git, Java, Gradle and Spring. We offer both public and inhouse training. Whichever course you decide to take, you are guaranteed to experience what many before you refer to as “The best IT class I have ever attended”. The vogella company offers expert consulting services, development support and coaching. Our customers range from Fortune 100 corporations to individual developers.