Developing General Java Applications

Last reviewed on 2019-02-24

The following short tutorial takes you through some of the basic steps of developing a Java SE application in the NetBeans IDE. This tutorial assumes you already have some familiarity with developing Java applications. Along the way, you will see some of the IDE’s features that simplify application development.

You will create an application that converts several words into a single word that contains one letter from each of the other words. The resulting word is called an acrostic.

This tutorial takes approximately 30 minutes to complete. If you would like to do a quicker Hello World tutorial, see the NetBeans IDE Java Quick Start Tutorial.

Project Setup

The application you create will contain two projects:

  • A Java Class Library project, MyLib, in which you will create a utility class.

  • A Java Application project, MyApp, with a main class that implements a method from the library project’s utility class.

After you create the projects, you will add the library project, MyLib, to the classpath of the application project, MyApp. Then you will code the application. The library project will contain a utility class with a method named acrostic . The method acrostic takes an array of words as a parameter and then generates an acrostic based on those words. The MyApp project will contain a class Main that calls method acrostic and passes the words that are entered as arguments when the application is run.

Strictly speaking, two projects are not needed for such a simple application. This tutorial uses two projects to demonstrate features that you might need for a more complex application.

Creating a Java Class Library Project

To open a new Java project, press:

Windows™/Linux

Ctrl+Shift+N

macOS

Command+Shift+N

or, select File > New Project…​ from the menu bar. Then Choose Project by selecting Categories: Java and Projects: Java Class Library, then click Next >.

For Name and Location, set Project Name: MyLib. Change Project Location: to any directory on your computer. From now on, this tutorial refers to this directory as NetBeansProjects.

The specified path is then shown as Project Folder: /NetBeansProjects/MyLib

Optionally, select Use Dedicated Folder for Storing Libraries checkbox and specify the location for the libraries Folder:. See Sharing a Library with Other Users in Developing Applications with NetBeans IDE for more information on this option.

Finally, click Finish. The MyLib project will be created and opens in the Projects window.

Creating a Java Application Project

Open a new Java Project, as shown above. Then Choose Project by selecting Categories: Java and Projects: Java Application, then click Next >.

for Name and Location, set Project Name: MyApp. Make sure the Project Location is set to NetBeansProjects.

Optionally, select the Use Dedicated Folder for Storing Libraries checkbox.

Ensure that the Create Main Class checkbox is selected and, enter acrostic.Main as the main class.

Finally, click Finish. The MyApp project is displayed in the Projects window and Main.java opens in the source editor.

Configuring the Compilation Classpath

Since class MyApp is going to depend on class MyLib, you have to add MyLib to the classpath of MyApp. Doing so also ensures that classes in the MyApp Project can refer to classes in the MyLib Project without causing compilation errors. In addition, this enables you to use code completion in the MyApp Project to fill in code based on the MyLib Project. In the IDE, the classpath is visually represented by the Libraries node.

To add the library’s utility classes to the project classpath:

In the Projects window, right-click the Libraries node for the MyApp project and choose Add Project…​ as shown in the image below.

addproj

If necessary, in the Add Project window browse to NetBeansProjects and, select the MyLib project folder. When you do so, you will see Project Name: MyLib and, Project JAR Files: dist/MyLib.jar can be added to the project.

Notice that a JAR file is shown for MyLib even though you have not actually built one yet. This JAR file will get built when you build and run the MyApp project.

Select Add Project JAR Files then expand the Libraries node of MyApp in the Projects window and, you will see that MyLib project’s JAR file has been added to the MyApp project’s classpath.

Creating and Editing Java Source Code

Now you need to create a Java package and, add the method that will construct the acrostic. After that you need to implement the method acrostic in class Main.

Creating a Java Package and Class File

In the Projects window, right-click the MyLib project node and select New > Java Class…​ . Alternatively, regardless of where you are in the project, press:

Windows™/Linux

Ctrl+N

macOS

Command+N

or, select File > New File…​ from the menu bar. Then in the New File window select: Project: MyLib, Categories: Java and File Types: Java Class then click Next.

In the New Java Class window, type: Class Name: LibClass and Package: org.me.mylib. Click Finish and LibClass.java opens in the source editor.

