NetBeans

NetBeans users ask the following question about IntelliJ IDEA most frequently:
ABOUT PROJECTS
o How do I open a NetBeans project in IntelliJ IDEA?
o What's the difference between projects and modules?
o Is there a directory-based project format in IntelliJ IDEA?
o How do I change the JDK for my project?
o How do I add a library to my project?
o How do I configure a Web framework for my project?
o The Run button is disabled. How do I run my application?
o How do I generate an Ant build script for my project?
o Where is the Options dialog?
o How do I close a project?
ABOUT THE EDITOR
o Can I use the NetBeans key bindings in IntelliJ IDEA?
o How does code completion in IntelliJ IDEA work?
o Is local history in IntelliJ IDEA any different from that in NetBeans?
o Are there any special code analysis features in IntelliJ IDEA?
o Can I enable 'mark occurrences' in IntelliJ IDEA?
o Can I enable 'compile on save' in IntelliJ IDEA?
o Can I enable 'deploy on save' in IntelliJ IDEA?
ABOUT PLUGINS
o Can I use NetBeans plugins in IntelliJ IDEA?
o How do I find the plugin that I need?
o How do I install the plugin that I have available on my computer?
o I'd like to write a plugin for IntelliJ IDEA. Are there any instructions?
o Is it possible to build NetBeans RCP applications with IntelliJ IDEA?

ABOUT PROJECTS
How do I open a NetBeans project in IntelliJ IDEA?
Use File | New | Project from Existing Sources and select your NetBeans project directory.
When the Import Project wizard opens, select the Create project from existing sources option
and then follow the instructions of the wizard.
IntelliJ IDEA will add the necessary definition files (the .idea directory) to your project directory.
The NetBeans .nbproject directory and build.xml will remain untouched, and you'll be able to use
IntelliJ IDEA along with NetBeans.
During the import IntelliJ IDEA will fix missing libraries, add facets for different Web
frameworks and create a run configuration.
If you are using Maven with NetBeans and you want to import a Maven project into IntelliJ
IDEA, select File | Open and then select your project's pom.xml. You'll still need to configure a
run configuration, however, all project dependencies will get resolved.
See also, Creating a Project by Importing Existing Sources.

What's the difference between projects and modules?

1

IntelliJ IDEA creates a project for an entire code base and a module for each of its individual
components. So, IntelliJ IDEA module is more like a NetBeans project.
The following table maps the most important NetBeans concepts to IntelliJ IDEA ones.
NetBeans
IntelliJ IDEA
Project
Module
Global library
Global library
Project library
Module library
Project dependency
Module dependency

Is there a directory-based project format in IntelliJ IDEA?

Yes, there is a .idea directory where project definition XML files are stored. For more
information, see Project.

How do I change the JDK for my project?

1. Open the Project Structure dialog (File | Project Structure or Ctrl+Shift+Alt+S).
2. Under Platform Settings, select SDKs.
3. Click , select JDK and specify the JDK installation directory.
4. Click Apply.
5. Under Project Settings, select Project.
6. Under Project SDK, select the JDK from the list.
7. Click OK.
For more information, see Configuring Global, Project and Module SDKs.

How do I add a library to my project?

1. Open the Project Structure dialog (File | Project Structure or Ctrl+Shift+Alt+S).
2. Under Project Settings, select Libraries.
3. Click , select Java and specify the library location.
4. Select the modules in which this library will be used.
5. Click OK.
For more information, see Configuring Project and Global Libraries and Configuring Module
Dependencies and Libraries.

How do I configure a Web framework for my project?

