by Lars Vogel
Version 3.0
Copyright © 2007, 2008, 2009, 2010, 2011, 2012 Lars Vogel
10.04.2012
| Revision History | ||
|---|---|---|
| Revision 0.1 | 18.07.2007 | Lars Vogel |
| Created | ||
| Revision 0.2 - 3.0 | 18.05.2008 - 10.04.2012 | Lars Vogel |
| bugfixes and enhancements | ||
Table of Contents
Most people know Eclipse as an integrated development environment (IDE) for Java. Today it is the leading development environment for Java with a marketshare of approx. 65%.
Eclipse is created by an Open Source community and is used in several different areas, e.g. as a development environment for Java or Android applications. Eclipse roots go back to 2001.
The Eclipse project is governed by the Eclipse Foundation. The Eclipse Foundation is a non-profit, member supported corporation that hosts the Eclipse projects and helps to cultivate both an open source community and an ecosystem of complementary products and services.
The Eclipse IDE can be extended with additional software components. Eclipse calls these software components "plug-ins". Several Open Source projects and companies have extended the Eclipse IDE.
It is also possible to use Eclipse as a basis for creating general purpose applications. These applications are known as Eclipse Rich Client Platform (Eclipse RCP) applications . RCP).
Eclipse requires an installed Java Runtime. I recommend to use Java 7 (also known as Java 1.7) or Java 6.
Java comes in two flavors, the Java Runtime Environment (JRE) and the Java Development Kit (JDK). The JRE contains only the necessary functionality to start Java programs, while the JDK contains in addition the development tools.
Eclipse contains its own development tools, e.g. Java compiler. Therefore for this tutorial it is sufficient to use the JRE.
The JDK is required if you compile Java source code outside Eclipse and for advanced development scenarios. For example if you use automatic builds or if you develop web development. These scenarios are not covered in this tutorial.
Java might already be installed on your machine. You can test this by opening a console (if you are using Windows: Win+R, enter "cmd" and press Enter) and by typing in the following command:
java -version
If Java is correctly installed you should see some information about your Java installation. If the command line return the information that the program could not be found, you have to install Java. A Google search for "How to install Java on ..." should result in helpful links. Replace "..." with your operating system, e.g. Windows, Ubuntu, Mac OS X, etc.
To install Eclipse download the package "Eclipse IDE for Java Developers" from the website http://www.eclipse.org/downloads and unpack it to a local directory.
The download is a "zip" file. Most operating system can extract zip files in their file browser, e.g. Windows7 via right mouse click on the file and selecting "Extract all...". If in doubt, search via Google for "How to unzip a file on ...", again replacing "..." with your operating system.
Use a directory path which does not contain spaces in its name, as Eclipse sometimes has problems with that.
After unpacking the download, Eclipse is ready to be used; no additional installation procedure is required.
To start Eclipse double-click on the file
eclipse.exe
(Microsoft Windows) or
eclipse
(Linux / Mac) in the directory where you
unpacked Eclipse.
The system
will
prompt you for a workspace.
The
workspace
is
the place
where you store
your Java projects (more on
workspaces
later). Select
an empty directory
and press Ok.
Eclipse will start and show the Welcome page. Close the welcome page by pressing the "X" beside "Welcome".
Eclipse provides
Perspectives,
Views
and
Editors.
Views
and
Editors
are grouped into
Perspectives. All projects are
located in a
workspace.
The
workspace
is the physical location (file path) you are
working in. You can
choose the workspace during startup of
Eclipse or
via the menu (
→ → )
.
All your projects,
source files, images and other artifacts
will be
stored and saved in
your workspace.
Eclipse allows that certain behavior is configured via startup parameters. The following parameters are relevant for the Workspace.
Table 1. Workspace Startup Parameterse
| Parameter | Description |
|---|---|
| -data workspace_path | Predefine the Eclipse workspace. |
| -showLocation | Configures Eclipse so that is shows the current workspace directory in the title of Eclipse. |
For example if you want to start Eclipse under Microsoft Windows with the workspace "c:\temp" you can use the following command from the command line.
Home
Tutorials
Trainings
Books
Connect
c:\eclipse.exe -data "c:\temp"
Depending on your platform you may have to put the path name into double quotes.
Parts
are user interface components which allow to navigate and modify
data.
Parts
are typically divided into
Views
and
Editors.
The distinction into
Views
and
Editors
is primarily not based on technical differences, but on a different
concept of using and arranging these
Parts.
A
View
is
typically
used to work on a set of data, which might be hierarchical
structured. If data
is
changed via the
View,
this change is typically directly applied to the
underlying data
structure. A
View
sometimes allows us to open
an
Editor
for a selected set of the data.
An example for a
View
is the Java Package Explorer, which allow you browse the files of
Eclipse Projects. If you choose to change data in the Package
Explorer, e.g. if you rename a file, the file name is directly
changed
on the filesystem.
Editors
are
typically used to modify a single data element, e.g. a file or a
data object. To apply the
changes done in an
editor to the
data
structure, the user has to explicitly save the editor content.
Editors
were traditionally placed in a certain area, called the "editor
area".
Until Eclipse 4 this was a hard limitation, it was not
possible to move
an
Editor
out of this area; Eclipse 4 allows to place
Editors
at any position in a
Perspective.
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" command.
A
Perspective
is a visual container for a set of
Parts. The Eclipse IDE uses
Perspectives
to arrange
Parts
for different development tasks.
You can change the layout and content within a
Perspective
by opening or closing
Parts
and by re-arranging them.
As of Eclipse 4.x Perspectives are optional elements for Eclipse
applications.
The Eclipse IDE ships with several default
Perspectives.
For Java development you
usually use the
Java Perspective, but Eclipse has much more predefined
Perspectives, e.g. Debug, Git Repositories, CVS Repositories.
Eclipse allows you to switch to another perspective via the menu → → .
A common problem is that you mis-configured your
Perspective, e.g. by closing a
View. You can reset a
Perspective
to its original
state
via the menu
→ .
The default
Perspective
for Java development can be opened via
→ → .
On the left hand side, this perspective shows the
"Package Explorer"
View,
which allows to browse your Java projects and to select the
components you want to work on via 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 an
Editor.
The following picture shows the Eclipse IDE in its standard Java
perspective. The "Package Explorer" is on the left. In the middle
you
have the
open
Editor
for a Java source file. If several
Editors
would be open, they would be stacked in the same place and you could
switch between them by clicking on the next
Editor. All editors share the same part of the Eclipse IDE; this part is
called the "editor area".
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 "Console" view shows the output of
System.out
statements in your code.
The Package Explorer allows displaying the associated file from
the
currently selected editor. For example if you working on
Foo.java
and
you change in the editor to
Var.java
then the corresponding file will be selected in
the "Package
explorer"
View.
To activate this behavior, press the button "Link with Editor" in
the
"Package
explorer"
View.
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 it is closed you
can
open it
via
→ → .
You can configure the content of the "Problems"
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".
The following describes how to create a minimal Java program 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.
Select from the menu
→ → . Enter
de.vogella.eclipse.ide.first
as the project name. Select the flag "Create
separate folders for
sources and class files".
Press finish 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.
Create a new
package. A good convention is to use the same name
for the top package and
the
project. Create therefore the package
de.vogella.eclipse.ide.first.
Select the folder
src, right click on it and select
→ .
We will now create a Java class. Right click on your package and select → .
Enter
MyFirstClass
as the class name and
select the flag "public static void main
(String[] args)".
This creates a new file and opens an
Editor
to edit the source code of this file. Write the following code.
package de.vogella.eclipse.ide.first; public class MyFirstClass { public static void main(String[] args) { System.out.println("Hello Eclipse!"); } }
Now run your code. Right click on your Java class and select → .
Finished! You should see the output in the console.
To run your Java program outside of Eclipse 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 on it and select
Export.
Select JAR file, select next. Select your project and maintain
the
export destination and a name for the jar file. I named it
myprogram.jar.
Press finish. This creates a jar file in your selected output directory.
Open a command shell, e.g. under Microsoft Windows select
→
and type
cmd
and press enter. This should open a console.
Switch to your output directory, by
typing
cd path. For example if
your
jar is located in
c:\temp
type
cd c:\temp.
To run this program you need to include the jar file in your
classpath. The
classpath
defines what Java classes are available to the Java
runtime. You can
add a
jar
file to the classpath with the
-jar
option.
java -classpath myprogram.jar de.vogella.eclipse.ide.first.MyFirstClass
If you type the command from above and are in the correct directory you should see the "Hello Eclipse!" output on the console.
Congratulations! You created your first Java project, a package, a Java class and you ran this program inside and outside Eclipse.
The content assistant allows you to get input help in an editor. 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 it's
methods, type
person.
and
press
CTRL+Space.
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.
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.
Quick Fix is extremely powerful. It allows you to create new local variables and fields as well as new methods and new classes. I can put try-catch statements around your exceptions. It can assign a statement to a variable and much more.
You can navigate between the classes in your project via the "Package
Explorer"
View.
In addition you can open any class via 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.
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.
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 → , mark both fields and press "Ok".
Select → , select again both your fields and press the "Ok" button.
Select → , mark again both fields and press "Ok".
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 + "]"; } }
Refactoring is the process of restructuring the code without changing his behavior. For example renaming a Java class or method is a refactoring activity.
Eclipse supports simple refactoring activities, for example renaming or moving. For example you can select your class, right click on it and select → to rename your class or method. Eclipse will make sure that all calls in your Workspace to your your class or method will also be renamed.
The following shows a screenshot for calling the "Rename" refactoring on a class.
For the next examples change the code of "MyFirstClass.java" to the following.
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 = 0; i <= 100; i++) { sum += i; } System.out.println(sum); } }
Another useful refactoring is to mark code and create a method from the selected code. For this mark the coding of the "for" loop, right click and select → . Use "calculateSum" as name of the new method.
The resulting class should look like the following.
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 = 0; i <= 100; i++) { sum += i; } return sum; } }
You can also extract strings and create constants from them. Mark for this example "Hello Eclipse!", right click on it and select → . Name your new constant "HELLO".
The resulting class should look like the following.
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 = 0; i <= 100; i++) { sum += i; } return sum; } }
Eclipse has much more refactorings, in most cases you should get an idea of the performed action by the naming of the refactoring operation.
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
The following describes how to add Java libraries to your project. Java libraries are distributed via "jar" files. It assumes that you have a jar file available; if not feel free to skip this step.
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
→ .
From the menu select
→ → → .
Select your
jar and select the folder
lib
as target. Alternatively, just copy and paste your
jar
file into the "lib" folder.
Right click on your project and select Properties. Under → select the button "Add JARs".
The following example shows how the result would look like, if the junit-4.4.jar had been added to the project.
Afterwards you can use the classes contained in the
jar
file in your Java source code.
As said earlier you can open any class via 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 decompiled byte-code of that class.
This happens if you open a class from Java library and the source for this .jar file is not available. The same happens if you open a class from the standard Java library without attaching the source code to it.
To browse the source of a type contained in a library (i.e. .jar file), you can attach a source archive or source folder to that library. Afterwards the editor will show the source instead of the byte-code.
In addition setting the source attachment allows debugging this source code.
The Source Attachment dialog can be reached in the Java Build Path page of a project. To open this page, → → . On the "Libraries" tab, expand the library's node, select the "Source attachment" attribute and press Edit.
In the Location path field, enter the path of an archive or a folder containing the source.
The following shows this 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".
It is also possible to add Javadoc to a library which you use.
Download the Javadoc of the jar and put it somewhere in your filesystem.
Open the Java Build Path page of a project via → → . On the "Libraries" tab expand the library's node, select the "Javadoc location" attribute and press Edit.
Enter the location to the file which contains the Javadoc.
Eclipse contains an Update Manager
which allows you
to install and
update
software components. Installable software components are
called
features
and consists of
plug-ins.
To update your Eclipse installation, select → . The system will search for updates for the already installed software components. If it finds updated components, it will ask you to approve the update.
To install a new functionality, select →
From the "Work with" list, select an URL from which you would like to install.
To add a new update site, press and enter the new URL as well as a name for the new update site.
Sometimes you have to uncheck "Group items by category" because not all available plug-ins are categorized. If they are not categorized, they will not be displayed, unless the grouping is disabled.
If you’re using a plug-in for which no Update Site is available, you can use the "dropins" folder in your Eclipse installation directory.
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.
Eclipse also contains a client which allows installing software components from the Eclipse Marketplace. 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 don't have to know the URL for the update site.
To open the Eclipse Marketplace select → .
You can use the "Find" box to search for components. Pressing "Install" will start the installation process.
Eclipse 4.2 also allow to export a description file which for selected Eclipse components. Other users can import this description file into their Eclipse installation and install these components from the file.
This way Eclipse installation can be kept in sync with each other.
To export a description file, select → → → and select the components which should be included into your description file.
To install selected components of this file in another Eclipse Installation, open it with → → → and follow the wizard.
The behavior of the Eclipse IDE can be controlled via the Preference Settings. Select → to open the preference settings dialog. You can use the filter box to search for specific settings.
Eclipse can make typing more efficient by placing semicolons at the correct position in your source code.
In the Preference setting select → → . In the section "Automatically insert at correct position”, enable the "Semicolons" checkbox.
You can now type a semicolon in the middle of your code and Eclipse will position it at the end of the current statement.
Eclipse can format your source code and organize your import statements automatically during a save operation. This is useful as the "Save" shortcut ( CTRL+S ) is easy to reach.
You can find this setting under → → .
Import statements will only be automatically imported, if Eclipse finds only one valid import. If Eclipse determines more than one valid import, it will not add import statements automatically.
The "Organize imports" Save Action or the "“Organize Imports” shortcut ( CTRL+Shift+) ) allows to import the packages which are required. If there are several alternatives, Eclipse suggests all available packages and the user has to select the right one.
To following shows the available packages for the
List
class in the "Organize Imports" dialog.
This is annoying, if you never use certain packages. You can exclude these packages via → → → →
Press to add a specific package or to use wildcards. The following will exclude all AWT packages from import.
If you have to frequently type the same code / part of the document, you can create templates which 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 → → → → .
Press New. Create the template shown in the following screenshot.
${cursor}
indicates
that the cursor should be placed at this
position after
applying the
template.
In this example the name "npm" is your keyword.
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.
The
Editors
which are available to open a file can be configured via
→ → → → .
The "Default" button in this preference dialog allows to set the default editor for a certain file extension, e.g. this is the editor which will be used per default if you open a new file with this extension.
The other configured
Editors
can be selected, if you right mouse click on a file and select
"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.
Eclipse generates lots of source code automatically. For example, in several cases comments are added to the source code.
Select → → → → to change the code generation templates.
In the code tree you have the templates. Select for example → and press "Edit" to edit this template and to remove the "todo" comment.
You can export your preference settings from one workspace via → → → .
Similarly you can import them again into another workspace.
You can use
// TODO
comments 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
→ → .
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.
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 → →
Press "New" on the following dialog to create a working set.
On the next dialog select "Resource", press Next and select the projects you would like to see and give it a name.
You can now easily display only the files you want to see.
Eclipse has a public bug tracker based on Bugzilla. This bugtracker can be found under https://bugs.eclipse.org/bugs/. Here you can search for existing bugs and review them.
To participate actively in the Eclipse bugtracker you need to create a new account. This can be done by pressing the "Open a New Account" link.
Once you have an user you can login to the Eclipse bugtracker. This allows you to comment on existing bugs and report new ones.
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 → . This will start a new window which shows you the help topics for your currently installed components.
Online you find the online help under http://www.eclipse.org/documentation/. The online help is version dependent and contains the help for all Eclipse projects included in the selected release.
Due to the complexity and extensibility of Eclipse you will need additional resources to help you resolve your specific problems. Fortunately the web contains several resources which can help you with your Eclipse problems.
Currently the best places to ask questions are the Eclipse forums, which can be found under http://eclipse.org/forums and Stackoverflow, which can be found under http://stackoverflow.com.
The Eclipse forums offer several topic specific forums in which you can post and answer questions. To post questions in the Eclipse forums you need a valid user in the Eclipse bugtracker. The advantage of the Eclipse forums is that, depending on the topic, Eclipse committer are also active there and might directly answer your question.
Stackoverflow also requires a user and its community is also very active. Stackoverflow does not have separate forums specific questions. In Stackoverflow you tag your questions with the relevant keyword, e.g. "Eclipse" and people interested in these keyword search for them or subscribe to them.
Both places are excellent places to ask questions. If you ask a question it is in general good advice to be polite and to give a good error description as this motivates people to give you high quality answers.
The Eclipse homepage also contains a list of relevant resources about Eclipse and Eclipse programming. You find these resources under http://www.eclipse.org/resources/.
Also the author of this description maintains several Eclipse relevant tutorials on his webpage. You find all his Eclipse related articles on http://www.vogella.com/eclipse.html.
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 extend Eclipse with Eclipse Plug-ins .
Good luck in your journey of learning Java!
Before posting questions, please see the vogella FAQ. If you have questions or find an error in this article please use the www.vogella.com Google Group. I have created a short list how to create good questions which might also help you.
Eclipse RCP Training (German) Eclipse RCP Training with Lars Vogel
Android Tutorial Introduction to Android Programming
GWT Tutorial Program in Java and compile to JavaScript and HTML
Eclipse RCP Tutorial Create native applications in Java
JUnit Tutorial Test your application
Git Tutorial Put everything you have under distributed version control system
