Getting Started With the NetBeans IDE Tutorial

Content

• NetBeans IDE Nuts and Bolts
  • Features and Tools
  • Getting Familiar With NetBeans
  • Using the Source Editor
  • Refactoring
  • Debugging
  • Importing Existing Java Source Code Into NetBeans
• Creating, Compiling, and Running an Application
  • Creating the Pay Calculator Application
  • Checking Your GUI
  • Adding Menus and Images
  • Adding Event Handlers
  • Documenting Your Work
• Summary

Using an Integrated Development Environment (IDE) for developing applications saves you time by managing windows, settings, and data. In addition, an IDE can store repetitive tasks through macros and abbreviations. Drag-and-drop features make creating graphical user interface (GUI) components or accessing databases easy, and highlighted code and debugging features alert you to errors in your code.

The NetBeans IDE is open source and is written in the Java programming language. It provides the services common to creating desktop applications -- such as window and menu management, settings storage -- and is also the first IDE to fully support JDK 6.0 features. The NetBeans platform and IDE are free for commercial and noncommercial use, and they are supported by Sun Microsystems.

This tutorial is aimed at those who are new to using IDEs, fairly new to programming, and new to the Java platform. You'll learn to create a simple desktop application with a GUI interface and functionality that calculates overtime pay using basic features of the NetBeans IDE. This tutorial provides explanations for the code where appropriate, as well as links to the Java API and information about objects as they are introduced. Though the NetBeans environment also provides many rich features for the various Java platforms, such as Java Platform, Enterprise Edition (Java EE) and Java Platform, Micro Edition (Java ME), this article covers only Java Platform, Standard Edition (Java SE) technology, which is generally the entry point for new developers and programmers. Future tutorials will discuss more advanced features.

To follow this tutorial, you need to have downloaded and installed the JDK and the NetBeans IDE. Or you can download JDK 6 and NetBeans 6.1 separately to ensure that you have the latest versions.

NetBeans IDE Nuts and Bolts

Because the NetBeans IDE is open source is undergoing continual improvement, you may notice slight differences between the screen captures in this article and the latest download. This tutorial is based on NetBeans 6.1 and may vary slightly from later versions as they become available.

Features and Tools

The NetBeans IDE has many features and tools for each of the Java platforms. Those in the following list are not limited to the Java SE platform but are useful for building, debugging, and deploying applications and applets:

Source Code Editor

• Syntax highlighting for Java, JavaScript, XML, HTML, CSS, JSP, IDL
• Customizable fonts, colors, and keyboard shortcuts
• Live parsing and error marking
• Pop-up Javadoc for quick access to documentation
• Advanced code completion
• Automatic indentation, which is customizable
• Word matching with the same initial prefixes
• Navigation of current class and commonly used features
• Macros and abbreviations
• Goto declaration and Goto class
• Matching brace highlighting
• JumpList allows you to return the cursor to previous modification

GUI Builder

• Fully WYSIWYG designer with Test Form feature
• Support for visual and nonvisual forms
• Extensible Component Palette with preinstalled Swing and AWT components
• Component Inspector showing a component's tree and properties
• Automatic one-way code generation, fully customizable
• Support for AWT/Swing layout managers, drag-and-drop layout customization
• Powerful visual editor
• Support for null layout
• In-place editing of text labels of components, such as labels, buttons, and text fields
• JavaBeans support, including installing, using, and customizing properties, events, and customizers
• Visual JavaBean customization -- ability to create forms from any JavaBean classes
• Connecting beans using Connection wizard
• Zoom view ability

Database Support

• Database schema browsing to see the tables, views, and stored procedures defined in a database
• Database schema editing using wizards
• Data view to see data stored in tables
• SQL and DDL command execution to help you write and execute more complicated SQL or DDL commands
• Migration of table definitions across databases from different vendors
• Works with databases, such as MySQL, PostgreSQL, Oracle, IBM DB2, Microsoft SQL Server, PointBase, Sybase, Informix, Cloudscape, Derby, and more