In IntelliJ IDEA Ultimate (there's no corresponding functionality in the Community Edition):
1. Open the Project tool window (e.g. View | Tool Windows | Project).
2. Right-click the necessary module and select Add Framework Support. (Framework
support is enabled at a module level.)
3. In the Add Frameworks Support dialog that opens, select the frameworks to be
supported, specify the associated settings and click OK.
For more information, see Add Frameworks Support Dialog and e.g. Enabling JSF support for
an existing module.

The Run button is disabled. How do I run my application?

The Run button is disabled because there are no run configurations in your project.
If you have a Java class with a main() method, open the corresponding file in the editor, rightclick the editing area and select Run '<FileName>.main()'. As a result, the necessary run
configuration will be created automatically and then executed.
You can also create run configurations yourself: e.g. Run | Edit Configurations | , etc.
2

How do I generate an Ant build script for my project?

Select Build | Generate Ant Build. For more information, see Generating Ant Build File.

Where is the Options dialog?

In IntelliJ IDEA, the Settings dialog is used for similar purposes. To open this dialog, press
Ctrl+Alt+S.
There is also the Project Structure dialog (Ctrl+Shift+Alt+S) which lets you manage JDKs, libraries,
module dependencies, etc.
For more information, see Settings / Preferences Dialog and Project Structure Dialog.

How do I close a project?

Select File | Close Project. You can also use File | Exit to close all open projects and quit IntelliJ
IDEA. See also, Opening, Reopening and Closing Projects.

ABOUT THE EDITOR

Can I use the NetBeans key bindings in IntelliJ IDEA?
Yes, you can.
1. Open the Settings dialog (e.g. Ctrl+Alt+S).
2. In the Appearance and Behavior category, select Keymap.
3. In the right-hand part of the dialog, next to Keymaps, select NetBeans 6.5 from the list.
4. Click OK.

How does code completion in IntelliJ IDEA work?

The code completion suggestion list appears automatically after you type one or two letters. To
narrow down this list, use:
Ctrl+Space. The list is reduced to keywords and also the names of classes, methods and
fields available in the current context. Note that the list changes when you press
Ctrl+Space for the second or third time.
Ctrl+Shift+Space. Only the types appropriate for the current context are shown.
For more information, see Auto-Completing Code.

Is local history in IntelliJ IDEA any different from that in NetBeans?

Local history in IntelliJ IDEA, generally, is more detailed. Whatever you do with a directory,
file, class, method or field, or a code block is reflected in your local history. The local history
also includes VCS operations.
For more information, see Using Local History.

Are there any special code analysis features in IntelliJ IDEA?

IntelliJ IDEA can analyze dependencies, data flows and stacktraces, find duplicates and
evaluate code quality. Just have a look at the options in the Analyze menu.
For more information, see Analyzing Applications and Code Inspection.

Can I enable 'mark occurrences' in IntelliJ IDEA?

You can. The corresponding option in IntelliJ IDEA is called Highlight usages of element at
caret. This option is enabled by default.
Just in case:
1. Open the Settings dialog (e.g. Ctrl+Alt+S).
2. In the Editor category, select General.
3. In the right-hand part of the dialog, under Highlight on Caret Movement, select the
Highlight usages of element at caret check box.
3

4. Click OK.
See also, Highlighting Usages.

Can I enable 'compile on save' in IntelliJ IDEA?

You can.
To enable automatic compilation on every save (or autosave), turn on the Make project
automatically option in the Settings dialog:
1. Open the Settings dialog (e.g. Ctrl+Alt+S).
2. In the Build, Execution, Deployment category, select Compiler.
3. In the right-hand part of the dialog, select the Make project automatically check box.
4. Click OK.
Also note that by default, IntelliJ IDEA saves changed files automatically, so you don't need to
use Ctrl+S as frequently as in other IDEs.

Can I enable 'deploy on save' in IntelliJ IDEA?

There is no such option in IntelliJ IDEA settings, however, you can get similar result by
choosing an appropriate application update option in the corresponding run configuration.
For more information, see Updating Applications on Application Servers.
(The corresponding functionality is available only in IntelliJ IDEA Ultimate. The Community
Edition doesn't provide integration with application servers.)

ABOUT PLUGINS
Can I use NetBeans plugins in IntelliJ IDEA?
Unfortunately not. However, a lot of functionality implemented as plugins for NetBeans is
available in IntelliJ IDEA "out of the box". Besides, there's a lot of plugins for IntelliJ IDEA, so
you can always find an IntelliJ IDEA plugin with the functionality similar to that of your
favorite NetBeans plugin.

How do I find the plugin that I need?

All the functions related to working with plugins are on the Plugins page of the Settings dialog
(Ctrl+Alt+S | Plugins). You can look for, download, install and update the plugins as well as
enable and disable them.
For more information, see Plugins and Managing Plugins.

How do I install the plugin that I have available on my computer?

1.
2.
3.
4.
5.
6.

Open the Settings dialog (e.g. Ctrl+Alt+S).

In the left-hand pane, select Plugins.
In the lower part of the Plugins page, click Install plugin from disk.
In the dialog that opens, select the plugin file (normally, a JAR or ZIP).
Click OK.
If asked, restart IntelliJ IDEA.

I'd like to write a plugin for IntelliJ IDEA. Are there any instructions?
Yes, have a look at:
Plugin Development Guidelines
Information for Plugin Developers on the IntelliJ IDEA Plugins page
Open API and Plugin Development

Is it possible to build NetBeans RCP applications with IntelliJ IDEA?

4

It is possible, however you won't get the same kind of support you would in the case of
NetBeans (wizards, menu actions, etc.). Have a look at Using IntelliJ IDEA for NetBeans
Platform Development.

NetBeans For Java

How To Install and Get Started with Java Programming
(on Windows, Mac and Linux)
NetBeans (@ http://netbeans.org) is an open-source Integrated Development Environment
(IDE). NetBeans began in 1996 as a Java IDE student project at Charles University in Prague.
Sun Microsystems acquired NetBeans in 1999. In 2010, Oracle acquired Sun (and thus
NetBeans).
Compared with its rival Eclipse (http://www.elicpse.org) (both are open-source, so I don't
know what are they competing for?), NetBeans provides seamless support for Java AWT/Swing,
Java ME mobility pack, Java EE, and bundled with an excellent profiler for performance tuning.

1. How to Install NetBeans

1.1 For Windows
Step 0: Install JDK

To use NetBeans for Java programming, you need to first install Java Development Kit (JDK).
See "JDK - How to Install".
Step 1: Download

Download "NetBeans IDE" installer from http://netbeans.org/downloads/index.html. There

are many "bundles" available. For beginners, choose the "Java SE" (e.g., "netbeans-8.0-javasewindows.exe").
Step 2: Run the Installer

Run the downloaded installer. Choose your installation directory (e.g., "d:\myproject").
1.2 For Mac

Read "How to Install NetBeans on Mac".

1.3 For Ubuntu Linux

Read "How to Install NetBeans on Ubuntu".

2. Writing a Hello-world Java Program in NetBeans

Step 0: Launch NetBeans

Launch NetBeans. If the "Start Page" appears, close it by clicking the "close" button.
Step 1: Create a New Project

For each Java application, you need to create a "project" to keep all the source files, classes and
relevant resources.

1. From "File" menu Choose "New Project...".

2. In "Choose Project" diglog Under "Categories", choose "Java" Under "Projects", choose "Java
Application" "Next".
3. In "Name and Location" Under "Project Name", enter "FirstProject" In "Project Location",
select a suitable directory to save your works Uncheck "Create Main class" Finish.

Step 2: Write a Hello-world Java Program

1. Right-click on "FirstProject" "New" "Java Class..." (OR from the "File" menu "New File..."
Categories: "Java", File Types: "Java Class" "Next").
2. In "Name and Location" Under "Class Name", enter "Hello" Delete the content in "Package" if
it is not empty "Finish".
3. The source file "Hello.java" appears in the editor panel. Enter the following codes:
4.
5.
6.
7.
8.

/** First Java Program to say Hello wrold */

public class Hello {
public static void main(String[] args) {
System.out.println("Hello, world");
}
}

Step 3: Compile & Execute

There is no need to "compile" the source code explicitly, as NetBeans performs the so-called
incremental compilation (i.e., the source statement is compiled while it is entered).
To run the program, right-click anywhere in the source (or from the "Run" menu), select "Run
File" (or "Run Hello.java"). Observe the output on the output console.
Notes:
You should create a new Java project for each of your Java application.
Nonetheless, NetBeans allows you to keep more than one programs in a project, which is handy
for writing toy programs (such as your tutorial exercises). If you have more than one files with
main() method in one project, you need to right-click the source and choose "Run File".
Step 4: Read the NetBeans Documentation
At a minimum, you SHOULD READ the "IDE Basics, Getting Started, Java Application", which is
accessible via NetBeans's "HELP" menu "Help Contents".
The "Help" "Online Doc and Support" (@ http://netbeans.org/kb/index.html) contains many
articles and tutorial on using NetBeans.
The NetBeans "Start Page" also provides many useful links to get you started.

3. Debugging Program in NetBeans

Step 0: Write a Java Program

The following program computes and prints the factorial of n (=1*2*3*...*n). The program,
however, has a logical error and produce a wrong answer for n=20 ("The Factorial of 20 is 2102132736" - a negative number?!).
1 /** Compute the factorial of n */
2 public class Factorial {
3
// Print factorial of n
4
public static void main(String[] args) {
5
int n = 20;
6
int factorial = 1;
7
8
// n! = 1*2*3...*n
9
for (int i = 1; i <= n; i++) {
10
factorial *= i;
11
}
12
System.out.println("The Factorial of " + n + " is " + factorial);
13 }
14 }

Let us use the graphic debugger to debug the program.

6

Step 1: Set an initial Breakpoint

A breakpoint suspends program execution for you to examine the internal states of the program.
Before starting the debugger, you need to set at least one breakpoint to suspend the execution
inside the program. Set a breakpoint at main() method by clicking on the left-margin of the line
containing main(). A red circle or an inverted Triangle appears in the left-margin indicating a
breakpoint is set at that line.

Step 2: Start Debugging

Right click anywhere on the source code "Debug File". The program begins execution but
suspends its operation at the breakpoint, i.e., the main() method.
As illustrated in the following diagram, the highlighted line (also pointed to by a green arrow)
indicates the statement to be executed in the next step.

Step 3: Step-Over and Watch the Variables and Outputs

Click the "Step Over" button (or select "Step Over" in "Debug" menu) to single-step thru your
program. At each of the step, examine the value of the variables (in the "Variable" panel) and the
outputs produced by your program (in the "Output" Panel), if any. You can also place your
cursor at any variable to inspect the content of the variable.

Single-stepping thru the program and watching the values of internal variables and the outputs
produced is the ultimate mean in debugging programs - because it is exactly how the computer
runs your program!
Step 4: Breakpoint, Run-To-Cursor, Continue and Finish

As mentioned, a breakpoint suspends program execution and let you examine the internal states
of the program. To set a breakpoint on a particular statement, click on the left-margin of that
line (or select "Toggle Breakpoint" from "Run" menu).
"Continue" resumes the program execution, up to the next breakpoint, or till the end of the
program.
"Single-step" thru a loop with a large count is time-consuming. You could set a breakpoint at the
statement immediately outside the loop (e.g., Line 11 of the above program), and issue
"Continue" to complete the loop.
Alternatively, you can place the cursor on a particular statement, and issue "Run-To-Cursor" to
resume execution up to the line.
"Finish" ends the debugging session. Always terminate your current debugging session using
"Finish" or "Continue" till the end of the program.
3.1 Other Debugger's Features:
Modify the Value of a Variable

You can modify the value of a variable by entering a new value in the "Variable" panel. This is
handy for temporarily modifying the behaviour of a program, without changing the source
code.

Step-Into and Step-Out

To debug a method, you need to use "Step-Into" to step into the first statement of the method.
You could use "Step-Out" to return back to the caller, anywhere within the method.
Alternatively, you could set a breakpoint inside a method.

4. NetBeans - Tips & Tricks

4.1 General Usage

These are the features that I find to be most useful in NetBeans:

1. Maximizing Window (double-click): You can double-click on the "header" of any panel to
maximize that particular panel, and double-click again to restore it back. This is particularly useful
for editing source code in full panel.
2. Code Auto-Complete (or Intelli-Sense) (ctrl-space): Enter a partial statement (e.g., Sys) and press
control-space to activate the auto-complete, which displays all the available choices.
3. Javadoc (ctrl-space, alt-F1): Place the cursor on a method or class, and press ctrl-space to view the
javadoc; or right-click Show Javadoc (alt-F1) to open it on a browser.
4. Code Shorthand (tab): For example, you can enter "sout" and press TAB for "System.out.println";
"psvm" for "public static void main(String[] args) { }" or "fori" + tab for a for-loop. To view and
configure code template, choose "Tools" menu "Options" "Editor" "Code Templates".
5. Formatting Source Code (alt-shift-f): Right-click on the source (or from the "Source" menu)
Choose "Format". NetBeans will layout your source codes with the proper indents and format. To
configure the formatting, choose "Tools" menu "Options" "Editor" "Formatting".
You can also select the section of codes to be formatted, instead of the entire file.
6. Hints for Correcting Syntax Error: If there is a syntax error on a statement, a red mark will show
up on the left-margin on that statement. You could click on the "light bulb" to display the error
message, and also select from the available hints for correcting that syntax error.
7. Rename (Refactor) (ctrl-r): To rename a variable, place the cursor on that variable, right-click
"Refactor" "Rename" Enter the new name. All the appearances of that variables in the project
will be renamed.
8. Small Programs: You can keep many small toy programs (with main()) in one Java project instead
of create a new project for each small program. To run the desired program, on the "editor" panel
right-click "Run File".
9. Source Toggle Comment: To temporarily comment-off a block of codes, choose "Source"
"Toggle Comment".
10. Error Message Hyperlink: Click on an error message will hyperlink to the corresponding source
statement.
11. Command-Line Arguments: To provide command-line arguments to your Java program in
NetBeans, right-click on the "project" "Set as Main Project" "Set Configurations"
"Customize..." "Run" select the "Main" class type your command-line arguments inside
the "Arguments" field choose "Run" menu "Run Main Project".
12. Line Numbers: To show the line numbers, right-click on the left-margin "Show Line Numbers".
13. Changing Font Face and Size: Tools Options Fonts & Colors In "Category", select
"Default" In "Font", choose the font face and size.
14. Resetting Window View: If you mess up the window view (e.g., you accidentally close a window
and cannot find it anymore), you can reset the view via "Window" menu "Reset Windows".
15. Code Templates: For example, when you create a new Java class, NetBeans retrieves the initial
contents from the "Java Class" code template. To configure code templates, select "Tools" menu
"Templates" Choose the desired template "Open in Editor". To set a value of a variable used
in the all the code templates (e.g., $User), select "Tools" menu "Templates" "Settings".
9

16. Displaying Chinese Character: Need to choose a font that support chinese character display, such
as "Monospace", in Tools Options Fonts & Colors Syntax default.
17. Changing the JDK Location: The Netbeans configuration file is located at "etc\netbeans.conf". Edit
the directive "netbeans_jdkhome".
18. Let me know if you have more tips to be included here.
4.2 Java Application Development
1. Choosing the JDK version for your program: Right-click on your project "Properties"
"Source" node You can select the JDK level of your project in pull-donw menu "Source/Binary
Format".
2. Enabling JDK 7 support: If JDK 7 is already installed in your system, right-click on your Project
"Properties" "Source" node "Source/Binary Format" Select "JDK 7". Also check "Libraries"
Java Platform JDK 7.
If JDK 7 is not installed/configured, install JDK 7. Add JDK 7 support to NetBeans via "Tool"
menu "Java Platforms" "Add Platform...".
3. Choosing Default Charset: Right-click on your project "Properties" "Source" node
"Encoding" choose your desired charset for the text-file I/O from the pull-down menu.
4. Enabling Unicode Support for File Encoding: Right-click on your project "Properties"
"Source" node "Encoding" choose your Unicode encoding (e.g., UTF-8, UTF-16, UTF-16LE,
UTF-16GE) for the text-file I/O.
5. To include Javadoc/Source: Use "Library Manager" (select the "Tools" menu "Libraries"); or
"Java Platform Manager" (select "Tools" menu "Java Platforms")
6. Adding External JAR files & Native Libraries (".dll", ".lib", ".a", ".so"): Many external Java
packages (such as JOGL, Java3D, JAMA, etc) are available to extend the functions of JDK. These
packages typically provide a "lib" directory containing JAR files (".jar") (Java Archive - a single-file
package of Java classes) and native libraries (".dll", ".lib" for windows, ".a", ".so" for Linux and
Mac).
To include an external JAR file (".jar") into a project: Expand the project node Right-click on
"Libraries" "Add JAR/Folder..." Select the desired JAR file or the folder containing the
classes.
If the external package contains many JAR files, you could create a user library to contain all the
JAR files, and add the library to all the projects that required these JAR files. From "Tools" menu
"Libraries" "New Library..." Enter a library name Use "Add JAR/Folder..." to add JAR
files into this library.
Many JAR files come with native libraries in the form of ".dll", ".lib" (for Windows) and ".a", ".so"
for Linux/Mac. The directory path of these libraries must be included in JRE's property
"java.library.path". This can be done via right-click the project Set Configuration Customize...
Run In "VM options", enter "-Djava.library.path=xxx", where xxx is path of the native libraries.
Notes: The JAR files must be included in the CLASSPATH. The native library directories must be
included in JRE's property "java.library.path", which normally but not necessarily includes all the
paths from the PATH environment variable. Read "External JAR files and Native Libraries".

5. Writing Java GUI (AWT/Swing) Application in NetBeans

Step 0: Read
1. Java GUI Application Learning Trail @ http://www.netbeans.org/kb/trails/matisse.html.
2. Swing Tutorial's "Learning Swing with the NetBeans IDE" @
http://docs.oracle.com/javase/tutorial/uiswing/learn/index.html.
Step 1: Create a New "Java Application" Project
1. Launch NetBeans File New Project...
2. Under "Categories", choose "Java" Under "Projects", choose "Java Application" Next.
10

3. In "Project Name", enter "FirstNetBeansGUI" Choose a suitable directory for your "Project
Location" Uncheck the "Create Main class" box Finish.
Step 2: Write a Java File "JFrame Form"
1. Right-click on the project "FirstNetBeansGUI" "New" "JFrame Form..." (or "Others" "Swing
GUI Forms" "JFrame Form").
2. In "Class Name", enter "NetBeansSwingCounter" Finish.
3. Create the GUI Components visually:
1. From the "Platte" panel "Swing Controls" Drag and drop a "Label", "TextField", and
"Button" into the design panel.
2. Click on the "jLabel1" In the "Properties" panel, enter "Count" in "text" (You can also
single-click on the jLabel1 to change the text). Right-click on the jLable1 Change Variable
Name In "New Name", enter "lblCount".
3. Similarly, for "jTextField1" Change the "text" to 0, and change the "Variable Name" to
"tfCount" Resize the text field if necessary.
4. For "jButton1" Change the "text" to "Count", and change the "Variable Name" to
"btnCount".
4. Write the event handler for the button by double-clicking the button and enter the following
codes:
5.
6.
7.

private void btnCountActionPerformed(java.awt.event.ActionEvent evt) {

count++;
tfCount.setText(count + "");
}
8. Create an instance variable count (just below the class declaration) as follows:
9. public class Counter extends javax.swing.JFrame {
int count = 0;

Step 3: Compile & Execute

Right-click the source and select "Run File".

Step 4: Study the Generated Source Code

Expand the "Generated Code" and study how the GUI builder declare, allocate and initialize the
GUI Components in the initComponents(). Note how the JButton registers an ActionEvent listener and
how an inner class is used as the listener and provide the event handler actionPerformed(). Also
notice that the main() method uses a Swing's worker to run the GUI on the Event-Dispatcher
thread, instead of the main thread, for thread-safe operations.
public class NetBeansSwingCounter extends javax.swing.JFrame {
int count = 0;
// Constructor to setup the UI via initComponents()
public NetBeansSwingCounter() {
initComponents();
}
private void initComponents() {
lblCount = new javax.swing.JLabel();
tfCount = new javax.swing.JTextField();
btnCount = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
lblCount.setText("Counter");
tfCount.setText("0");

11

btnCount.setText("Count");
// Create an anonymous inner as the listener for the ActionEvent fired by btnCount
btnCount.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
btnCountActionPerformed(evt);
}
});
// Laying out the components
// ......
pack();
}
// ActionEvent handler for btnCount
private void btnCountActionPerformed(java.awt.event.ActionEvent evt) {
count++;
tfCount.setText(count + "");
}
public static void main(String args[]) {
// Setup the Look and Feel
// .....
// Run the constructor on the Event-Dispatcher Thread for thread-safe
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new NetBeansSwingCounter().setVisible(true);
}
});
}
// private variables
private javax.swing.JButton btnCount;
private javax.swing.JLabel lblCount;
private javax.swing.JTextField tfCount;
}