In LibClass.java, place the cursor on the line after the class declaration public class LibClass {.

Type or paste in the following method code:

    public static String acrostic(String[] args) {
        StringBuffer b = new StringBuffer();
        for (int i = 0; i < args.length; i++) {
            if (args[i].length() > i) {
                b.append(args[i].charAt(i));
            } else {
                b.append('?');
            }
        }
        return b.toString();
    }

If the code that you pasted in is not formatted correctly, press:

Windows™/Linux

Alt+Shift+F

macOS

Ctrl+Shift+F

or, Source > Format from the menu bar or, right-click Format to reformat the entire file. Then save your file:

Windows™/Linux

Ctrl+S

macOS

Command+S

or, select File > Save from the menu bar.

Editing a Java File

Now you will add some code to class Main.java. In doing so, you will see the source editor’s code completion and, code template features.

Select the Main.java tab in the source editor. If it isn’t already open, select the Projects window and expand MyApp > Source Packages > acrostic and either: double-click Main.java or, right-click and select Open.

In the method main, delete the comment: // TODO code application logic here and, in its place type the following:

String result = Li

At this point stop typing but leave the cursor immediately after Li. Invoke code completion by pressing Ctrl+Space, a short list of options appears. However, the class that you want, LibClass might not be there. If you press Ctrl+Space again a longer code completion list appears containing LibClass, select LibClass and press Enter. The IDE fills in the rest of the class name and also automatically creates an import statement for the class.

The IDE also opens a box above the code completion box that displays Javadoc information for the selected class or package. Since there is no Javadoc information for this package, the box displays a "Cannot find Javadoc" message.

In the main method, type a period ( . ) after LibClass, the code completion box opens again. Select the acrostic(String[]args) method and press Enter. The IDE fills in the acrostic method and highlights the args parameter, press Enter again to accept args as the parameter, end the line with a semicolon ( ; ). The line should look, as follows:

String result = LibClass.acrostic(args);

Press Enter to start a new line. Then type sout and press Tab. The sout abbreviation expands to System.out.println(""); with the cursor positioned between the quotation marks. Type Result = inside the quotation marks and + result after the end quotation mark. The final line should look like the following line.

System.out.println("Result = " + result);

Save the file.

sout is one of many code templates that are available in the Source Editor. To find out how to edit using code templates see, See Sharing a Library with Other Users in Developing Applications with NetBeans IDE for more information on this option.choose Tools > Options > Editor > Code Template.

Compiling and Running the Application

Now you need to set the main class and execution arguments so that you can run the project.

By default, the projects have been created with the Compile on Save feature enabled, so you do not need to compile your code first in order to run the application in the IDE. For more information, see Compiling a Single Java File in Developing Applications with NetBeans IDE.

Setting the Main Class and Execution Arguments

The output of this program is based on arguments that you provide when you run the program. As arguments, you will provide five words, from which the acrostic "Hello" will be generated. The acrostic is assembled from the first letter of the first word, the second letter of the second word, the third letter of the third word, and so on.

To add the arguments for the IDE to use when running the application:

From the Projects window, right-click the MyApp project node and select Properties. The Project Properties window opens, select the Categories: Run node in the dialog’s left-hand pane. In the right-hand pane set Arguments: However we all feel zealous and select OK.

Running the Application

Now that you have created the application and provided runtime arguments for the application, you can test run the application in the IDE.

To run the application in the IDE:

First, press F11 to clean and build your project or, in the Projects window right-click the MyApp project node and choose Clean and Build or, select Run > Clean and Build Project (MyApp) from the menu bar.

Then, you can press F6 or, in the Projects window right-click the MyApp project node and choose Run or, select Run > Run Project (MyApp) from the menu bar .

In the Output window, you should see the output from the program, Result = Hello, the acrostic of the phrase that was passed as an argument to the program.

Testing and Debugging the Application

Now you will create and run a test for the project using JUnit and then run the application in the IDE’s debugger to check for errors. In the JUnit test, you will test the LibClass by passing a phrase to the acrostic method and using an assertion to indicate what you think the result should be.

Creating JUnit Tests

To create a JUnit test, from the Projects window select the LibClass.java node and press:

Windows™/Linux

Ctrl+Shift+U

macOS

Command+Shift+U

or, select Tools > Create/Update Tests from the menu bar or, in the Projects window, right-click the LibClass.java node and and select Tools > Create/Update Tests.

In the Create/Update Tests dialog box, click OK to run the command with the default options.

In the Projects window you will see that the IDE has created the org.me.mylib package, the LibClassTest.java file in the MyLib > Test Packages folder and, created the MyLib > Test Libraries folder. Finally the file LibClassTest.java is opened in the editor.

In the Projects window, right-click the Test Libraries node and select Properties. In the Project Properties - MyLib window, select Categories: Libraries. In the right-hand pane select the Compile Tests tab and click the ` + ` button. From the pop-up list select Add Library, from the Global Libraries folder select JUnit 4.x and click Add Libray repeat, this time selecting the Hamcrest 1.x library.

In LibClassTest.java, delete the body of the public void testAcrostic() method and, in place of the deleted lines, type or paste in the following:

System.err.println("Running testAcrostic...");
String result = LibClass.acrostic(new String[]{"fnord", "polly", "tropism"});
assertEquals("Correct value", "foo", result);

Then Save the file.

Running JUnit Tests

In the Projects window, select the MyLib project node and press:

Windows™/Linux

Alt+F6

macOS

Ctrl+F6

or, select Run > Test Project (MyLib) from the menu bar or, right-click the MyLib project node and select Test. A notification pops up telling you "Tests completed successfully for project: MyLib", and then instructs you to open the Test Results window, were you will receive confirmation of success.

You can also run a single test file rather than testing the entire project. Right-click the LibClass.java node in the Projects window and choose Run > Test File. Alternatively, if LibClassTest.java is open in the editor, select Run > Test File from the menu bar.

The JUnit API documentation is available from the IDE. To look for Javadoc references, select Help > Javadoc References from the menu bar and select JUnit.

If this is the first time you try to access Javadoc in the IDE, you need to first choose Help > Javadoc References > More Javadoc.

You can learn more about JUnit by visiting http://www.junit.org

Debugging the Application

In this section, you will use the debugger to step through the application and watch the values of variables change as the acrostic is assembled.

To run the application in the debugger:

In the LibClass.java file, go to the acrostic method and place the insertion point anywhere inside b.append(args[i].charAt(i));, then set a breakpoint by pressing:

Windows™/Linux

Ctrl+F8

macOS

Command+F8

or, select Debug > Toggle Line Breakpoint from the menu bar or, in the left hand margin right-click the specified line and select Breakpoint > Toggle Line Breakpoint.

Select the MyApp project node in the Projects window and, press:

Windows™/Linux

Ctrl+F5

macOS

Shift+F5

or, select Debug > Debug Project (MyApp) from the menu bar or, right-click and select Debug. The IDE opens the Debugging window and runs the project in the debugger until the breakpoint is reached.

Select the Variables window in the bottom of the IDE and expand the args node. The array of strings contains the phrase you entered as the command arguments.

Press F7 or, select Debug > Step Into from the menu bar to step through the program and watch the b variable change as the acrostic is constructed.

When the program reaches the end, the debugger windows close.

For more information, see Writing JUnit Tests in NetBeans IDE.

Building, Running, and Distributing the Application

Once you are satisfied that your application works properly, you can prepare the application for deployment outside of the IDE. In this section you will build the application’s JAR file and then run the JAR file from the command line.

Building the Application

The main build command in the IDE is the Clean and Build command. The Clean and Build command deletes previously compiled classes and other build artifacts and then rebuilds the entire project from scratch.

There is also a Build command, which does not delete old build artifacts, but this command is disabled by default. See About Building Java Projects in Developing Applications with NetBeans IDE for more information.

To build the application, press Shift+F11 or, if Main.java is open in the editor, select Run > Clean and Build Project (MyApp) from the menu bar or, in the projects window right-click on the MyApp node and select Clean and Build.

Output from the Ant build script appears in the Output window, If the window does not appear automatically, open it manually by choosing Window > Output from the menu bar.

When you clean and build your project, the following things occur:

  • Output folders that have been generated by previous build actions are deleted, " cleaned ". In most cases, these are the build and dist folders.

  • build and dist folders are added to your project folder, hereafter referred to as the PROJECT_HOME folder. You can view these folders in the Files window.

  • All of the sources are compiled into .class files, which are placed into the PROJECT_HOME/build folder.

  • A JAR file containing your project is created inside the PROJECT_HOME/dist folder.

  • If you have specified any libraries for the project, in addition to the JDK, a lib folder is created in the dist folder. The libraries are copied into dist/lib.

  • The manifest file in the JAR is updated to include entries that designate the main class and any libraries that are on the project’s classpath.

You can view the contents of the manifest in the IDE’s Files window. After you have built your project, switch to the Files window and navigate to dist/MyApp.jar. Expand the node for the JAR file, expand the META-INF folder, and double-click MANIFEST.MF to display the manifest in the Source Editor.

To find more about manifest files, you can read this chapter from the Java Tutorial.

Running the Application Outside of the IDE

To run the application outside of the IDE:

On your system, open up a command prompt or terminal window.

In the command prompt, change directories to the MyApp/dist directory.

At the command line, type the following statement:

java -jar MyApp.jar However we all feel zealous

The application then executes and returns the following output as shown in the image below:

Result = Hello

Distributing the Application to Other Users

Now that you have verified that the application works outside of the IDE, you are ready to distribute the application.

To distribute the application:

On your system, create a zip file that contains the application JAR file (MyApp.jar) and the accompanying lib folder that contains MyLib.jar.

Send the file to the people who will use the application. Instruct them to unpack the zip file, making sure that the MyApp.jar file and the lib folder are in the same folder.

Instruct the users to follow the steps in the Running the Application Outside of the IDE section above.

Other Common Tasks

You have now completed the main part of the tutorial, but there are still some basic tasks that have not been covered. This section includes a few of those tasks.

Making the Javadoc Available in the IDE

To view the Java SE API documentation in the NetBeans IDE, select either: Source > Show Documentation or, Window > IDE Tools > Javadoc Documentation from the menu bar.

However, for some third-party libraries, API documentation is not available. In these cases, the Javadoc resources must be manually associated with the IDE.

If you have not already installed the Javadoc for your JDK then go to:

and, download the file.

To install, select Tools > Java Platforms from the menu bar and, in the Java Platform Manager window select the Javadoc tab and click Add ZIP/Folder…​. Navigate to the download file, select and then click the Add ZIP/Folder button, finally click Close.

Generating Javadoc for a Project

You can generate compiled Javadoc documentation for your project based on Javadoc comments that you have added to your classes.

To generate Javadoc documentation for a project:

From the Projects window select the MyLib project node then select Run > Generate Javadoc (MyLib) from the menu bar.

The generated Javadoc is added to the dist folder of the project. In addition, the IDE opens a web browser that displays the Javadoc.