The NetBeans IDE also provides full-featured refactoring tools, which allow you to rename and move classes, fields, and methods, as well as change method parameters. In addition, you get a debugger and an Ant-based project system.

Getting Familiar With NetBeans

To get started, download the latest stable version from the NetBeans.org web site and install it on whatever platform you use for programming and development. The NetBeans.org web site lists the computer requirements needed to run the IDE.

NetBeans can automatically upgrade its core and extension modules over the Internet, and it has a module that runs periodically on your behalf to check for updates to the version of NetBeans you're using. In addition, the Update Center can update and install any modules you okay or request.

You'll notice that this welcome screen makes getting started right away an easy process by displaying a Quick Start Guide up front, as well as the options to begin a project or open one. In addition, you can select the Sample Project for a quick example of how code is set up in this IDE. NetBeans is fairly intuitive to use, especially if you've used IDE software in the past.

You'll get familiar with three concepts right away: projects, nodes, and workspaces.

Within NetBeans, you work within the context of a project, which consists of an organized group of source files and associated metadata; project-specific properties files; an Ant build script and run settings; and all the tools you'll need to write, compile, test, and debug your application. You can create a main project with subprojects, and you can link projects through dependencies. So getting started is as easy as giving your project a name.

Once you tell NetBeans the name of a new project, it then:

• Creates a source tree with an optional skeleton class inside
• Creates a folder for unit tests
• Sets classpaths for compiling, running, and testing
• Sets the Java platform the project is to run on
• Creates an Ant build script ( build.xml), which contains instructions that the IDE uses when you perform commands on your project, such as compile or run

From there, you can choose the type of application you want to create by selecting a category such as Java, Web, or Enterprise. Notice that within the Java category, you can create a project containing an empty application. Choose Java and select Java Application. Next, name the project and select a location within your file system. Note that the IDE automatically creates a main class for your application if you want it to. Click Finish.

The Projects window displays only the files that are likely to be regularly edited, such as source files and tests. To see more details about your project, click on the Files tab. The Files tab shows a directory-based view of your project. If you click on the project folder you created, you'll see that the folder contains the Ant script and properties files that control how your project is built and run:

• nbproject/build-impl.xml -- Contains the instructions for handling your project. The IDE generates this file, which you should not edit.
• build.xml -- Imports targets from build-impl.xml. You can edit this file to override existing targets or create new targets.

Tip:

Many menu commands such as Run and Build have keyboard shortcuts to the main project. You can also access all commands for individual projects by right-clicking their project nodes in the Projects window.

The Files folder also contains the output folder for compiled classes, JAR files (for Java SE projects) or WAR files (for web projects), and Javadoc. This displays as a build folder after you compile the application.

NetBeans allows you to see all your objects in a project represented as nodes of a tree, each having its own icon to represent the type of object the node represents. Within the Files tab, you can easily view the trees and representative nodes. If you double-click on a node, it opens up into a subtree that contains more detail. You can collapse or expand trees as necessary. Right-clicking on any node provides easy access to specific functions that you can perform and tools that you can use on that object. Expand the subtrees of the project node that you just created, and you will notice that the fields, constructors, methods, and bean patterns appear as node branches.

The Services window lists various facilities available to your project, such as servers, databases, enterprise beans, and web services. In addition, you can see what operations have been performed and troubleshoot some types of runtime errors, such as when a remote method invocation (RMI) connection is causing a problem. You'll get more familiar with this window after you have written, compiled, run, tested and debugged your applications.

Return to the Projects window. Notice the file system that has been created. Files and directories associated with an application project are organized in a logical fashion. Double-clicking a source file automatically opens the file in the workspace to the right, bringing up the appropriate Source Editor.

"Double-click the Main.java source file to see the Source Editor.

When your application is organized into several projects, the main project serves as the entry point to the application. Usually, the main project contains the main class that starts the application. To make a project the main project, right-click the project's node in the Projects window and choose Set Main Project.

Using the Source Editor