6. NetBeans and MySQL

Reference: "Connecting to a MySQL Database" @
http://netbeans.org/kb/docs/ide/mysql.html.
NetBeans (JavaEE) provides direct support to MySQL server. You can use NetBeans as a GUI
client to access a MySQL server, as well as an administrative tool (e.g., starting and stopping the
server).
Configuring NetBeans to Support MySQL

From NetBeans "Window" menu Select "Services". The "Services" tab shall appear on the left
pane
1. Right-click on the "Databases" node "Register MySQL Server". (If you have already registered a
MySQL server, you can right-click on Server node "MySQL Server at hostname:port" Properties, to
modify its properties.)
2. Select the "Basic Properties" tab, enter the hostname, port number, root user and password.
12

3. Select the "Admin Properties" tab:

1. Leave the "Path/URL to admin tool" empty.
2. In "Path to start command", enter "<MYSQL_HOME>\bin\mysqld.exe"; in the "Arguments",
enter "--console"
3. In "Path to stop command", enter "<MYSQL_HOME>\bin\mysqladmin.exe", in the
"Arguments", enter "-u root -ppassword shutdown".
4. A server node "MySQL Server at hostname:port" appears.
Database Administration - Start/Stop the Server and Create Databases
1. You can start the MySQL server by right-clicking on the server node select "start". [There
seems to be a problem here. If a "connection refused: connect" error occurs, enter the password
again.]
2. Once the MySQL server is started and connected, you can see the list of databases by expanding
the MySQL server node. You can create a new database by right-clicking on it and choose "Create
Database...".
Create a new Connection

You need a connection to manipulate data. You can create multiple connections with different
users and default databases.

1. Right-click on the "Databases" "New Connection..." Select the driver "MySQL Connector/J"
Next Enter hostname, port number, default database, a general username and password
"Test Connection" (make sure that MySQL is started) Finish.
2. A connection node "jdbc:mysql://hostname:port/defaultDatabase" appears.
Manipulating Data via a Connection
1. Right-click on a connection node (e.g., "jdbc:mysql://hostname:port/defaultDatabase") Choose
"Connect" (if not connected, provided that the MySQL server has been started).
2. You can expand the connection node to view all the databases.
3. Expand an existing database. There are three sub-nodes "Tables", "View" and "Procedures". Rightclick on the "Tables" to create table or execute command. Similarly, right-click on the "View" and
"Procedures".
4. To view/manipulate the records in a table, right-click on the selected table You can choose to
"View Data...", "Execute Command...", etc.
5. You can right-click on the connection to "connect" or "disconnect" from the server.
Create a SQL Script and Run the Script

You can create a SQL script by right-clicking on a project New "SQL File". You can run the
script by right-clicking on the SQL script "Run File" Select an existing connection (or create
a new connection) to run the script. You could also run a single statement (right-click on the
statement Run Statement) or a selected group of statements (highlight the statements
Right-click Run Selection).

7. Developing and Deploying Web Application in NetBeans

Read:
"Introduction to Developing Web Applications" @
http://netbeans.org/kb/docs/web/quickstart-webapps.html.
More articles in "Java EE & Java Web Learning Trail" @ http://netbeans.org/kb/trails/javaee.html.
7.1 Web (HTTP) Servers
Configuring Web Server

You could configure the web server via "Tools" menu "Servers".
13

Tomcat Server

To configure Tomcat Server, select "Tools" menu "Servers" click "Add Servers":

1. Choose Server: Select the desired Tomcat version Next.

2. Installation and Login Details: In "Server Location", fill in the Tomcat installation directory
($CATALINA_HOME) Enter the username/password of a tomcat user with "manager" role.
You could either check the "create user if it does not exist" or define the tomcat user in
"$CATALINA_HOME\conf\tomcat-users.xml" as follows:
3.
4.
5.

<tomcat-users>
<role rolename="manager"/>
<user username="tomcatmanager" password="xxxx" roles="manager,manager-script,admin" />
</tomcat-users>

Running the Web Server

Choose "Services" Expand "Servers" node Right-click on the desired server

Start/Stop/Restart.
7.2 MySQL Database Server

You can also manage the MySQL database server directly from Tomcat. Read "NetBeans and
MySQL" Section.

7.3 Writing a Hello-World Servlet/JSP Web Application

Create a New Servlet/JSP Project
1. From "File" menu choose "New Project...".
2. "Choose Project" Under "Categories", choose "Java Web" Under "Projects", choose "Web
Application" "Next".
3. "Name and Location" In "Project Name", enter "HelloServletJSP" In "Project Location", select a
suitable directory to save your works Check "Set as Main Project" Next.
4. "Server and settings" Choose your server, or "add" a new server Next.
5. "Frameworks" Select none for pure servlet/JSP application Finish.
Writing a Hello-World JSP

A JSP page called "index.jsp" is automatically created, which says "Hello world!". To execute this
JSP, right-click on the project "Run". The URL is http://localhost:8080/HelloServletJSP/index.jsp.
Writing a Hello-World Servlet
1. Right-click on the project "HelloServletJSP" New Servlet.
2. "Name and Location" In "Class Name", enter "HelloServlet" In "Package", enter "hello"
Next.
3. "Configure Servlet Deployment" In "Servlet Name", enter "HelloServletExample" In "URL
Pattern", enter "sayhello" Finish.
4. Enter the following codes for "HelloServlet.java":
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

package hello;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class HelloServlet extends HttpServlet {
@Override
public void doGet(HttpServletRequest request, HttpServletResponse response)

14

18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

throws IOException, ServletException {

// Set the response message's MIME type (in Content-Type response header)
response.setContentType("text/html;charset=UTF-8");
// Get an output Writer to write the response message over the network
PrintWriter out = response.getWriter();
// Write the response message (in an HTML page) to display "Hello, world!"
try {
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println("<head><title>Hello Servlet</title></head>");
out.println("<body><h1>Hello, World (from Java Servlet)!</h1></body>");
out.println("</html>");
} finally {
out.close(); // Always close the output writer
}
}
}

34. To execute the servlet: Right-click on the project run Change the URL to
http://localhost:8080/HelloServletJSP/sayhello.
Generating a WAR-file for a Web Application

A WAR (Web Archive) file is basically a zip file for distributing web application in single file.
You can use WinZip or WinRAR to inspect or unzip the war file.
To distribute the project as a war-file, right-click project "Clean and Build". The war file is
created in the "dist" directory. You can deploy the web application by dropping the war-file into
Tomcat's "webapps" directory. Tomcat will automatically unzip the war-file and deploy the
application upon startup.
Debugging Web Application

The most important reason for using IDE is to use the graphic debugger for debugging the
program. You can set a breakpoint in your server-side Java codes, and "Debug" a web
application, similar to a standalone application.
7.4 Writing a Hello-world JSF 2.0 Web Application
Create a New JSF 2.0 Project
1. From "File" menu choose "New Project...".
2. "Choose Project" Under "Categories", choose "Java Web" Under "Projects", choose "Web
Application" "Next".
3. "Name and Location" In "Project Name", enter "HelloJSF20" In "Project Location", select a
suitable directory to save your works Check "Set as Main Project" Next.
4. "Server and settings" Choose your server, or "add" a new server Next.
5. "Frameworks" Check "JavaServer Faces" In "Libraries", "Registered Libraries", select "JSF 2.0"
Finish.
6. An "index.xhtml" JSF page is generated, as follows:
7. <?xml version='1.0' encoding='UTF-8' ?>
8. <!DOCTYPE html>
9. <html xmlns="http://www.w3.org/1999/xhtml"
10.
xmlns:h="http://java.sun.com/jsf/html">
11.
<h:head>
12.
<title>Facelet Title</title>
13.
</h:head>
14.
<h:body>
15.
Hello from Facelets

15

16.

</h:body>
</html>

To run this facelet, right-click on the project Run.

Create a new JSF 2.0 Facelet
1. Right-click on the project New "Other..."
2. "Choose File Type" Under "Category", select "JavaServer Faces" Under "File Type", select
"JSF Page" Next.
3. "Name and Location" In "File Name", enter "HelloJSF20" In "Options", check "Facelets"
Finish.
4. In "HelloJSF20.xhtml", enter the following codes:
5. <?xml version='1.0' encoding='UTF-8' ?>
6. <!DOCTYPE html>
7. <html xmlns="http://www.w3.org/1999/xhtml"
8.
xmlns:h="http://java.sun.com/jsf/html">
9.
<h:head>
10.
<title>Hello JSF 2.0</title>
11.
</h:head>
12.
<h:body>
13.
<h1>Hello from Facelets</h1>
14.
</h:body>
</html>

15. To execute the JSF page, right-click on the project Run Change the URL to
http://localhost:8080/HelloJSF20/HelloJSF20.xhtml.
7.5 Writing a Hello-world JSF 1.2 Web Application
Create a New JSF 1.2 Project
1. From "File" menu choose "New Project...".
2. "Choose Project" In "Categories", choose "Java Web" In "Projects", choose "Web Application"
"Next".
3. "Name and Location" In "Project Name", enter "HelloJSF12" In "Project Location", select a
suitable directory to save your works Check "Set as Main Project" Next.
4. "Server and settings" choose your server, or "add" a new server Next.
5. "Frameworks" Check "JavaServer Faces" In "Libraries", "Registered Libraries", select "JSF 1.2"
Finish.
6. A "WelcomeJSF.jsp" page is generated, as follows:
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<!DOCTYPE html>
<%-This file is an entry point for JavaServer Faces application.
--%>
<f:view>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>JSP Page</title>
</head>
<body>
<h1><h:outputText value="JavaServer Faces"/></h1>
</body>
</html>