You can click right into the Source Editor and write code. When you write code this way, you'll notice that the editor automatically highlights code in color as appropriate and provides suggestions for code-completion as you type.

You can customize colors in the highlighting by going to Tools > Options (NetBeans > Preferences on a Mac) > Fonts and Colors.

Code completion finishes package names, classes, interfaces, and common methods. As handy as code completion can be, you may sometimes not want it. You can easily turn off this feature by pressing Esc. Or you can deactivate it more permanently by going to Tools > Options (NetBeans > Preferences on a Mac) > Editor > General, and under Code Completion, deselecting the Auto Popup Completion Window checkbox.

You can also save time by assigning abbreviations that the Source Editor expands for you. To set abbreviations, go to Tools > Options (NetBeans > Preferences on a Mac) > Editor > Code Templates. Type the first few letters of an abbreviation and press the spacebar. The Source Editor then expands the abbreviation.

Turn on line numbering easily by right-clicking in the Source Editor's left sidebar and selecting Show Line Numbers.

When programming in Java, you can add to your source code by making use of commonly-used code templates. Press Ctrl-I in the Source Editor to view the Insert Code pop-up menu. Add properties to classes, create constructors, generate accessor methods, and override methods from superclasses. When adding properties, the IDE provides you with a dialog.

For more information on editing features in the IDE, see Java Editing Enhancements in NetBeans IDE 6.0

Refactoring

The refactoring tool goes to work and makes all the necessary changes based on your single entry. Refactoring is the restructuring of code, using small transformations, where the result does not change any program behavior. Just as you factor an expression to make it easier to understand or modify, you refactor code to make it easier to read, simpler to understand, and faster to update. A refactored expression must produce the same result, and the refactored program must be functionally equivalent with the original source.

Some common reasons for refactoring code include the following:

• To make the code easier to change or easier to add a new feature
• To reduce complexity for better understanding
• To remove unnecessary repetition
• To enable use of the code for other needs or more general needs

NetBeans provides the following features for refactoring:

• Finds where classes, variables, and methods are used throughout the source code in your project.
• Enables you to move a class to another package or into another class and enables you to move a static field or a static method from one class to another. In addition, it updates all source code in your project to reference the element in its new location.
• Enables you to change the name of a class, variable, or method to something more meaningful. In addition, it updates all source code in your project to reference the element by its new name.
• Generates a getter method and a setter method for a field and optionally updates all referencing code to access the field using the getter and setter methods.
• Enables you to add parameters to a method and change the access modifier.
• Enables you to roll back all the changes in all the files that were affected by the refactoring.

To view the Refactor menu, right-click and choose Refactor from an item in the Projects window, or right-click and choose Refactor of an opened file in the Source Editor.

Debugging

Within the NetBeans IDE, you can debug by setting breakpoints and watches in your code, then running your application in the debugger. You can execute your code one line at a time and examine the state of your application in order to discover any problems. When you start a debugging session, all of the relevant debugger windows appear automatically at the bottom of your screen. You can debug an entire project, any executable class, and any JUnit tests. The IDE also lets you debug applications that are running on a remote machine by attaching the debugger to the application process.

A breakpoint is a flag in the source code that tells the debugger to stop execution of the program. When your program stops on a breakpoint, you can perform actions like examining the value of variables and single-stepping through your program. The Source Editor indicates a breakpoint by highlighting the line in red and placing an annotation in the left margin.

Except for line breakpoints, all Java breakpoints are defined globally for all IDE projects. For example, if you set a breakpoint on a class, the IDE will stop execution every time it encounters that class during a debugging session regardless of what project you are debugging.

To set a line breakpoint, click on the left margin of the line in the Source Editor. A line breakpoint is denoted by a red square, and a field breakpoint is displayed as a triangle.

You can customize a breakpoint by right-clicking on the breakpoint icon and choosing Breakpoint > Customize. The Customizer dialog enables you to set conditions and actions on the breakpoint. You can set other types of breakpoints as well, such as the following:

• Method -- Program execution stops every time the method is executed.
• Exception -- You can break whenever a specific exception is caught, whenever a specific exception is not handled in the source code or whenever any exception is encountered regardless of whether the program handles the exception or not.
• Variable -- You can stop execution of your program whenever a variable in a specific class is accessed (for example, the method was called with the variable as an argument) or modified.
• Thread -- You can break program execution whenever a thread starts, stops, or both.
• Class -- You can break when the class is loaded into the virtual machine, unloaded from the virtual machine, or both.

To run the debugger tool, click the Debug Main Project icon in the main tool bar, or choose Run > Debug Main Project from the main menu. For a quick demonstration of the debugger tool in action, see Demo of JDK Debugging.

Importing Existing Java Source Code Into NetBeans

You can use two project templates to import your existing source code:

• Java Project With Existing Sources -- Use this project template to create a standard Java project. A standard Java project uses the IDE to compile, run, and debug your application.
• Java Free-From Project -- Use this project template if you want to use your own Ant script to compile, run, and debug your application.

The following steps cover use of the first template to create a standard Java project without the use of existing Ant scripts.

1. Choose File > New Project (Ctrl-Shift-N).
2. Choose Java > Java Project With Existing Sources.
3. Click Next.
4. In the Project Name field, type a name for your project. Notice that the IDE automatically suggests a name for the project folder.
5. Click the Browse button next to the Project Folder field and create a folder somewhere on your system for your NetBeans projects. Then select the newly created NetBeans projects folder. Be sure to select the Set as Main Project box, then click Next.
6. In the Existing Sources pane, click Add Folder, navigate to the directory of source files, and select the resources and src folders.
7. (Optional) In the Test Packages Folder pane, click Browse to select the folder containing the JUnit package folders.
8. Click Finish.

Your project will now be displayed in the Projects and Files windows.

jLabel9 = new javax.swing.JLabel();

...
jLabel9.setIcon(new javax.swing.ImageIcon("/Users/nbuser/Desktop/newjava.gif"));

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

// TODO add your handling code here:
}

jButton1.addActionListener(new java.awt.event.ActionListener() {

    public void actionPerformed(java.awt.event.ActionEvent evt) {
        jButton1ActionPerformed(evt);
    }
});

byte - Byte
short - Short
int - Integer
long - Long
char - Character
float - Float
double - Double
boolean - Boolean

String myString = "12345";

int myInt = Integer.parseInt(myString);

byte - Byte.parseByte(aString)

short - Short.parseShort(aString)
int - Integer.parseInt(aString)
long - Long.parseLong(aString)
float - Float.parseFloat(aString)
double - Double.parseDouble(aString)
boolean - Boolean.valueOf(aString).booleanValue();

// The variable e is the character e in the string Hello

String hello = "Hello";
char e = hello.charAt(1);

If the String contents cannot be converted to the requested primitive type, then a NumberFormatException is thrown. This is a runtime exception, so the conversion code does not have to be in a try-catch block.

The NumberFormat class is used to print the numbers correctly. Printing numbers to the screen can produce some odd or undesired results. For instance:

public class PrintNum {

    public static void main(String args[]) {
        double amount = 400000.00;
        System.out.println("She paid " + amount + " for the house.");
    }
}

results in:

She paid 400000.0 for the house.

You can control the display format and arrange input into the needed output format by using the NumberFormat abstract class in the java.text package. This class provides the interface to format and parse numbers, and it includes methods to determine which locales have number formats and what their names are.

The class has methods for three standard formats:

• getInstance or getNumberInstance gets a format for the normal number format, such as 600,000.
• getCurrencyInstance gets a format for the currency number format, such as $600,000.00.
• getPercentInstance gets a format for displaying percentages, such as 56%.

To format a primitive, start by returning an object of type NumberFormat by calling on one of the above methods.

NumberFormat nf = NumberFormat.getCurrencyInstance();

To be certain the amount is formatting correctly for a specific country, you specify the locale this way:

NumberFormat nf =

NumberFormat.getCurrencyInstance(Locale.US);

The result is:

She paid $400,000.00 for the house.

To compile these, you'll need to import the following packages and add them to the top of the file:

import java.text.NumberFormat;

import java.util.Locale;

Now, back to the application you are building: Add the following code to the jButton1ActionPerformed() event handler method. Read the comments in the code, which provide some explanation. If you are new to using if/else statements, read Java Programming Language Basics: if/else and switch statements, which is a part of the Java Technology Fundamentals newsletter.

//Gets how many hours worked from the text field, and then parses it to type int.

int hw = Integer.parseInt(hoursWorked.getText());

//Gets the pay rate entered in the text field, and parses it to type double.
double rateEntered = Double.parseDouble(rate.getText());

//Creates two variables of type double for later use.
double regularPay = 0;
double overTimePay = 0;

//Simple if statement for calculations
if (hw > 40) {
    regularPay = 40 * rateEntered;
    overTimePay = (hw - 40) * 1.5 * rateEntered;
} else {
      regularPay = hw * rateEntered;
      overTimePay = 0.0;
}

//Creates a variable of both types of pay combined.
double total = regularPay + overTimePay;

//Creates variables for number formatting
NumberFormat nfRegular = NumberFormat.getCurrencyInstance(Locale.US);
NumberFormat nfOverTime = NumberFormat.getCurrencyInstance(Locale.US);
NumberFormat nfTotal = NumberFormat.getCurrencyInstance(Locale.US);

//Writes the totals in the correct format to the labels
regularPayField.setText(" " + nfRegular.format(regularPay));
overtimePayField.setText(" " + nfOverTime.format(overTimePay));
totalField.setText(" " + nfTotal.format(total));

After entering the above code, make sure to add imports for NumberFormat and Locale. You can do this by right-clicking in the Source Editor and choosing Fix Imports. A dialog displays, showing you the fully qualified class names that match the unrecognized classes used in the file.

Compile and run the application. Test it out by entering hours worked and pay rate.

You'll notice that the menus are still nonfunctional. You can follow the same procedure to add events to your menu items. In the Inspector, right-click ExitItem and choose Events > Action > actionPerformed. You'll be sent to the Source Editor, where you can see the following code:

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

// TODO add your handling code here:
}

Type in the following code (changes in bold):

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

// TODO add your handling code here:
     
                  System.exit(1);
}
                  

Select Clean and Build Project, then run your application, closing it with the Exit menu. Follow the same procedure for each menu item and any other objects that require functionality.

If there are any objects you don't want in your application, select the object in the Inspector. Right-click and select Delete. The item immediately disappears from the view. You can then Clean and Build the application, and run it to verify changes. Try this by deleting OpenItem. You'll see that cleanup is an easy process.

Documenting Your Work

Documenting your application is always a good idea, especially if many people are working on one project. This sample application is a bit small for a good demonstration of the Javadoc tool feature, but the following steps provide you with an idea of the kind of information that goes into the documentation and see how NetBeans does all the hard work for you.

Click into the Files window, then click your project node. Go to the Build Menu and select Generate Javadoc for JavaApplication (or whatever name you gave your project). The IDE generates the Javadoc in the dist > javadoc folder, and you'll see output provided in the Output window. Then a browser window pops up with the documentation formatted in HTML. Click on SamplesJFrame, and scroll down to see the documentation. This application would not require much documentation, but if you continue building in this project or move on to other larger projects, Javadoc will come in handy.

Summary

You have completed a small desktop application and learned some of the basics of the NetBeans IDE. A big advantage of using the NetBeans IDE platform is that you won't outgrow it. As your development knowledge and skills build, you can delve into other technologies and platforms, such as web development, including EJB and web service applications, or mobile applications using the Java Micro Edition (Java ME) platform. In addition, NetBeans is extensible, meaning that many of the extensions, or modules, that work in NetBeans also work seamlessly within other products. The IDE evolves with your needs and experience, and you build on the experience you gain using a common IDE platform, rather than having to learn an entirely new toolset as your needs change.

For More Information

• http://netbeans.org/