16

</f:view>

To run this page, right-click on the project Run.

Create a new JSF 1.2 Page
1. Right-click on the project New "Other..."
2. "Choose File Type" In "Category", select "JavaServer Faces" In "File Type", select "JSF Page"
Next.
3. "Name and Location" In "File Name", enter "HelloJSF12" In "Options", check "JSP File
(Standard Syntax)" Finish.
4. In "HelloJSF12.jsp", enter the following codes:
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<!DOCTYPE html>
<f:view>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>Hello JSF 1.2</title>
</head>
<body>
<h1><h:outputText value="Hello World!"/></h1>
</body>
</html>
</f:view>

20. To execute the JSF page, right-click on the project Run Change the URL to
http://localhost:8080/HelloJSF12/faces/HelloJSF12.jsp .
7.6 Debugging Web Applications in NetBeans

You can debug a webapp just like standalone application. For example, you can set breakpoints,
single-step through the programs, etc.
REFERENCES & RESOURCES

NetBeans mother site @ http://netbeans.org.

Eclipse 4.4 (Luna) for Java

How To Install Eclipse and Get Started with Java Programming
(on Windows, Mac and Linux)
Eclipse (@ www.eclipse.org) is an open-source Integrated Development Environment (IDE) supported by
IBM. Eclipse is popular for Java application development (Java SE and Java EE) and Android apps. It
also supports C/C++, PHP, Python, Perl, and other web project developments via extensible plug-ins.
Eclipse is cross-platform and runs under Windows, Linux and Mac OS.

17

Eclipse Versions

The various versions are:

Eclipse 1.0 (November 7, 2001): based on an earlier Java IDE called VisualAge from IBM.
Eclipse 2.0 (June 28, 2002)
Eclipse 2.1 (March 28, 2003)
Eclipse 3.0 (June 25, 2004)
Eclipse 3.1 (June 28, 2005)
Eclipse 3.2 (June 30, 2006) (Callisto - named after one of the Jupiter's Galilean moons): started annual
simultaneous release of all the related Eclipse projects.
Eclipse 3.3 (June 25, 2007) (Europa - named after another Jupiter's Galilean moons)
Eclipse 3.4 (June 19, 2008) (Ganymede - named after yet another Jupiter's Galilean moons)
Eclipse 3.5 (June 12, 2009) (Galileo - named after the great 17th century scientist and astronomer Galileo
Galilei)
Eclipse 3.6 (June 23, 2010) (Helios - named after god of the sun in Greek Mythology)
Eclipse 3.7 (June 23, 2011) (Indigo)
Eclipse 4.2 (June 27, 2012) (Juno)
Eclipse 4.3 (June, 2013) (Kepler)
Eclipse 4.4 (June, 2014) (Luna)

1. How to Install Eclipse for Java

1.1 For Windows
Step 0: Install JDK

To use Eclipse for Java programming, you need to first install Java Development Kit (JDK).
Read "How to Install JDK (on Windows)".
Step 1: Download

Download Eclipse from http://www.eclipse.org/downloads. For beginners, choose "Eclipse

IDE for Java Developers" (32-bit or 64-bit) (e.g., "eclipse-java-luna-SR1a-win32-x86_64.zip").
Step 2: Unzip

To install Eclipse, simply unzip the downloaded file into a directory of your choice (e.g.,
"d:\myproject").
There is no need to run any installer. Moreover, you can simply delete the entire Eclipse
directory when it is no longer needed (without running any un-installer). You are free to move
or rename the directory. You can install (unzip) multiple copies of Eclipse in the same machine.
1.2 For Macs

Read "How to Install Eclipse on Mac".

1.3 For Ubuntu Linux

Read "How to Install Eclipse on Ubuntu".

2. Writing your First Java Program in Eclipse

Step 0: Launch Eclipse
1. Start Eclipse by running "eclipse.exe" in the Eclipse installed directory.
2. Choose an appropriate directory for your workspace (i.e., where you would like to save your files).
3. If the "Welcome" screen shows up, close it by clicking the "close" button.
18

Step 1: Create a new Java Project

For each Java application, you need to create a project to keep all the source files, classes and
relevant resources.
To create a new Java project:

1. Choose "File" menu "New" "Java project".

2. The "New Java Project" dialog pops up.
1. In the "Project name" field, enter "FirstProject".
2. Check "Use default location".
3. In the "JRE" box, select "Use default JRE (currently 'JDK1.x')". But check the JDK version,
you should be using JDK 1.5 and above.
4. Click "Finish".
Step 2: Write a Hello-world Java Program
1. In the "Package Explorer" (left panel) Right-click on "FirstProject" (or use the "File" menu)
New Class.
2. The "New Java Class" dialog pops up.
1. In "Name" field, enter "Hello".
2. In "package" field, delete the content if it is not empty.
3. Check "public static void main(String[] args)" box.
4. Click "Finish".
3. The source file "Hello.java" opens on the editor panel. Enter the following codes:
4.
5.
6.
7.

public class Hello { // "Hello.java"

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

Step 3: Compile & Execute the Java Program

1. There is no need to compile the Java source file explicitly. It is because Eclipse performs the socalled incremental compilation, i.e., the Java statement is compiled as and when it is entered.
2. To run the program, right-click anywhere on the source file "Hello.java" (or from the "Run" menu)
Choose "Run As" "Java Application".
3. The output "Hello, world!" appears on the "Console" panel.

NOTES:

You should create a new Java project for each of your Java application.
Nonetheless, Eclipse allows you to keep more than one programs in a project, which is handy for
writing toy programs (such as your tutorial exercises). If you have more than one files with main()
method in one project, you need to right-click the source and choose "Run As" "Java
Application" to run that particular source. Clicking the "Run" button runs the recently-run
program (based on the previous configuration). Try clicking on the "down-arrow" besides the
"Run" button.

3. Read the Documentation

At a minimum, you SHOULD browse through Eclipse's "Workbench User Guide" and "Java
Development User Guide" - accessible via the Eclipse's "Welcome" page or "Help" menu. This
will save you many agonizing hours trying to figure out how to do somethings later.

4. Debugging Programs in Eclipse

Able to use a graphics debugger to debug program is crucial in programming. It could save you
countless hours guessing on what went wrong.
19

Step 0: Write a Java Program

The following program computes and prints the factorial of n (=1*2*3*...*n). The program,
however, has a logical error and produce a wrong answer for n=20 ("The Factorial of 20 is 2102132736" - a negative number?!).
1 /** Compute the Factorial of n, where n=20.
2 * n! = 1*2*3*...*n
3 */
4 public class Factorial {
5
public static void main(String[] args) {
6
int n = 20;
// To compute factorial of n
7
int factorial = 1; // Init the product to 1
8
9
int i = 1;
10
while (i <= n) {
11
factorial = factorial * i;
12
i++;
13
}
14
System.out.println("The Factorial of " + n + " is " + factorial);
15 }
16 }

Let's use the graphic debugger to debug the program.

Step 1: Set an Initial Breakpoint

A breakpoint suspends program execution for you to examine the internal states (e.g., value of
variables) of the program. Before starting the debugger, you need to set at least one breakpoint
to suspend the execution inside the program. Set a breakpoint at main() method by doubleclicking on the left-margin of the line containing main(). A blue circle appears in the left-margin
indicating a breakpoint is set at that line.
Step 2: Start Debugger

Right click anywhere on the source code (or from the "Run" menu) "Debug As" "Java
Application" choose "Yes" to switch into "Debug" perspective (A perspective is a particular
arrangement of panels to suits a certain development task such as editing or debugging). The
program begins execution but suspends its operation at the breakpoint, i.e., the main() method.
20

As illustrated in the following diagram, the highlighted line (also pointed to by a blue arrow)
indicates the statement to be executed in the next step.
Step 3: Step-Over and Watch the Variables and Outputs

Click the "Step Over" button (or select "Step Over" from "Run" menu) to single-step thru your
program. At each of the step, examine the value of the variables (in the "Variable" panel) and the
outputs produced by your program (in the "Console" Panel), if any. You can also place your
cursor at any variable to inspect the content of the variable.
Single-stepping thru the program and watching the values of internal variables and the outputs
produced is the ultimate mean in debugging programs - because it is exactly how the computer
runs your program!
Step 4: Breakpoint, Run-To-Line, Resume and Terminate

As mentioned, a breakpoint suspends program execution and let you examine the internal states
of the program. To set a breakpoint on a particular statement, double-click the left-margin of
that line (or select "Toggle Breakpoint" from "Run" menu).
"Resume" continues the program execution, up to the next breakpoint, or till the end of the
program.
"Single-step" thru a loop with a large count is time-consuming. You could set a breakpoint at the
statement immediately outside the loop (e.g., Line 11 of the above program), and issue
"Resume" to complete the loop.
Alternatively, you can place the cursor on a particular statement, and issue "Run-To-Line" from
the "Run" menu to continue execution up to the line.
"Terminate" ends the debugging session. Always terminate your current debugging session
using "Terminate" or "Resume" till the end of the program.
Step 5: Switching Back to Java perspective

Click the "Java" perspective icon on the upper-right corner to switch back to the "Java"
perspective for further programming (or "Window" menu Open Perspective Java).
21

Important: I can's stress more that mastering the use of debugger is crucial in programming.
Explore the features provided by the debuggers.
Other Debugger's Features

Modify the Value of a Variable: You can modify the value of a variable by entering a new
value in the "Variable" panel. This is handy for temporarily modifying the behavior of a
program, without changing the source code.
Step-Into and Step-Return: To debug a method, you need to use "Step-Into" to step into the first
statement of the method. ("Step-Over" runs the function in a single step without stepping
through the statements within the function.) You could use "Step-Return" to return back to the
caller, anywhere within the method. Alternatively, you could set a breakpoint inside a method.

5. Tips & Tricks

5.1 General Usages (for all Programming Tasks)

These are the features that I find to be most useful in Eclipse:

1. Maximizing Window (Double-Clicking): You can double-click on the "header" of any panel to
maximize that particular panel, and double-click again to restore it back. This feature is particularly
useful for writing source code in full panel.
2. Shorthand Templates (sysout, for,...): You can type "sysout" followed by a ctrl+space (or alt-/) as a
shorthand for typing "System.out.println()".
The default shortcut key (ctrl-space or alt-/) depends on the system. Check your system's
shortcut key setting in "Edit" "Content Assist" "Default". Take note that many of you use
ctrl+space to switch between input languages. You need to reconfigure either your language
switching hot-key or Eclipse.
Similarly, you can type "for" followed by ctrl-space (or alt-/) to get a for-loop.
You can create your own shorthand in "Window" menu "Preferences" "Java" "Editor"
"Templates". (Alternatively, in "Window" "Preferences" type "template" as filter text and
choose "Java" "Editor" "Templates".)
You can change your key settings in "Window" menu "Preferences" "General" "Key"
choose "Command", "Content Assist". (Alternatively, in "Window" "Preferences" type "key"
as filter text and choose "General" "Key".)
3. Intelli-Sense (ctrl-space): You can use ctrl-space to activate the "intelli-sense" (or content assist).
That is, Eclipse will offer you the choices, while you are typing.
4. Source Formatting (ctrl-shift-f): Right-click on the source. Choose "Source" "Format" to let
Eclipse to layout your source codes with the proper indentation.
5. Source Toggle Comment (ctrl-/): To comment/uncomment a block of codes, choose "Source"
"Toggle Comment".
6. Hints for Correcting Syntax Error: If there is a syntax error on a statement, a red mark will show
up on the left-margin on that statement. You could click on the "light bulb" to display the error
message, and also select from the available hints for correcting that syntax error.
7. Refactor (or Rename) (alt-shift-r): You can rename a variable, method, class, package or even the
project easily in Eclipse. Select and right-click on the entity to be renamed "Refactor"
"Rename". Eclipse can rename all the occurrences of the entity.
8. Line Numbers: To show the line numbers, choose "Window" menu "Preferences" "General"
"Editors" "Text Editors" Check the "Show Line Numbers" Box. You can also configure
many editor options, such as the number of spaces for tab. Alternatively, you can right-click on
the left-margin, and check "Show Line Numbers".
9. Error Message Hyperlink: Click on an error message will hyperlink to the corresponding source
statement.
22

10. Changing Font Type and Size: From "Window" menu "Preferences" "General"
"Appearance" "Colors and Fonts" expand "Java" "Java Editor Text Font" "Edit".
(Alternatively, in "Window" "Preferences" type "font" as filter text and choose the
appropriate entry.)
11. Unicode Support: To enable Unicode support, select "Window" menu Preferences General
Workspace Text file encoding UTF-8. This sets the default character set used for file
encoding, similar to VM's command-line option -Dfile.encoding=UTF-8. Commonly used charsets
for Unicode are UTF-8, UTF-16 (with BOM), UTF-16BE, UTF-16LE. Other charsets are US-ASCII,
ISO-8859-1.
12. Mouse Hover-over: In debug mode, you could configure to show the variable's value when the
mouse hovers over the variable. Select "Window" menu "Preferences" "Java" "Editor"
"Hover".
13. Comparing Two Files: In "Package Explorer", select two files (hold the control key) Right-click
Compare with.
14. Useful Eclipse Shortcut Keys:
o F3: Goto the declaration of the highlighted variable/method.
o Ctrl-Shift-G: Search for ALL references of the highlighted variable/method in workspace.
o Ctrl-G: Search for the Declaration of a variable/method in workspace.
Don't use Find (Ctrl-F), but use the above context-sensitive search.
o Ctrl-Shift-F: Format the source code.
o Ctrl-Shift-O: Organize imports.
o Alt-Shift-R: Rename. (Don't use Find/Replace.)
o Ctrl-Space: auto-complete.
15. Package Explorer vs. Navigator: We usually use "Package Explorer" in programming, but it will
not show you all the folders and files under the project. On the other hand, "Navigator" is a file
manager that shows the exact file structure of the project (similar to Windows Explorer). You can
enable the Navigator by "Window" Show view Navigator.
16. Spell Check: To enable spell check, select Window Preferences type "spell" in the filter
General Editors Text Editors Spelling Check "Enable spell checking". Also provide a
"User defined dictionary" (with an initially empty text file).
To correct mis-spell words, right-click and press ctrl-1 (or Edit menu Quick Fix).
17. Eclipse's Log File: Goto Help about Eclipse Installation details Configuration View
Error Log.
18. Viewing two files in split screen: Simply click and hold on the title of one file and drag it to the
lower side of the screen. [To view the same file on split screen, create a new editor window by
selecting Window New Editor; and drag one window to the lower side of the screen.]
19. Block Select: Push Alt-Shift-A to toggle between block-select mode and normal mode.
20. Snippets:
o To view the snippet window: choose "Window" Show View Snippets.
o To create a new snippet category: Right-click Customize New.
o To create a new snippet item: Copy the desired text Select the snippet category paste
as snippet.
o To insert a snippet: place the cursor on the desired location at the editor panel click the
snippet item.
21. Word Wrap (Line Wrap): Word-wrap (or line-wrap) is essential for editing long HTML
documents without the horizontal scroll bar. However, the Eclipse's HTML Editor and Text
Editor do not support word-wrap.
You could install a plug-in called "Word Wrap" from http://ahtik.com/eclipse-update/.
Choose "Help" Install New Software in "Work with" Enter "http://ahtik.com/eclipse23

update/".
To activate word wrap, right-click on the editor panel select "Word Wrap".
22. Creating "link folder" in project: You do not have to place all the folders under the project base
directory, instead, you can use so-called "link folders" to link to folder outside the project base
directory.
To create a link folder in a project, right-click on the project File New Folder Advanced
Check Link to alternate Location (Linked Folder).
23. Running Eclipse in "clean" mode: You can run eclipse in so-called "clean" mode, which wipes all
the cached data and re-initialize the cache, by running eclipse from command-line with "-clean"
argument (i.e., "eclipse -clean"). It is useful if something is not working proper, especially if you
install a new copy of Eclipse.
24. Show the Right Margin: Window Preferences General Editors Text Editors Show
Print Margin and set the column number.
25. Let me know if you have more tips to be included here.
5.2 Update Eclipse and Install new Software
1. Install New Software: Select "Help" menu Install New Software In "Work With", pull down
the select menu and choose a software site.
2. Update: Select "Help" menu Check for Updates .
5.3 For Java Application Development Only
1. Eclipse 3.7 does not support JDK 7. Eclipse 4.2 does.
2. Small Toy Java Programs: You can keep many small programs (with main()) in one Java project
instead of create a new project for each toy program. To run the desired program, right-click on
the source file "Run as" "Java Application".
3. Scanner/printf() and JDK 1.5: If you encounter syntax error in using printf() or Scanner (which are
available from JDK 1.5), you need to check your compiler settings. Select "Window" menu
Preferences open the "Java" node select "Compiler" in "Compiler compliance level"
select the latest release, which should be "1.5" or above.
4. Command-Line Arguments: To provide command-line arguments to your Java program in
Eclipse, right-click on the source file "Run Configurations" Under the "Main" panel, check
that "Project" name and "Main Class" are appropriate Select the "Argument" tab type your
command-line arguments inside the "Program Arguments" box "Run".
5. Resolving Import (Ctrl-Shift-o): To ask Eclipse to insert the import statements for classes. Useful
when you copy a large chunk of codes without the corresponding import statements.
6. Including Another Project: To include another project in the same work space, right-click on the
project Build Path Configure Build Path... Select "Projects" tab "Add..." to select project
in the existing work space OK.
7. Exporting a Project to a JAR file: Right-click on the project Export... Java, JAR File Next
Select the files to be exported Next Next In "JAR Manifest Specification" dialog, enter the
main class (if you wish to run the JAR file directly) Finish.
8. Unit Testing: If you keep your test in another project, you need to include the project under test
in your Build Path (see above).
To create a test case: Right-click on the project New JUnit Test Case the "New JUnit Test
Case" dialog appears. Select "New JUnit 4 Test". In "Name", enter your class name. In "Class
under test", browse and select the class to be tested.
To run the test: Right-click "Run As" "JUnit Test". The results are displayed in a special
"JUnit console".
9. Adding External JAR files & Native Libraries (".dll", ".lib", ".a", ".so"): Many external Java
packages (such as JOGL, Java3D, JAMA, etc) are available to extend the functions of JDK. These
24

packages typically provide a "lib" directory containing JAR files (".jar") (Java Archive - a single-file
package of Java classes) and native libraries (".dll", ".lib" for windows, ".a", ".so" for Linux and
Mac).
To include these external packages into an Eclipse's project, right-click on the project Build
Path Add External Archives Navigate to select the JAR files (".jar") to be included.
In "Package Explorer", right-click on the JAR file added Properties:
o To include native libraries (".dll", ".lib", ".a", ".so"), select "Native Library" "Location
Path" "External Folder".
o To include the javadoc, select "JavaDoc Location" "JavaDoc URL" You can specify a
local file or a remote link.
o To include source file (for debugging), select "Java Source Attachment".
All the above options are also accessible via project's property "Build Path".
Notes: The JAR files must be included in the CLASSPATH. The native library directories must be
included in JRE's property "java.library.path", which normally but not necessarily includes all the
paths from the PATH environment variable. Read "External JAR files and Native Libraries".
10. Creating a User Library: You can also create a Eclipse's user library to include a set of JAR files
and native libraries, that can then be added into subsequent Eclipse projects.
For example, I created a user library for "JOGL" as follows:
1. From "Window" menu Preferences Java Build Path User Libraries New In
"User library name", enter "jogl". The "User Library" dialog appears.
2. In "User Library" dialog Select "jogl" Add JAR... Navigate to <JOGL_HOME>/lib,
and select "gluegen-rt.jar" and "jogl.jar".
3. Expand the "jogl.jar" node Select "Native library location: (none)" Edit... External
Folder... select <JOGL_HOME>/lib.
4. Expand the "jogl.jar" node Select "Javadoc location: (none)" Edit... Javadoc in
archive In "Archive Path", "Browse" and select the downloaded JOGL API
documentation zip-file In "Path within archive", "Browse" and expand the zip-file to
select the top-level path (if any) Validate. Alternatively, you can provide the path to the
un-zipped javadocs. This is needed for Eclipse to display javadoc information about
classes, fields, and methods.
5. You may provide the source files by editing "Source attachment: (none)". Source is needed
only if you are interested to debug into the JOGL source codes.
For EACH subsequent Java project created that uses JOGL, right-click on the project Build Path
Add Libraries Select "User Library" Check "jogl".
11. Running an External Program: Suppose that you want to run a Perl script on the selected file, you
can configure an external tool as follows:
0. From "Run" menu External Tools External Tools Configuration... The "External
Tools Configuration" dialog appears.
1. In "Name", enter your tool name.
2. Choose the "Main" tab In "Location", "Browse File System..." to choose the perl
interpreter "perl" In "Arguments", enter "path/scriptname.pl ${resource_loc}", where
${resource_loc} is an Eclipse variable that denotes the currently selected resource with
absolute path.
3. Choose the "Common" tab In "Standard Input and Output", uncheck "Allocate
Console", check "File" and provide an output file (e.g., d:\temp\${resource_name}.txt).
4. (If you use the CYGWIN perl interpreter, need to set environment variable
CYGWIN=nodosfilewarning to disable warning message.)
To run the configured external tool, select a file run external tool tool name.
25

12. Viewing Hex Code of Primitive Variables in Debug mode: In debug perspective, "Variable" panel
Select the "menu" (inverted triangle) Java Java Preferences... Primitive Display Options
Check "Display hexadecimal values (byte, short, char, int, long)".
13. Adding a New Version of JDK/JRE: First, you can check the installed JDK/JRE via "Window"
menu "Preferences" Expand "Java" node "Installed JREs". Check the "Location" current
JRE installed to make sure that it is the intended one. You can use the "Add" button to add a new
version of JRE. For program development, I recommend that you add the JDK (instead of JRE).
[The "Location" decides the extension directory used for including additional JAR files, e.g.,
$JAVA_HOME\jre\lib\ext.]
5.4 For Web Developers
1. HTML Editor: Use the "Web Page Editor" (available in Eclipse Java EE), which provides the
design view (WYSISYG).
To use the "Web Page Editor", right-click on the HTML file, open as "Web Page Editor".
To make the "Web Page Editor" as default for HTML file, goto Window Preferenes General
Editor File Associations .htm and .html Select "Web page editor" default.

6. File I/O in Eclipse

Suppose that your want to write a Java program, which inputs from a text file called "xxxx.in"
and outputs to a text file called "xxxx.out". This is a little tricky under Eclipse due to:
1. When you create a text file in Windows' Notepad and saved it as "xxxx.in", Notepad will append
the ".txt" to your file and it becomes "xxxx.in.txt". Worse still, the Windows' Explorer, by default,
will not show the ".txt" extension. (The first thing I always do to an alien computer is to change
this setting. From "Tools" menu Folder Options... View Uncheck "Hide extensions for
known file types".) You need to put a pair of double quotes around xxxx.in to override the default
".txt" extension. This is one good reason not to use Notepad for programming at all. You should
use Eclipse to create the text file instead.
2. Which directory to keep the input file "xxxx.in" in Eclipse?
o If you did not separate the sources and class files into two separate directories, then the
answer is straight forward, because there is only one directory to place your input file.
o If you choose to keep your sources and class files in two separate directories, eclipse will
create two sub-directories "src" and "bin" under the base directory. BUT you need to put
your input file "xxxx.in" in the base directory of your project, instead of the "src" or "bin"..
For writing simple programs:
Put the sources, class files, and the input/output files in the same directory. (When you create a
new project, select "Use project folder as root for sources and class files" in "Project Layout".) (But
put your sources and class files in separate directories for big project.)
You can create you input file from eclipse directly via "File" menu "New" "File".
Remember to add a newline to the end of your input file.
You may need to right-click the project and select "Refresh" to see the output file "xxxx.out"
created in the package explorer.
To open the "xxxx.in" and "xxxx.out": right-click Open With Text Editor.

This is a sample JDK 1.5 program for file input/output:

import java.util.Scanner;
import java.util.Formatter;
import java.io.File;
import java.io.IOException;
public class FileIOTest { // saved as "FileIOTest.java"
public static void main (String [] args) throws IOException {
Scanner in = new Scanner(new File("FileIOTest.in"));
// file input

26

Formatter out = new Formatter(new File("FileIOTest.out")); // file output

int a = in.nextInt();
int b = in.nextInt();
out.format("%d\n",a+b); // format() has the same syntax as printf()
out.close();

// flush the output and close the output file

}
}

Create the input text file called "FileIOTest.in" with the following contents and terminated with a
newline:
55 66

7. Writing Swing Applications using Eclipse GUI Builder

Eclipse provides a visual GUI builder called "WindowBuilder" (@
https://www.eclipse.org/windowbuilder), which supports AWT/Swing, SWT (Eclipse's
Standard Widget Toolkit - an alternative to JDK's AWT/Swing), XWT, GWT, eRCT.
Step 1: Create a New "Java Application" Project
1. Choose "File" menu "New" "Java project".
2. The "New Java Project" dialog pops up.
1. In the "Project name" field, enter "FirstSwingProject".
2. Check "Use default location".
3. In the "JRE" box, select "Use default JRE (currently 'JDK1.x')". But check the JDK version,
you should be using JDK 1.5 and above.
4. Click "Finish".
Step 2: Create a Swing JFrame Subclass
1. Choose "File" menu "New" "Other..." "WindowBuilder" "Swing Designer" "JFrame"
"Next". [If you cannot find "WindowBuilder" option, you need to install the "WindowBuilder"
plug-in for Eclipse. Check https://www.eclipse.org/windowbuilder.]
2. In the "Create JFrame" dialog Enter "SwingMain" in the "Name" field "Finish".
3. Select the "Design" pane.
4. In "Layouts", select "FlowLayout" and click on the "design form".
5. From "Components", select "JLabel" and click on the design form. Change the label text to
"Counter: ". Select a "JTextField" and place it on the design form. Change the text to "0". Select a
"JButton" and place it on the design form. Change the text label to "Count".
6. To attach a event-handler to the button, double-click the JButton to switch into the "Source" pane,
with the event-handler skeleton created. Complete the actionPerformed() as follows:
7.
8.
9.

public void actionPerformed(ActionEvent e) {

count++;
textField.setText(count + "");
}
Add an instance variable called count as follow:
public class SwingMain extends JFrame {
private int count = 0;
......

10. You can now ready run the program. Right-click on the project Run As Java Application.
Eclipse Generated Codes

Study the codes generated by Eclipse GUI Builder, as follows, which is just a typical Swing
application.
1 import java.awt.*;

27

2 import java.awt.event.*;
3 import javax.swing.*;
4 import javax.swing.border.EmptyBorder;
5
6 public class SwingMain extends JFrame { // A JFrame application
7
8
// Define private variables of all the GUI components
9
private JPanel contentPane;
10 private JTextField textField;
11 private int count = 0;
12
13 /**
14 * Launch the application.
15 */
16 public static void main(String[] args) {
17
EventQueue.invokeLater(new Runnable() { // same as SwingUtilities.invokeLater()
18
@Override
19
public void run() {
20
try {
21
SwingMain frame = new SwingMain();
22
frame.setVisible(true);
23
} catch (Exception e) {
24
e.printStackTrace();
25
}
26
}
27
});
28 }
29
30 /**
31 * Create the frame.
32 */
33 public SwingMain() {
34
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
35
setBounds(100, 100, 450, 300);
36
contentPane = new JPanel();
37
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
38
setContentPane(contentPane);
39
contentPane.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5));
40
41
JLabel lblNewLabel = new JLabel("Counter: ");
42
contentPane.add(lblNewLabel);
43
44
textField = new JTextField();
45
textField.setText("0");
46
contentPane.add(textField);
47
textField.setColumns(10);
48
49
JButton btnCount = new JButton("Count");
50
btnCount.addActionListener(new ActionListener() {
51
@Override
52
public void actionPerformed(ActionEvent e) {
53
count++;
54
textField.setText(count + "");

28

55
}
56
});
57
contentPane.add(btnCount);
58 }
59 }

8. Eclipse for C/C++ Programming

Here.

9. Eclipse PDT (PHP Development Tool)

Here.

10. Eclipse and Database Development (MySQL)

Reference: "Data Tools Platform User Documentation" @ Eclipse Welcome page.
You need to install Eclipse for Java EE, MySQL and MySQL Connector/J Driver. Read "How to
install and get started with MySQL".
To use Eclipse for MySQL development:
1. Switch to "Database Development" perspective: From "Window" menu Open Perspective
Other Database Development.
2. Connect to MySQL database server: Start your MySQL database server. Right-click "Database
Connection" New.
1. In "Connection Profile", choose "MySQL" Next.
2. In "Driver", choose "New Driver Definition" Choose the MySQL Connector/J Driver
In JAR List, select the MySQL Connector/J Driver JAR file (that you have installed). In
"Properties", "General", specify URL (take note of the database name), User name and
password Test Connection Finish.
3. In "Datasource Explorer", you can "connect" and "disconnect" the connection.
3. To create a new SQL script, choose File New SQL File You may use an existing project or
create a new project (General - Project or Web - Dynamic Web Project) Enter filename, and set
the connection profile name Finish. Enter a SQL statement (e.g., SELECT * FROM tablename)
Right-click on the text "Execute Current Text" or "Execute All".
4. To use an existing SQL file, drop the file into a project and open the SQL file. In Connection
profile, set the type and connection name. Right-click on a statement "Execute ...".
5. To CURD (create-update-read-delete) tables, in "Datasource Explorer" (of the "Database
Development" perspective), expand "database" to view the tables. Right-right on the table
Datat Edit.

11. Developing and Deploying Web Applications in Eclipse for Java EE

11.1 Setting Up Eclipse for Web Development
1. Install "Eclipse for Java EE (Enterprise Edition)".
2. Install Tomcat (or Glassfish) server.
3. Configuring Web Server: Launch Eclipse Window Preferences Expand the "Server" node
"Runtime Environments" "Add..." Expand "Apache" and select "Apache Tomcat v7.0"
Enter the "Tomcat Installation Directory" "Finish".
11.2 Writing a Hello-world JSP Page
1. Create a new Web Application: File New Dynamic Web Project (under "Web" category) In
"Project Name", enter "HelloJSP" Finish.
2. Create a new JSP File: Right-click on the project "HelloJSP" New JSP File The parent folder
shall be "HelloJSP/WebContent" In "File Name", enter "Hello" "Finsih".
3. Enter the following HTML/JSP codes within the <body>...</body> tags:
4.

<h1>Hello World!</h1>

29

5.
6.
7.
8.

<%
out.println("Your IP address is " + request.getRemoteAddr() + "<br/>");
out.println("Your user agent is " + request.getHeader("user-agent") + "<br/>");
%>
9. To execute the JSP, right-click on "Hello.jsp" Run As Run on Server.

11.3 Writing a Hello-world Servlet

1. Create a new Web Application: File New Dynamic Web Project (under "Web" category) In
"Project Name", enter "HelloServlet" "Finish".
2. Create a new Servlet: Right-click on the project "HelloServlet" New Servlet In "Java
Package", enter "hello"; in "Class Name", enter "HelloServlet" Next In "URL Mappings", select
"\HelloServlet", "Edit" to "\Hello" Next In "Which method stubs would you like to create",
check "Inherited abstract method" and "doGet" Finish.
In "HelloServlet.java", enter the following codes:
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

package hello;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.WebServlet;
@WebServlet("/sayhello") // URL for this Servlet (for Servlet 3.0 with Tomcat 7)
public class HelloServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set the response message MIME type (in Content-Type response header)
response.setContentType("text/html");
// Get an output Writer to write the response message over the network
PrintWriter out = response.getWriter();
// Write the response message (in an HTML page) to display "Hello, world!"
out.println("<!DOCTYPE html>");
out.println("<html><head>");
out.println("<meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>");
out.println("<title>Hello Servlet</title></head>");
out.println("<body><h1>Hello, World!</h1>");
out.println("<p>Your IP address is " + request.getRemoteAddr() + "</p>");
out.println("<p>Your user agent is " + request.getHeader("user-agent") + "</p>");
out.println("</body></html>");
}
}

(For Servlet 2.4/2.5 with Tomcat 6) The annotation @WebServlet is new in Servlet 3.0 and is
not supported in Servlet 2.4/2.5. Hence, you need to manually configure the URL for the
servlet in the Web Application Deployment Descriptor "web.xml" under directory "WEBINF", as follows:
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/webapp_3_0.xsd"
version="3.0" metadata-complete="true">

30

<servlet>
<servlet-name>HelloServletExample</servlet-name>
<servlet-class>hello.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServletExample</servlet-name>
<url-pattern>/sayhello</url-pattern>
</servlet-mapping>
</web-app>

31. To execute the Servlet, right-click on the "HelloServlet" project "Run As" "Run on Server"
Change the URL to "http://localhost:8080/HelloServlet/sayhello".
11.4 Exporting a Web Application as a WAR file

Right-click on the project to be exported Export WAR File In "Destination", specify the
destination directory and filename (the filename shall be the web application name) Finish.
1. To deploy the war file in Tomcat, simply drop the war file into Tomcat's "webapps" folder. The
war file will be automatically extracted and deployed. The web application name is the warfilename.
2. You could use WinZip (or WinRAR) to view the content of the war file, as war-file is in ZIP
format.
11.5 Writing a Hello-world JSF Page
[TODO]
11.6 Debugging Web Applications

You can debug a webapp just like standalone application. For example, you can set breakpoints,
single-step through the programs, etc.
REFERENCES & RESOURCES
1. Eclipse mother site @ www.eclipse.org.

31