Java Technology Fundamentals

The Numbers Classes

2009-01-07T10:02:20-08:00

Working with numbers can be a large part of application programming. Follow this tutorial to get familiar with the Numbers classes, and how to work with numbers in your applications.

When working with numbers, most of the time you use the primitive types in your code. For example:
int i = 500;
float gpa = 3.65f;
byte mask = 0xff;
There are, however, reasons to use objects in place of primitives, and the Java platform provides wrapper classes for each of the primitive data types. These classes "wrap" the primitive in an object. Often, the wrapping is done by the compiler—if you use a primitive where an object is expected, the compiler boxes the primitive in its wrapper class for you. Similarly, if you use a number object when a primitive is expected, the compiler unboxes the object for you.
Here is an example of boxing and unboxing:
Integer x, y;
x = 12;
y = 15;
System.out.println(x+y);
When x and y are assigned integer values, the compiler boxes the integers because x and y are integer objects. In the println() statement, x and y are unboxed so that they can be added as integers.
All of the numeric wrapper classes are subclasses of the abstract class Number:

Note: There are four other subclasses of Number that are not discussed here. BigDecimal and BigInteger are used for high-precision calculations. AtomicInteger and AtomicLong are used for multi-threaded applications.
There are three reasons that you might use a Number object rather than a primitive:

As an argument of a method that expects an object (often used when manipulating collections of numbers).

To use constants defined by the class, such as MIN_VALUE and MAX_VALUE, that provide the upper and lower bounds of the data type.

To use class methods for converting values to and from other primitive types, for converting to and from strings, and for converting between number systems (decimal, octal, hexadecimal, binary).

The following table lists the instance methods that all the subclasses of the Number class implement.

Methods Implemented by all Subclasses of Number

Method Description

byte byteValue()
short shortValue()
int intValue()
long longValue()
float floatValue()
double doubleValue() Converts the value of this Number object to the primitive data type returned.

int compareTo(Byte anotherByte) int compareTo(Double anotherDouble) int compareTo(Float anotherFloat) int compareTo(Integer anotherInteger) int compareTo(Long anotherLong) int compareTo(Short anotherShort) Compares this Number object to the argument.

boolean equals(Object obj) Determines whether this number object is equal to the argument.
The methods return true if the argument is not null and is an object of the same type and with the same numeric value.
There are some extra requirements for Double and Float objects that are described in the Java API documentation.

Each Number class contains other methods that are useful for converting numbers to and from strings and for converting between number systems. The following table lists these methods in the Integer class. Methods for the other Number subclasses are similar:

Conversion Methods, Integer Class

Method Description

static Integer decode(String s) Decodes a string into an integer. Can accept string representations of decimal, octal, or hexadecimal numbers as input.

static int parseInt(String s) Returns an integer (decimal only).

static int parseInt(String s, int radix) Returns an integer, given a string representation of decimal, binary, octal, or hexadecimal (radix equals 10, 2, 8, or 16 respectively) numbers as input.

String toString() Returns a String object representing the value of this Integer.

static String toString(int i) Returns a String object representing the specified integer.

static Integer valueOf(int i) Returns an Integer object holding the value of the specified primitive.

static Integer valueOf(String s) Returns an Integer object holding the value of the specified string representation.

static Integer valueOf(String s, int radix) Returns an Integer object holding the integer value of the specified string representation, parsed with the value of radix. For example, if s = "333" and radix = 8, the method returns the base-ten integer equivalent of the octal number 333.

**Methods Implemented by all Subclasses of Number**
Method	Description
`byte byteValue()` `short shortValue()` `int intValue()` `long longValue()` `float floatValue()` `double doubleValue()`	Converts the value of this `Number` object to the primitive data type returned.
`int compareTo(Byte anotherByte) int compareTo(Double anotherDouble) int compareTo(Float anotherFloat) int compareTo(Integer anotherInteger) int compareTo(Long anotherLong) int compareTo(Short anotherShort)`	Compares this `Number` object to the argument.
`boolean equals(Object obj)`	Determines whether this number object is equal to the argument. The methods return `true` if the argument is not `null` and is an object of the same type and with the same numeric value. There are some extra requirements for `Double` and `Float` objects that are described in the Java API documentation.

**Conversion Methods, `Integer` Class**
Method	Description
`static Integer decode(String s)`	Decodes a string into an integer. Can accept string representations of decimal, octal, or hexadecimal numbers as input.
`static int parseInt(String s)`	Returns an integer (decimal only).
`static int parseInt(String s, int radix)`	Returns an integer, given a string representation of decimal, binary, octal, or hexadecimal (`radix` equals 10, 2, 8, or 16 respectively) numbers as input.
`String toString()`	Returns a `String` object representing the value of this `Integer`.
`static String toString(int i)`	Returns a `String` object representing the specified integer.
`static Integer valueOf(int i)`	Returns an `Integer` object holding the value of the specified primitive.
`static Integer valueOf(String s)`	Returns an `Integer` object holding the value of the specified string representation.
`static Integer valueOf(String s, int radix)`	Returns an `Integer` object holding the integer value of the specified string representation, parsed with the value of radix. For example, if s = "333" and radix = 8, the method returns the base-ten integer equivalent of the octal number 333.

« Previous • Trail • Next »

Application Basics With Ants (Young Developer Series, Part 3)

2008-12-01T09:06:19-08:00

By Dana Nourie, December 2008

Learn about Java packages, variables, and ways that objects interact with each other through methods.

In the articles Wombat Object Basics and Wombat Classes Basics, you learned about objects, classes, methods, and language syntax. Now, in Part 3 of the Young Developer series, you'll learn what is involved in writing a Java application that relies on other Java classes (or Java API), what variables are, how to use variables, and how objects interact through methods.

As in the last article, to follow along, you will need these installed on your computer:

The Java SE software
Greenfoot

This article is aimed at anyone interested in Java programming who is from the age of 10 to 100 and who has no programming experience. We recommend that you have read and followed the instructions in Wombat Object Basics and Wombat Classes Basics before you move on to this article.

Looking at Packages and Variables in Ants

For this tutorial, open the Ants scenario by going to the Scenario menu, and selecting Open. The scenarios folder should automatically be visible. Choose ants, and then click Open as shown in Figure 1.

Figure 1. Opening the Ants Scenario

A new window opens and displays the Ants scenario. If you do not see the sand-colored world on the screen, click the Compile All button at the bottom of the scenario main screen.

Read the rest of this article . . .

Security

2008-11-10T13:23:46-08:00

Trail: Security Features in Java SE

In this trail you'll learn how the built-in Java™ security features protect you from malevolent programs. You'll see how to use tools to control access to resources, to generate and to check digital signatures, and to create and to manage keys needed for signature generation and checking. You'll also see how to incorporate cryptography services, such as digital signature generation and checking, into your programs.

The security features provided by the Java Development Kit (JDK™) are intended for a variety of audiences:

Users running programs:

Built-in security functionality protects you from malevolent programs (including viruses), maintains the privacy of your files and information about you, and authenticates the identity of each code provider. You can subject applications and applets to security controls when you need to.
Developers:

You can use API methods to incorporate security functionality into your programs, including cryptography services and security checks. The API framework enables you to define and integrate your own permissions (controlling access to specific resources), cryptography service implementations, security manager implementations, and policy implementations. In addition, classes are provided for management of your public/private key pairs and public key certificates from people you trust.
Systems administrators, developers, and users:
JDK tools manage your keystore (database of keys and certificates); generate digital signatures for JAR files, and verify the authenticity of such signatures and the integrity of the signed contents; and create and modify the policy files that define your installation's security policy.

Trail Lessons

Quick Tour of Controlling Applets shows how resource accesses, such as reading or writing a file, are not permitted for unsigned applets unless explicitly allowed by a permission in a policy file.

Quick Tour of Controlling Applications builds on the previous lesson, showing that when applications are run under a security manager, resource accesses may be controlled in exactly the same way as for unsigned applets.

API and Tools Use for Secure Code and File Exchanges defines digital signatures, certificates, and keystores and discusses why they are needed. It also reviews information applicable to the next three lessons regarding the steps commonly needed for using the tools or the API to generate signatures, export/import certificates, and so on.

Signing Code and Granting It Permissions illustrates the use of all the security-related tools. It shows the steps that a developer would take to sign and to distribute code for others to run. The lesson also shows how someone who will run the code (or a system administrator) could add an entry in a policy file to grant the code permission for the resource accesses it needs.

Exchanging Files shows use of the tools by one person to sign an important document, such as a contract, and to export the public key certificate for the public key corresponding to the private key used to sign the contract. Then the lesson shows how another person, who receives the contract, the signature, and the public key certificate, can import the certificate and verify the signature.

Generating and Verifying Signatures walks you step by step through an example of writing a Java program using the JDK Security API to generate keys, to generate a digital signature for data using the private key, and to export the public key and the signature to files. Then the example shows writing a second program, which may be expected to run on a different person's computer, that imports the public key and verifies the authenticity of the signature. Finally, the example discusses potential weaknesses of the approach used by the basic programs and demonstrates possible alternative approaches and methods of supplying and importing keys, including in certificates.

Implementing Your Own Permission demonstrates how to write a class that defines its own special permission.

*******************

Test Your Java Knowledge - Chance to Win 1 of 100 books!

Take the SDN Quiz to see how much you know about Java. Join or log into the Sun Developer Network and answer the questions correctly for a chance to win one of 100 Hello World(s) -- From Code to Culture: A 10 Year Celebration of Java Technology (Hardcover). Register to take the Quiz and a chance to Win Today!

No purchase necessary. Void where prohibited. Open to legal residents of U.S. (excluding Puerto Rico) and Canada (excluding Quebec) 18 years or older. Entrants are responsible for complying with their employers' policies regarding acceptance of promotional items. Entries accepted from 11/04/08 to 12/01/08. 100 winners will receive one copy of the book Hello World(s) -- From Code to Culture: A 10 Year Celebration of Java Technology (Hardcover) (US $24.99). For complete Official Rules, visit here.

UML: Developing Applications

2008-10-28T12:32:35-07:00

Contributed by Sherry Barkodar and maintained by Cindy Castillo and Bob May November 2007 [Revision number: V1-4]
This publication is applicable to NetBeans IDE 6.0 and 6.1 releases.

In this tutorial, you learn how to use the UML features of the IDE to create a simple UML class diagram. You then use the code generation and reverse engineering features to develop a simple banking application, which you can test by executing a test class. This banking application is greatly simplified; a real model for an application of this type would require more detail. The purpose of this tutorial is to introduce some of the IDE's UML features, not to teach you about UML concepts or the Java programming language.

Expected duration: 25 minutes

Tutorial Requirements

Before you proceed, make sure you review the requirements in this section.

Prerequisites

To use this tutorial, the IDE must be installed on your system and you should be familiar with the basic parts of the IDE. You should also have a basic familiarity with the Java programming language and UML. For a basic understanding of the IDE, see the IDE Basics topics in the online help. A good resource for UML techniques and theory is the official UML resource page at http://www.uml.org/.

System Requirements

This tutorial assumes that your system meets the requirements specified in the Systems Requirements section of the NetBeans 6.1 Release Notes.

Software Needed for This Tutorial

To follow this tutorial, you need the software and resources listed in the following table.

Software or Resource	Version Required
NetBeans IDE	version 6.1 or version 6.0
Java Development Kit (JDK)	version 6 or version 5

Software or Resource

Version Required

NetBeans IDE

version 6.1 or
version 6.0

Java Development Kit (JDK)

version 6 or
version 5

Creating the Java Project for the Application

In this section , you create a new Java project for the Java application you are going to develop in this tutorial.

From the main menu, choose File > New Project and then do the following in the New Project wizard:
1. Under Categories, select Java.
2. Under Projects, select Java Application
3. Click Next.
In the Project Name field, type JavaPrj.
For the Project Location field, click Browse, navigate to any directory on your computer. Click Open and type MyPrj.
Clear the Set as Main Project and the Create Main Class checkboxes.
Click Finish.
A progress dialog box appears.
When the new JavaPrj project is created, it appears in the Projects window.

View Demo

top

Creating the UML Project and the Class Diagram

In this section, you create the UML project (or UML project) and class diagram for the application. A UML project is the mechanism by which you store and manage a collection of files for a UML model. A UML model contains all of the model's diagrams, their associated elements, and metadata related to the UML model.

To create the UML project, choose File > New Project and then do the following:
1. Under Categories, select UML.
2. Under Projects, select Java-Platform Model.
3. Click Next.
The New Java-Platform Model dialog box opens.
In the Project Name field, type UMLPrj.
Notice that when you type the Project Name, the IDE automatically suggests this name for the name of the Project Folder.
Verify that the Project Location is MyPrj.
Click Finish.
The IDE creates the UML project and the Create New Diagram dialog box appears.
In the Diagram Type list, select Class Diagram.
In the Diagram Name field, type BankClassDiagram.
Leave UMLPrj in the Namespace field and click Finish.
The IDE does the following:
- Adds the UMLPrj project node in the Projects window.
- Creates a BankClassDiagram node under the Model node
- Displays the new diagram in the Diagram editor (the diagram is empty at this point)
- Opens the Modeling Palette

View Demo

top

Adding and Defining Class Elements

Now, add and define the class elements that will make up your Java application. You use the Class icon from the Modeling Palette to create the class elements.

From the Basic section of the Modeling Palette, select the Class icon and click in the Diagram editor.
This action places a class element on the Diagram editor.
Deselect the Class icon by right-clicking anywhere in the Diagram editor.
Select the newly added class element, type BankAccount and press Enter.
The IDE does the following:
- Labels the element BankAccount
- Creates a public operation, BankAccount()
- Displays the properties of the BankAccount class in the Properties window
With the BankAccount class element selected in the Diagram editor, right-click the word Attributes and choose Insert Attribute from the pop-up menu.
A one-line editor opens and displays the following information:
```
visibility type name[ranges]=initialValue{name=value}
```
Type balance and press Enter.
A private attribute named balance of type int appears on the BankAccount class. The following operations are created on the class:
- public int getBalance()
- public void setBalance(int val)
With the BankAccount class element still selected in the Diagram editor, right-click the word Operations and choose Insert Operation from the pop-up menu.
A one-line editor opens and displays the following information:
```
visibility returnType name(parameter) {properties...}
```
Type withdraw, move your cursor (use the forward arrow on your keyboard) into the parentheses, type int amount and press Enter.
The IDE adds the new operation in the class element as follows:
```
public void withdraw(int amount)
```

View Demo

top

Adding More Elements to the Diagram

In this section, you use more UML icons from the Modeling Palette to add interfaces, packages, attributes, and operations to your application.

From the Basic section of the Modeling Palette, select the Package icon .

Note: If necessary, scroll down to see the additional Modeling icons.
Click in the Diagram editor to add a package element to the class diagram.
Right-click anywhere in the Diagram editor to deselect the Package icon.

Note: As you add modeling elements to the diagram, you can select them and drag them to new locations in the Diagram editor to improve the appearance of the diagram. Be careful when you right-click, as in some positions, this action opens a pop-up menu for the Diagram editor. If this happens, just click again in the white space of the Diagram editor.
With the package element selected, type bankpack and press Enter.
From the Basic section of the Modeling Palette, select the Interface icon and click in the Diagram editor.
Right-click anywhere in the Diagram editor to deselect the Interface icon.
With the interface element selected, type Bank and press Enter.
Add a deposit operation to the Bank interface.
You add operations to interfaces the same way you add them to classes (Step 6 in the preceding section). Define the operation as follows:
```
public void deposit(int amount)
```
From the Modeling Palette, select the Class icon and click in the Diagram editor two times.
Right-click anywhere in the Diagram editor to deselect the Class icon.

Note: If you draw too many class elements, deselect the Class icon, then right-click the class element you want to delete and select Edit > Delete.
Name the class elements Checking and AccountTest and resize the elements if necessary.

View Demo

top

Identifying Associations Between Elements

In this section, you use the UML icons from the Modeling Palette to identify the association between class elements.

From the Basic section of the Modeling Palette, select the Implementation icon and click inside the BankAccount class element.
Click inside the Bank interface element and right-click anywhere in the Diagram editor to deselect the Implementation icon.
An implementation link appears between the class and the interface element. An implementation link denotes a relationship between a class and an interface.
From the Basic section of the Modeling Palette, select the Generalization icon .
Click inside the Checking class element (the subclass), then click inside the BankAccount class element (the superclass).
The Select Methods to Redefine dialog box appears.
Select the withdraw method and click OK.
The IDE does the following:
- Closes the dialog box
- Adds the withdraw method to the Checking class
- Adds the Generalization link between the two related Class elements
A generalization link shows the relationship between a subclass and its superclass. Subclasses are refinements of the superclass, meaning they can inherit features (attributes and operations) from the superclass.
Right-click in any white space in the Diagram editor to deselect the Generalization icon.
From the Basic section of the Modeling Palette, select the Nested Link icon and click inside the BankAccount element and then inside the bankpack package element.
Use the Nested Link icon as described in the prior step and connect the Checking, AccountTest, and Bank elements with the bankpack package.
Deselect the Nested Link icon.
A nested link denotes how elements are organized into groups. In this case, you organized all the class elements into a group in the bankpack package.
Press Ctrl-S anywhere in the Diagram editor to save the changes made to the model.

View Demo

top

Generating Java Source Code

In this section, using the Generate Code feature of UML you generate the Java source code for the UML model that you created in the previous sections.

In the Projects window, right-click the UMLPrj node and choose Generate Code from the pop-up menu.
The Generate Code dialog box appears. and specifies the Target Project.
Accept the default checkboxes in the Generate Code dialog box.
Click OK.
The IDE generates the code and the output window displays the progress of the code generation process.

View Demo

top

Continuing Development Using Reverse Engineering

In this section, you continue with your application development by modifying the generated source code in the Source editor and using the Reverse Engineer feature to update your UML model of your application.

In the Projects window, expand the UMLPrj > Model > bankpack node.
Right-click the BankAccount node and choose Navigate To Source from the pop-up menu.
Add the following code to the deposit method in the Source Editor:
```
setBalance(getBalance() + amount);
```
Under the UMLPrj > Model > bankpack node in the Projects window, right-click the AccountTest node and choose Navigate To Source from the pop-up menu.

Type (or copy and paste) the following code in the Source Editor:

public static void main(String[] args) {
Checking myChecking = new Checking();
myChecking.deposit(100);
System.out.println("Checking Balance is: " +
myChecking.getBalance() );
}

This code creates a new Checking object and specifies a deposit of $100, then prints the results.

Right-click in the Source Editor and choose Format Code.
Press Ctrl-S anywhere in the Source Editor to save the changes made to the AccountTest.java source file.
Right-click in the Source Editor again and choose Reverse Engineer from the pop-up menu. The Reverse Engineer dialog box appears.
Select Use Existing UML Project in the Reverse Engineer dialog box and choose UMLPrj as the target project.
Click OK to invoke the reverse engineering process.
The popup Model Element Overwrite Authorization dialog appears, requesting that you confirm your overwriting the AccountTest model element. Click Yes/ Yes to All.
Click the BankClassDiagram tab. Notice that the newly entered main method now appears in the AccountTest class element in the class diagram. By using the Reverse Engineer feature, the changes made to the Java source project can be reflected in the corresponding UML model project.

View Demo

top

Testing Your Work

Now build and run your project.

In the Projects window, right-click the JavaPrj node and choose Build from the pop-up menu.
In the Projects window, right-click the JavaPrj node and choose Run from the pop-up menu. The Run Project dialog box appears.
In the Run Project dialog box, click OK to select the bankpack.AccountTest as the main class. The IDE executes the application and displays the following output in the Output window:
```
Checking Balance is: 100
```

You have now completed the application.

View Demo

top

Summary

In this tutorial, you designed a class diagram for a simple banking application. You learned how to perform the following tasks:

Create a UML project
Use the UML icons from the Modeling Palette to create classes, interfaces, packages, attributes, and operations
Link the classes together with UML associations
View the elements that you created in the Diagram editor in the UML project as represented in the Projects window
Generate the source code for the elements created in the Diagram editor in the UML project and view the generated source in the Source Editor.
Use the Code Generation and reverse engineering features to go back and forth between modeling and developing code in the Source Editor
Compile and execute classes from the Source Editor

top

Next Steps

To learn more about the UML feature, complete the Reverse Engineering tutorial.

Getting Started With the NetBeans IDE BlueJ Plugin

2008-09-30T09:39:30-07:00

By Dana Nourie

BlueJ is an integrated development environment (IDE) specifically designed for teaching students object-oriented programming using the Java programming language. Although BlueJ covers the introductory phase of learning to program, the NetBeans IDE offers powerful tools for professional developers. Taking the inevitable step from one into the other has been a difficult barrier for students -- until now.

The collaboration of the NetBeans IDE and BlueJ teams has resulted in the NetBeans BlueJ plugin. This tool creates a smooth migration path for students learning the Java programming language from beginner's stage through to the use of professional development tools. In addition, this IDE provides a seamless path for students to switch from educational tools into a full-featured, professional IDE. The BlueJ plugin makes the transition between these two environments easier for students and teachers. Even if you are not familiar with BlueJ, the NetBeans BlueJ plugin is a great way to learn to use an IDE.

This article gets you started using the NetBeans BlueJ plugin. First, you'll discover how easy it is to load existing projects and edit them, and then you'll learn to create a new project and use drag-and-drop features to create a graphical user interface (GUI).

Developers unfamiliar with the BlueJ software will also learn everything they need to get started with this IDE and will benefit by following along with the examples.

To follow the descriptions and code examples, download the NetBeans IDE version 6.1 or later. In addition, download the BlueJ project Calculator.zip, which the first part of this article uses as an example. In the second part of the article, you create a small application called Address Book to learn various other IDE features.

Read the article . . .

*************

Learn about Sun Microsystems events in Second Life

*************

Discover resources for Student Developers

*************

Join developers and students in virtual learning

*************

Learning in Second Life

Welcome to the Mac Java Community

2008-09-18T10:12:48-07:00

This community is for all things Macintosh and Java related. That may mean developing Java code on the Mac, with the various tools available to Mac developers... or it may mean running your Java code on the Mac, using available technologies to deliver a great experience to your Mac-based users... or even tying into technologies like Cocoa. If you have Mac-specific projects, weblogs, questions, or advice, this is the place to be.

Here are some of the items you'll find on this Mac Java Community page:

Bye bye, Mac OS X?
If you follow my blog, you know that I've a bad attitude towards Apple's gear, even though (or just because?) I've been an Apple user for three years now. I've been frustrated by a) lack of support for Java updates, b) Mac OS X not performing as I need (Linux on the same hardware box is faster) and c) the scarce quality of my MacBook Pro (first generation). So, this week I can officially say that - at the moment - Mac OS X is no more my primary operating system. — Fabrizio Giudici

OpenJDK 7 for Mac OS X
Landon Fuller has announced that OpenJDK7 is now runnable on Mac OS X (and the BSDs) as part of the OpenJDK BSD Port project, culminating the efforts of his SoyLatte project to bring the latest open-source JDK to the Mac. "The move to OpenJDK -- and Sun's re-licensing of the code under the GPL license -- opens the project to any interested contributor." He suggests there's more work to do with JCK conformance testing, enabling dtrace support, PowerPC and ARM support via the Zero project, Core Audio-based sound support, and more. To facilitate user testing, Landon has also posted OpenJDK 7 binaries for Darwin (and, by extension, for Mac OS X).

Running VisualVM on MacOS X
The Aquarium points out a tip for Running VisualVM on MacOS X: "I wrote about VisualVM yesterday (entry) but I had missed Octavian's Introduction where he gives instructions on how to use VisualVM on MacOS X. As a reminder, to run the VisualVM client you need a recent JVM, so you will need to use the latest JVM from Apple, but the app can run in a variety of JVMs, remote or local to VisualVM. VisualVM can even save the data into a snapshot and process it offline."

Java SE 6 for Mac OS X 10.5.2
Available via Software Update, Java for Mac OS X 10.5 Update 1 adds Java SE 6 version 1.6.0_05 to your Mac. This version of Java is only for Mac OS X v10.5.2 and later, and only runs on 64-bit Intel machines. Developers may want to check out the release notes, which detail major new features including an API to work with the Dock icon (getting and setting the image, adding a badge, setting a dock menu, etc.), the ability to provide document-modal dialog sheets, support for Java DTrace probes, AppleScript as a supported language to the javax.script API, and more.

And there is a whole lot more. Visit Mac Java Community today!

****************************

Virtual Classrooms in Geeksville

Over the last few years I've been spending a lot of time online learning a whole lot of stuff. There is no better tool to teach us about computing, programming languages, and software than the computer itself. Of course, I realize it's not the computer but the site or the program, but virtual learning is hugely successful and for good reasons. And it's not limited to computer topics, thank goodness.[Read More]

Learning in Second Life

Second Life (SL) is easy to misunderstand, and many people have the wrong idea that it is some kind of game environment, or a place where people just chat and act silly. On the contrary, Second Life has many places of learning from Science Friday, to Buddhist meditations, to technical seminars[Read More]

A Personal Data Storage Application With Embedded Java DB

2008-09-05T09:57:49-07:00

by Patrick Keegan

Most of the tutorials I've run across talk about creating applications that connect with a database that is managed from a server. This is appropriate for most business applications. However, sometimes you might want to create a more portable application that carries its own data with it, such as an application in which a user manages personal data.

In this application, we will use NetBeans to create a simple desktop application to store info on your personal music collection. We will use Java DB, which has an embedded mode so that it can be packaged within the application. The application will also make use of the Beans Binding library and the Java Persistence API.

Setting Up the Database

First we will create a "connection". This isn't a connection to a real database but it gives us a place to create a database structure, which we can then use to generate application code.

In NetBeans, open the Services window and expand the Drivers node.
Right-click Java DB (Embedded) and choose Connect Using.
For Database URL, enter jdbc:derby:Recordings;create=true.
For User Name, enter APP.
Enter whatever you wish the password and click OK.

Now we need to generate the database structure. We will do so by executing an SQL script that defines a single table and its columns.

To generate the database structure:

In the Services window, scroll down to the jdbc:derby:Recordings;create=true node, right-click, and choose Execute Command.

Paste the following code into the editor.

create table "APP".RECORD
(
	ARTIST VARCHAR(30) NOT NULL,
	TITLE VARCHAR(30) NOT NULL PRIMARY KEY,
	FORMAT VARCHAR(30) NOT NULL,
	RATING INTEGER,
	CONDITION VARCHAR(10),
	COMMENTS VARCHAR(30)
)

Click the Run SQL button to execute the command.
Right-click the jdbc:derby:Recordings;create=true node and choose Refresh.
Expand the node and then expand the Tables node.

Creating the Application

With the database structure set up, we can now use the Java Desktop Application project template to create a basic CRUD application based on that structure.

Choose File | New Project.
In the wizard select the Java | Java Desktop Application template.
In the Name and Location page of the wizard, select the Database Application skeleton.
In the Master Table page of the wizard, select the connection for the Recordings database.
In the Detail Options page, click Finish.

Once you complete the wizard, you have a basic CRUD application that should be ready to build and run. Here is how the application looks in the Design view of the GUI Builder:

Building, Testing, and Distributing the Application

Before building and running, make sure that you have all of the necessary libraries by expanding the project's Libraries node.

You should see libraries for the Swing Application Framework, Beans Binding, TopLink (which contains classes from the Java Persistence API), and Derby (Java DB). Depending on your setup, it might happen that TopLink and Derby are not added. If those libraries are not listed, you need to add the libraries manually. The TopLink library is available within the IDE's list of libraries. You can get the Derby JAR file from an installation of JDK 6, Glassfish, or from a Java DB or Derby standalone installation.

To add the TopLink library:

Right-click the Libraries node and choose Add Library.
From the Available Libraries list, add TopLink Essentials.

To add derby.jar:

Right-click the Libraries node and choose Add JAR/Folder.
Navigate to your Derby/Java DB installation and select derby.jar. (I used the copy I found in C:\Program Files\glassfish-v2ur2\javadb\lib, but you might have it as part of your JDK.)

To build and test run the project:

Press F11 to build the project. (If this project is not your main project, right-click the project's node in the Projects window and choose Build.)
Press F6 to run the project in the IDE. (If this project is not your main project, right-click the project's node in the Projects window and choose Run.)
In the running application, add a few records and save them.

The database is created and saved in your project directory. You can glimpse the database files that were created in the test run by opening the Files window and expanding the node for your project.

You'll notice that there is a sub-folder called Recordings (based on the database name) which contains the database files.

Note: If you run the application directly from dist/Recordings.jar, the database once again will be empty. When you add records, the database files will be created in a location that depends conventions of your operating system. I run on Vista, and so my database files are created in the VirtualStore folder of my Windows user directory.

You can distribute the application by zipping up the project's dist folder and giving it to the user. The dist folder contains the application's main JAR file, Recordings.jar, and the lib folder. The lib folder contains various libraries essential for the project, including derby.jar, which contains pretty much all of Java DB (which is just 2.2 MB).

Once they unzip the file, they can run the Recordings.jar file, either by double-clicking it (if they have the .jar file extension associated with Java on their system) or by running it from the command line with the command java -jar Recordings.jar.

So there you have it - a portable database application with no hand coding.

Bonus Note on the Database Structure

For purposes of quickly showing how to use Java DB as an embedded db, I used and over-simplified database structure, especially regarding the primary key. So that you can you can have multiple entries for the same artist, you might want to create an auto-generated identity field and make that the primary key instead. For example:

create table "APP".RECORD
(
    ID INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY,
    ARTIST VARCHAR(30) NOT NULL,
    TITLE VARCHAR(30) NOT NULL PRIMARY KEY,
    FORMAT VARCHAR(30) NOT NULL,
    RATING INTEGER,
    CONDITION VARCHAR(10),
    COMMENTS VARCHAR(30)
);

ALTER TABLE "APP".RECORD
    ADD CONSTRAINT CONTACTS2008_PK Primary Key (ID);

Then after creating the project, you would need to modify the Recordings entity class by inserting the line @GeneratedValue(strategy=GenerationType.IDENTITY)@Id.

***********************

Learning in Second Life

******************

Virtual Classrooms in Geeksville

********************

Participate in MySQL-GlassFish Student Contest and Win $500

Use MySQL database and GlassFish application server to develop a web application and write a review for...

A chance to win a grand prize of $500 in Visa debit card, and
Five chances to win a prize of $250 in Visa debit card

Java SE Application Design With MVC

2008-08-27T12:44:26-07:00

By Robert Eckstein,

Contents

- What Is Model-View-Controller (MVC)?
- Interaction Between MVC Components
- Modifying the MVC Design
- Using the Modified MVC
- Issues With Application Design
- Common Swing Component Listeners
- Conclusion
- For More Information

What Is Model-View-Controller (MVC)?

If you've programmed with graphical user interface (GUI) libraries in the past 10 years or so, you have likely come across the model-view-controller (MVC) design. MVC was first introduced by Trygve Reenskaug, a Smalltalk developer at the Xerox Palo Alto Research Center in 1979, and helps to decouple data access and business logic from the manner in which it is displayed to the user. More precisely, MVC can be broken down into three elements:

Model - The model represents data and the rules that govern access to and updates of this data. In enterprise software, a model often serves as a software approximation of a real-world process.
View - The view renders the contents of a model. It specifies exactly how the model data should be presented. If the model data changes, the view must update its presentation as needed. This can be achieved by using a push model, in which the view registers itself with the model for change notifications, or a pull model, in which the view is responsible for calling the model when it needs to retrieve the most current data.
Controller - The controller translates the user's interactions with the view into actions that the model will perform. In a stand-alone GUI client, user interactions could be button clicks or menu selections, whereas in an enterprise web application, they appear as GET and POST HTTP requests. Depending on the context, a controller may also select a new view -- for example, a web page of results -- to present back to the user.

Although different architectures allow the three components to interact in different ways, Figure 1 shows a common implementation of the MVC design pattern, as shown in the Sun BluePrints Catalog.

Figure1. A Common MVC Implementation

Interaction Between MVC Components

This section will take a closer look at one way to implement Figure 1 in the context of an application in the Java Platform, Standard Edition 6 (Java SE 6). Once the model, view, and controller objects are instantiated, the following occurs:

The view registers as a listener on the model. Any changes to the underlying data of the model immediately result in a broadcast change notification, which the view receives. This is an example of the push model described earlier. Note that the model is not aware of the view or the controller -- it simply broadcasts change notifications to all interested listeners.
The controller is bound to the view. This typically means that any user actions that are performed on the view will invoke a registered listener method in the controller class.
The controller is given a reference to the underlying model.

Once a user interacts with the view, the following actions occur:

The view recognizes that a GUI action -- for example, pushing a button or dragging a scroll bar -- has occurred, using a listener method that is registered to be called when such an action occurs.
The view calls the appropriate method on the controller.
The controller accesses the model, possibly updating it in a way appropriate to the user's action.
If the model has been altered, it notifies interested listeners, such as the view, of the change. In some architectures, the controller may also be responsible for updating the view. This is common in Java technology-based enterprise applications.

Figure 2 shows this interaction in more detail.

Figure 2. A Java SE Application Using MVC

As this article mentioned earlier, the model does not carry a reference to the view but instead uses an event-notification model to notify interested parties of a change. One of the consequences of this powerful design is that the many views can have the same underlying model. When a change in the data model occurs, each view is notified by a property change event and can update itself accordingly. For example, Figure 3 shows two views that use the same data model.

Figure 3. Multiple Views Using the Same Model

Modifying the MVC Design

A more recent implementation of the MVC design places the controller between the model and the view. This design, which is common in the Apple Cocoa framework, is shown in Figure 4.

Figure 4. An MVC Design Placing the Controller Between the Model and the View

The primary difference between this design and the more traditional version of MVC is that the notifications of state changes in model objects are communicated to the view through the controller. Hence, the controller mediates the flow of data between model and view objects in both directions. View objects, as always, use the controller to translate user actions into property updates on the model. In addition, changes in model state are communicated to view objects through an application's controller objects.

Thus, when all three components are instantiated, the view and the model will both register with the controller. Once a user interacts with the view, the events are nearly identical:

The view recognizes that a GUI action -- for example, pushing a button or dragging a scroll bar -- has occurred, using a listener method that is registered to be called when such an action occurs.
The view calls the appropriate method on the controller.
The controller accesses the model, possibly updating it in a way appropriate to the user's action.
If the model has been altered, it notifies interested listeners of the change. However, in this case, the change is sent to the controller.

Why adopt this design? Using this modified MVC helps to more completely decouple the model from the view. In this case, the controller can dictate the model properties that it expects to find in one or more models registered with the controller. In addition, it can also provide the methods that effect the model's property changes for one or more views that are registered with it.

Using the Modified MVC

This section of the article shows you how to put this design into practice, starting with the model. Suppose that you want to paint some text using a simple display model with five properties. Code Sample 1 shows a simple component that you can use to create such a model.

Code Sample 1

public class TextElementModel extends AbstractModel
{

    private String text;
    private Font font;
    private Integer x;
    private Integer y;
    private Integer opacity;
    private Integer rotation;


    /**
     * Provides the means to set or reset the model to
     * a default state
     */
    public void initDefault() {

        setOpacity(89);
        setRotation(0);
        setText("Sample Text");
        setFont(new Font("Arial", Font.BOLD, 24));
        setX(50);
        setY(50);

    }

    //  Accessors


    public String getText() {
        return text;
    }

    public void setText(String text) {

        String oldText = this.text;
        this.text = text;

        firePropertyChange(
            DefaultController.ELEMENT_TEXT_PROPERTY,
            oldText, text);
    }

    public Font getFont() {
        return font;
    }

    public void setFont(Font font) {

        Font oldFont = this.font;
        this.font = font;

        firePropertyChange(
            DefaultController.ELEMENT_FONT_PROPERTY,
            oldFont, font);
    }

    //  The remaining accessors for properties are omitted.

}

Note that the rest of the accessors follow the standard JavaBeans model, although they are omitted in Code Sample 1. For reference, Code Sample 2 shows the underlying AbstractModel class, which simply uses the javax.beans.PropertyChangeSupport class to register, deregister, and notify interested listeners of changes to the model.

Code Sample 2

public abstract class AbstractModel
{

    protected PropertyChangeSupport propertyChangeSupport;

    public AbstractModel()
    {
        propertyChangeSupport = new PropertyChangeSupport(this);
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        propertyChangeSupport.addPropertyChangeListener(listener);
    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        propertyChangeSupport.removePropertyChangeListener(listener);
    }

    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
        propertyChangeSupport.firePropertyChange(propertyName, oldValue, newValue);
    }


}

The Controller

Between the model and view lies the controller. First, take a look at the code for the abstract controller superclass, as shown in Code Sample 3.

Code Sample 3

public abstract class AbstractController implements PropertyChangeListener {

    private ArrayList registeredViews;
    private ArrayList registeredModels;

    public AbstractController() {
        registeredViews = new ArrayList();
        registeredModels = new ArrayList();
    }


    public void addModel(AbstractModel model) {
        registeredModels.add(model);
        model.addPropertyChangeListener(this);
    }

    public void removeModel(AbstractModel model) {
        registeredModels.remove(model);
        model.removePropertyChangeListener(this);
    }

    public void addView(AbstractViewPanel view) {
        registeredViews.add(view);
    }

    public void removeView(AbstractViewPanel view) {
        registeredViews.remove(view);
    }


    //  Use this to observe property changes from registered models
    //  and propagate them on to all the views.


    public void propertyChange(PropertyChangeEvent evt) {

        for (AbstractViewPanel view: registeredViews) {
            view.modelPropertyChange(evt);
        }
    }


    /**
     * This is a convenience method that subclasses can call upon
     * to fire property changes back to the models. This method
     * uses reflection to inspect each of the model classes
     * to determine whether it is the owner of the property
     * in question. If it isn't, a NoSuchMethodException is thrown,
     * which the method ignores.
     *
     * @param propertyName = The name of the property.
     * @param newValue = An object that represents the new value
     * of the property.
     */
    protected void setModelProperty(String propertyName, Object newValue) {

        for (AbstractModel model: registeredModels) {
            try {

                Method method = model.getClass().
                    getMethod("set"+propertyName, new Class[] {
                                                      newValue.getClass()
                                                  }


                             );
                method.invoke(model, newValue);

            } catch (Exception ex) {
                //  Handle exception.
            }
        }
    }


}

The AbstractController class contains two ArrayList objects, which are used to keep track of the models and views that are registered. Note that whenever a model is registered, the controller also registers itself as a property change listener on the model. This way, whenever a model changes its state, the propertyChange() method is called and the controller will pass this event on to the appropriate views.

The final method, setModelProperty(), employs some magic to get its work done. In order to keep the models completely decoupled from the controller, the code samples in this article have employed the Java Reflection API. In this case, when this method is called with the desired property name, you hunt through the registered models to determine which one contains the appropriate method. Once you find it, you invoke the method using the new value. If the method is not called, the getMethod() will throw a NoSuchMethodException, which the exception handler ignores, allowing the for- loop to continue.

Code Sample 4 shows the source code for the default controller class. This class consists of only property constants and methods called by the GUI event listeners of the view.

Code Sample 4

public class DefaultController extends AbstractController
{

    public static final String ELEMENT_TEXT_PROPERTY = "Text";
    public static final String ELEMENT_FONT_PROPERTY = "Font";
    public static final String ELEMENT_X_PROPERTY = "X";
    public static final String ELEMENT_Y_PROPERTY = "Y";
    public static final String ELEMENT_OPACITY_PROPERTY = "Opacity";
    public static final String ELEMENT_ROTATION_PROPERTY = "Rotation";

    //  Code omitted

    public void changeElementText(String newText) {
        setModelProperty(ELEMENT_TEXT_PROPERTY, newText);
    }

    public void changeElementFont(Font newFont) {
        setModelProperty(ELEMENT_FONT_PROPERTY, newFont);
    }

    public void changeElementXPosition(int newX) {
        setModelProperty(ELEMENT_X_PROPERTY, newX);
    }

    public void changeElementYPosition(int newY) {
        setModelProperty(ELEMENT_Y_PROPERTY, newY);
    }

    public void changeElementOpacity(int newOpacity) {
        setModelProperty(ELEMENT_OPACITY_PROPERTY, newOpacity);
    }

    public void changeElementRotation(int newRotation) {
        setModelProperty(ELEMENT_ROTATION_PROPERTY, newRotation);
    }

}

The View

This example will have two views displaying the data from the model: a property-editor view and a graphical page view. Both of these are implementations of a JPanel, inserted into either a JDialog or JFrame. The dialog box allows the user to update the values of the model, and the frame panel simply reflects the changes as the final textual display. The author of this article built this example using the NetBeans Swing GUI Builder, formerly referred to as Project Matisse, to design the GUI forms.

Code Sample 5 shows the source code for the property-editor view, the more interesting of the two. The first section is simply devoted to initialization of the components, which for the most part was automatically generated by the NetBeans integrated development environment (IDE) in the initComponents() method. All of this section is omitted but is present in the downloadable code. Any other initialization that you need to perform -- in this case, creating custom models for JSpinner and JSlider objects or adding DocumentListeners to the JTextField components -- is handled in the localInitialization() method.

Code Sample 5

public PropertiesViewPanel(DefaultController controller) {

        this.controller = controller;

        initComponents();
        localInitialization();

    }

    // ‹editor-fold defaultstate="collapsed" desc=" Local Initialization "›

    /**
     * Used to provide local initialization of Swing components
     * outside of the NetBeans automatic code generator
     */
    public void localInitialization() {

        opacitySpinner.setModel(new SpinnerNumberModel(100, 0, 100, 1));
        opacitySlider.setModel(new DefaultBoundedRangeModel(100, 0, 0, 100));

        rotationSpinner.setModel(new SpinnerNumberModel(0, -180, 180, 1));
        rotationSlider.setModel(new DefaultBoundedRangeModel(0, 0, -180, 180));

        text.getDocument().addDocumentListener(new DocumentListener() {

            public void insertUpdate(DocumentEvent e) {
                textDocumentChanged(e);
            }

            public void removeUpdate(DocumentEvent e) {
                textDocumentChanged(e);
            }

            public void changedUpdate(DocumentEvent e) {
                textDocumentChanged(e);
            }

        });

    }

    // ‹/editor-fold›

Note that the automatically generated NetBeans IDE code folds in the source code so that the developer can collapse each of these sections when it is not needed:

// ‹editor-fold defaultstate="collapsed" desc=" Local Initialization "›
// ‹/editor-fold›

If you're using the NetBeans IDE, this practice is highly recommended.

The second section of the PropertiesViewPanel class deals exclusively with the model. In Code Sample 6, a modelPropertyChange() method is called by the controller whenever the model reports a state change.

Code Sample 6

// ‹editor-fold defaultstate="collapsed" desc=" Model Event Handling Code "›

    public void modelPropertyChange(final PropertyChangeEvent evt) {

        if (evt.getPropertyName().equals(
                   DefaultController.ELEMENT_X_PROPERTY)) {
            String newStringValue = evt.getNewValue().toString();
            xPositionTextField.setText(newStringValue);
        } else if
           (evt.getPropertyName().equals(
                   DefaultController.ELEMENT_Y_PROPERTY)) {
            String newStringValue = evt.getNewValue().toString();
            yPositionTextField.setText(newStringValue);
        } else if
           (evt.getPropertyName().equals(
                   DefaultController.ELEMENT_OPACITY_PROPERTY)) {
            int newIntegerValue = (Integer)evt.getNewValue();
            opacitySpinner.setValue(newIntegerValue);
            opacitySlider.setValue(newIntegerValue);
        } else if
            (evt.getPropertyName().equals(
                   DefaultController.ELEMENT_ROTATION_PROPERTY)) {
            int newIntegerValue = (Integer)evt.getNewValue();
            rotationSpinner.setValue(newIntegerValue);
            rotationSlider.setValue(newIntegerValue);
        } else if
           (evt.getPropertyName().equals(
                   DefaultController.ELEMENT_TEXT_PROPERTY)) {
            String newStringValue = evt.getNewValue().toString();
            text.setText(newStringValue);
        } else if
           (evt.getPropertyName().equals(
                   DefaultController.ELEMENT_FONT_PROPERTY)) {
            Font f = (Font)evt.getNewValue();
            String fontString = f.getFontName() + " " + f.getSize();
            font.setText(fontString);
            currentFont = f;
        }

        //  Remainder of the code omitted

    }

    // ‹/editor-fold›

Again, this code sample omits portions of the code that are similar to the sections shown.

The final portion consists of the GUI event listeners. Code Sample 7 contains listeners that are called whenever GUI events occur, such as pushing the Change Font button or the Opacity spinner buttons, or resetting the text in any of the text fields. These are largely event listeners that most Swing developers are already familiar with. If you're using the NetBeans IDE, you'll see that the IDE can automatically generate many of these using the GUI developer.

Code Sample 7

 // ‹editor-fold defaultstate="collapsed" desc=" GUI Event Handling Code "›

    //  Code omitted

    private void yPositionTextFieldFocusLost(java.awt.event.FocusEvent evt) {
        try {
            controller.changeElementYPosition(
                Integer.parseInt(yPositionTextField.getText()));
        } catch (Exception e) {
            //  Handle exception.
        }
    }

    private void yPositionTextFieldActionPerformed(java.awt.event.ActionEvent evt) {
        try {
            controller.changeElementYPosition(
                Integer.parseInt(yPositionTextField.getText()));
        } catch (Exception e) {
            //  Handle exception.
        }
    }

    //  Code omitted -- code for xPosition
    //  is nearly the same as for yPosition.

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

        JFontChooserDialog fontChooser = new
            JFontChooserDialog((Dialog)this.getTopLevelAncestor());
        fontChooser.setSelectedFont(currentFont);
        fontChooser.setVisible(true);

        Font returnedFont = fontChooser.getSelectedFont();
        if (returnedFont != null) {
            controller.changeElementFont(returnedFont);
        }
    }

    private void opacitySliderStateChanged(javax.swing.event.ChangeEvent evt) {
        controller.changeElementOpacity((int)opacitySlider.getValue());
    }

    private void rotationSliderStateChanged(javax.swing.event.ChangeEvent evt) {
        controller.changeElementRotation((int)rotationSlider.getValue());
    }

    private void opacitySpinnerStateChanged(javax.swing.event.ChangeEvent evt) {
        controller.changeElementOpacity((Integer)opacitySpinner.getValue());
    }

    private void rotationSpinnerStateChanged(javax.swing.event.ChangeEvent evt) {
        controller.changeElementRotation((Integer)rotationSpinner.getValue());
    }

    private void textDocumentChanged(DocumentEvent evt) {

        Document document = evt.getDocument();
        try {
            controller.changeElementText(document.getText(0,
            document.getLength()));
        } catch (BadLocationException ex) {
            //  Handle exception.
        }
    }

    // ‹/editor-fold›

Issues With Application Design

Once the application is up and running, you immediately run into a problem. Consider the following chain of events:

One of the Swing components in the view receives a change, presumably from the user action.
The appropriate controller method is called.
The model is updated. It notifies the controller of its property change.
The view receives a change event from the controller and attempts to reset the value of the appropriate Swing components.
The appropriate controller method is called, and the model is updated again.

At this point, any of three different scenarios can occur, depending on what Swing component you use and how robust your model is.

The Swing component that prompted the initial change refuses to update itself the second time, noting that its property state cannot be updated again while it is in the process of notifying listeners of the initial state change. This primarily occurs when you use Swing text components.
The model notes that the value of the second update matches that of the first, its current value, and refuses to send a change notification. This is always a safe programming practice, and it automatically occurs if you use the PropertyChangeSupport class provided in the java.beans package. However, it does not keep the model from receiving a redundant update.
No safeguards are in place on either the model or the Swing component, and the program enters an infinite loop.

This issue occurs because the Swing components are autonomous. For example, what happens if the user presses the up arrow of the JSpinner component in PropertiesViewPanel, incrementing the spinner's value by one? After the value is updated, a GUI event listener method that is listening for value changes is called, opacitySpinnerStateChanged(), which in turn calls the controller and then updates the appropriate property in the model.

With a traditional MVC design, the view would still contain the previous value, and the change in the model would update the view to the current value. However, there is no need to update the Swing component because it has already reset itself to the correct value -- it did so before it even passed an event to the controller.

How do you get around this? One way is to write a mechanism that tells the model or the controller not to propagate a change notification under these circumstances, but this is not a good idea. Remember that more than one view may be listening for changes on the model. If you shut down the change notification for the model, no other listeners, including other views, will be notified of the change. In addition, other components in the same view may rely on the property change notification, with a slider and spinner combination, for example.

Ideally, each Swing component would be aware of its current value and the value that the view is trying to set it to. If they match, no change notifications will be sent. However, some Swing components include this logic, and others do not. One possible solution is to check the incoming changed value of the model against the current value stored in the Swing component. If they are identical, there is no need to reset the value of the Swing component.

Code Sample 8 shows an update of the modelPropertyChange() method to demonstrate this approach.

Code Sample 8

public void modelPropertyChange(final PropertyChangeEvent evt) {

        if (evt.getPropertyName().equals(DefaultController.ELEMENT_X_PROPERTY)) {

            String newStringValue = evt.getNewValue().toString();
            if (!xPositionTextField.getText().equals(newStringValue))
                xPositionTextField.setText(newStringValue);

        }

        //  Remaining code omitted

    }

The final example, which uses two delegate views, is shown in Figure 5. The second delegate makes use of the Java 2D libraries to display the text, which is beyond the scope of this article. However, the source code is relatively easy to follow and is included in the downloadable source code.

Figure 5. Both Views Attached to a Single Model

Common Swing Component Listeners

As this article has shown throughout, part of the initialization of each delegate or controller requires you to subscribe to various Swing component events. However, individual Swing components can often generate multiple event types. Table 1 presents some common listener methods.

Table 1. Common Swing Event Listener Methods

Event to Monitor	Swing Event Listener Method

`JButton` pressed; `JCheckBox` pressed; `JRadioButton` pressed; `JToggleButton` toggled.	`JButton.addActionListener(java.awt.event.ActionListener)`
`JSpinner` value changed.	`JSpinner.addChangeListener(javax.swing.event.ChangeListener)`
`JTextField`, `JFormattedTextField`, `JPasswordField` or `JTextArea` character(s) are added, changed, or deleted.	`JTextField.getDocument().addDocumentListener(javax.swing.event.DocumentListener)`
`JTextField` return button is pressed, or focus switches to another component.	`JTextField.addActionListener(java.awt.event.ActionListener)`
`JComboBox` new entry is selected. from list.	`JComboBox.addActionListener(java.awt.event.ActionListener)`
`JComboBox` editor (typically a text field) characters are added, changed, or deleted.	`JTextField editor = ((JTextField)comboBox.getEditor().getEditorComponent());` `editor.getDocument().addDocumentListener(javax.swing.event.DocumentListener)`
`JComboBox` return button is pressed.	`JComboBox.addActionListener(java.awt.event.ActionListener)`
`JComboBox` pop-up menu is about to become visible, invisible, or be cancelled without a selection.	`JComboBox.addPopupMenuListener(javax.swing.event.PopupMenuListener)`
`JList` new entry is selected.	`JList.addListSelectionListener(javax.swing.event.ListSelectionListener)`
`JTabbedPane` new tab is selected.	`JTabbedPane.addChangeListener(javax.swing.event.ChangeListener)`
`JScrollBar` adjustment is made.	`JScrollBar.addAdjustmentListener(java.awt.event.AdjustmentListener)`
`JScrollPane` adjustment is made.	`JScrollPane.getHorizontalScrollBar().addAdjustmentListener(java.awt.event.AdjustmentListener)` `JScrollPane.getVerticalScrollBar().addAdjustmentListener(java.awt.event.AdjustmentListener)`
`JPopupMenu` is about to become visible, invisible, or be cancelled without a selection.	`JPopupMenu.addPopupMenuListener(javax.swing.event.PopupMenuListener)`
`JMenu` is about to be become visible or invisible, or be cancelled without a selection.	`JMenu.addMenuListener(javax.swing.event.MenuListener)`
`JMenuItem` (in standard or pop-up menu) is selected.	`JMenuItem.addActionListener(java.awt.event.ActionListener)`
`JSlider` value is changed.	`JSlider.addChangeListener(javax.swing.event.ChangeListener)`

Conclusion

MVC is one of the staples of any GUI programmer's toolkit. This article has shown how to implement a variation of the MVC design using Java SE and the Swing libraries. In addition, it has demonstrated some common issues that programmers may face when using MVC, as well as listed common Swing component events that any Java platform programmer can use when creating a view.

For More Information

You can download the example source code for this article here.
The original MVC implementation is described in the now-canonical paper Applications Programming in Smalltalk-80: How to Use Model-View-Controller .
Creating a GUI With Java Swing, also known as The Swing Tutorial, shows you how to get started using the Java Swing components.
A Swing Architecture Overview gives the inside story on how Swing uses a variant of MVC.
The page Java Blueprints for Model-View-Controller provides a good background on the problem space and various solutions, even though its target audience is developers using the Java EE platform.
"Applying the Model-View-Controller Design Paradigm in VisualAge for Java" is an excellent article by Scott Stanchfield that discusses some of common problems and solutions in using MVC with Java technology. A follow-up article, "Advanced Model-View-Controller Techniques," also points out some best practices to follow when populating models with data from underlying domain sources.
If you are curious as to how the textual portion of the Java 2D libraries work, take a look at this article.

Lesson: Java Web Start

2008-08-18T11:35:22-07:00

Java Web Start provides the power to launch full-featured applications with a single click. Users can download and launch applications, such as a complete spreadsheet program or an Internet chat client, without going through complicated installation procedures.

With Java Web Start, the user can launch a Java application by clicking a link in a Web page. The link points to a JNLP file, which instructs Java Web Start to download, cache and run the application.

Java Web Start provides Java developers and users with many deployment advantages:

With Java Web Start, you can place a single Java application on a Web server for deployment to a wide variety of platforms, including Windows 2003/Vista/2000/XP, Linux, and Solaris^TM
Java Web Start supports multiple, simultaneous versions of the Java Standard Edition platform. Specific applications can request specific Java versions without conflicting with the different needs of other applications. Java Web Start automatically downloads and installs the correct version of the Java platform as necessary based on the application's needs and the user's environment.
Users can launch a Java Web Start application independently of a Web browser. The user can be off-line, or unable to access the browser. Desktop shortcuts can also launch the application, providing the user with the same experience as a native application.
Java Web Start takes advantage of the inherent security of the Java platform. By default, applications have restricted access to local disk and network resources. Users can safely run applications from sources that are not trusted.
Applications launched with Java Web Start are cached locally, for improved performance.
Java Web Start provides limited support for applets through its built-in applet viewer. However, this is not intended to be a full- scale applet environment, such as the one provided by Java Plug-in. Java Web Start's applet viewer has certain limitations; for example, you cannot specify class files as resources, and it does not accept policy files.

In Java Version 1.4.2 and beyond, Java Web Start is installed as part of the JRE. Users do not have to install it separately or perform additional tasks to use Java Web Start applications.

Read the rest of this lesson . . .

Also see:

New to Java Programming Center

Young Developers

The Java Tutorial

Get Started with Java Programming in Facebook

******

Introducing NetBeans IDE 6.5 Beta! Development Simplified. Rapidly create web, enterprise, desktop, and mobile applications with Java, C/C++ , JavaScript, Ruby, Groovy, and now PHP.

******

Wombat Classes Basics (Young Developers Series, Part 2)

2008-08-12T13:35:16-07:00

By Dana Nourie, August 2008

Learn where Java code is written and saved, how classes relate to one another, and how to use the Greenfoot code editor.

In the Wombat Object Basics article, you learned what an object is, what methods are for, and a bit about the syntax that is used in code. In this article, you will learn where that code is written and saved, how classes relate to one another, and you'll learn to use the Greenfoot code editor. In addition, certain words in this article are linked, so you can learn more than is being taught here.

As in the last article, to follow along you will need:

The Java SE software installed on your computer
Greenfoot installed on your computer

This article is aimed at anyone interested in Java programming who is between the ages of 10-100 and has no programming experience. It is recommended that you have read and followed Wombat Object Basics before moving on in this article.

Where Is the Code?

Now that you understand that Java programs are made up of a lot of Java objects, and they interact through methods that provide the instructions for doing things, you are ready to learn about the code. Let's not waste any time.

Open Greenfoot. If the Wombats scenario is not already open, Click Scenario in the top menu, choose Open, select wombats, and then click Open.

At the top of the world area, right-click wombatWorld and select void populate(). By invoking that void populate() method, you should now see a few wombats and lots of leaves in your wombat world as shown in Figure 1.

Figure 1. Wombat World

Read the rest of this article . . .

Also see:

New to Java Programming Center

Young Developers

The Java Tutorial

Get Started with Java Programming in Facebook

Wombat Object Basics

2008-08-08T09:37:12-07:00

By Dana Nourie, August 2008

Java programming is easy to learn. All Java programs are made up of objects just like the world around you. And Java objects do things with each other like you do things with objects wherever you are.

This article explains what Java objects are and how they interact with each other. You will get familiar with some basic programming terminology as well. This article is aimed at anyone interested in Java programming who is between the ages of 10-100, and has no programming experience.

The best way to learn object basics is to look at a Java program. So, to follow along with this article, you will need the following:

The Java SE software must be installed on your computer
Greenfoot must be installed on your computer

Open Greenfoot and let's get started!

Getting to Know Wombats

Next, click on Scenario in the top menu, choose Open, select wombats, then click Open. You should see something like Figure 1 below:

Figure 1. Wombat Scenario

This program will be made up of several Java objects: World, wombatWorld, Actor, Wombat, Leaf.

Compare the Wombat World to the real world: We live on the object planet Earth. On the Earth object are Continent objects and Ocean objects. On the Continent objects, there are City objects, House objects, and People objects. And many more objects.

Read the rest of this article . . .

Learning Curve Journal, Part 1: Exploring JavaFX Script

2008-08-01T16:42:52-07:00

By John O'Conner, August 2007; revised and updated by Ed Ort, July 2008

JavaFX Script is a new scripting language that developers can use to create dynamic graphical content. On the desktop, the language provides libraries to help you use the Swing user interface (UI) toolkit and Java 2D APIs conveniently. It doesn't replace either Swing or Java 2D; the goal is to make those APIs more accessible to rich content developers. In other environments, such as mobile systems, JavaFX Script makes use of user interface technologies other than Swing. JavaFX Script enables you to write visually rich applications that run across platforms and operating environments.

The language provides both declarative and procedural syntax. You can declaratively create a rich user interface, and then you can add event-handling routines and operations.

However, most of us have to start more modestly, and that's the purpose of this article. Its goal is to show you how to get started with JavaFX Script. First, you'll need the following:

An up-to-date Java SE Development Kit (JDK)
Access to accurate, up-to-date information
The JavaFX Script plugin for your integrated development environment (IDE)

Setting Up the Java Platform

As a developer, you no doubt have a JDK on your system. However, if you haven't updated your system in a while, make sure you have Java SE 6. The Learning Curve Journal focuses on the compiler-based version of JavaFX Script and its support in NetBeans IDE 6.1. To install and use NetBeans IDE 6.1 with JavaFX technology, it is recommended that you install the latest level of Java SE 6 on your system, which currently is Java SE 6 Update 10 Beta. Download the latest JDK from the Java SE Downloads page of the Sun Developer Network. If you use Mac OS X, you can get Apple's latest release of the Java platform development kit, which currently is Java for Mac OS X 10.5, Update 1, directly from their Java section of the Apple Developer Connection.

Going to the Source

When you experiment with a new environment or language, you're going to hit dead ends and difficult places. That's part of the deal we all make when we adopt leading-edge technology. However, to smooth the learning curve, good documentation and examples are absolutely critical. Along with the JavaFX Technology hub of the Sun Developer Network, the javafx.com and Project OpenJFX web sites provide demo resources and the latest documentation you need to get accurate information.

Some of you will want to start programming immediately, barely reading a word of the language reference. Others of you will read everything you can before actually using JavaFX Script. Even if you're the type that dives in right away, you have to start with some sort of language specification or tutorial. Before you can scribble out the prototypical "Hello, world" example, you need to know some basic language syntax. The documents on the JavaFX Reference page are a good place to start. You can find links there to reference documents such as the The JavaFX Script Programming Language Reference as well as links to many articles and tutorials such as Getting Started With JavaFX Technology and Creating A Simple JavaFX Application Using NetBeans IDE.

Creating a JavaFX Application

After you've read at least some of the language reference document, it's time to build a simple JavaFX application. Although you can build and run a JavaFX application manually from a command line, let's do it using NetBeans IDE 6.1, which has many features designed to simplify developing applications. You will need to install the JavaFX plugin for NetBeans.

Read the rest of this tutorial . . .

********************************

Get Started with Java Programming!

Now Facebook users have a page to lead them to content that can help them learn Java programming. Log in to your Facebook account and Become a Fan of Get Started with Java Programming!

********************************

New to Java Programming Center

The New to Java Programming Center helps developers who are new to the Java platform find what they need to set up their system, understand the various technologies, and create applications for the desktop, web, and devices.

Young Developer Learning Path

2008-07-30T09:33:55-07:00

By Dana Nourie, July 2008

Learning the Java platform is an adventure. There is so much you can do with Java technologies. Yet, figuring out what you want to do and where to start is the first hurdle you need to clear. This article describes the tools you can use to learn Java programming. You decide which tool to start with based on what you currently know. After reading about the tools, you'll discover resources to learn about the technologies, and the details of the Java programming language.

Figure 1. Greenfoot Lunarlander

The adventure of learning the Java platform should be fun, clear, and exciting. Start with one of the tools listed below, work your way into the next tool, and include the resources as you feel ready. Before you know it, you'll be creating exciting Java applications.

Before You Begin

Before you read about the tools and resources, you need the Java Standard Edition (Java SE) for any of the tools listed below to work.

Download Java SE

Once Java SE is installed on your computer, you are ready to consider the various teaching tools.

Tools Overview

Which tool you decide to use depends on what you already know about programming, and specifically Java programming. All of the tools listed here are designed to show you programming visually instead of just a bunch of confusing lines of code. The tools demonstrate the relationships between objects (you'll learn about objects within the tools), and how to make those objects interact and do things. Yet, each tool has been designed with a certain audience in mind.

If you start with no programming experience and move from one tool to the next, the basic learning path is: Greenfoot > BlueJ > the NetBeans IDE BlueJ Edition, as shown in Figure 2:

Figure 2. Tools Learning Path

Many of you, however, may know some programming, or you may know a little of another programming language, or maybe you've taken a class or two but need greater understanding. The descriptions of each tool below will help you decide which tool is best for you based on where are you are starting on your learning path now.

The Learning Tools

Each of the tools helps you visualize what is happening when you create a program. They help you see the objects and interactions so you can better understand the abstract concepts. All are intended to help you learn Java programming in a fun, clear way.

Greenfoot [Download]

Greenfoot is aimed at high school level (13+), but that doesn't mean someone younger or older won't benefit from it. Basically, Greenfoot is aimed at school level programming. The emphasis is to get something exciting and fun on screen very quickly. It's an easy entry into programming, for people who want to see what programming is like. It's great for people who have had no prior interest in programming. Greenfoot is fun, it's exciting, and it generates interest because it's specialized for building graphical 2D applications. This makes what you create visually fun. It's intended to draw you in to programming. Once you're hooked, you can graduate on to BlueJ, and then later to the NetBeans IDE BlueJ Edition.

Download Quick Intro Tutorial

BlueJ [Download]

BlueJ is aimed more at intro university level. It assumes that you know that you are interested in learning programming, and you want to do it in an organized way. BlueJ is generic. It can be used to develop any kind of application. BlueJ teaches the fundamentals of objects, methods, and fields, and shows you visually the relationships between everything you create. You learn the nuts and bolts of the Java programming language, and can also see what is happening visually. Special emphasis is placed on visualization and interaction techniques to create a highly interactive environment that encourages experimentation and exploration.

BlueJ Supports:
	Fully Integrated Environment
	Graphical Class Structure Display
	Graphical and Textual Editing
	Built-in Editor, Compiler, Virtual Machine, Debugger, etc.
	Easy-to-use Interface, deal for beginners
	Interactive Object Creation
	Interactive Object Calls
	Interactive Testing
	Incremental Application Development

Download The BlueJ Tutorial

NetBeans IDE BlueJ Edition [Download]

BlueJ is an environment specifically aimed at beginning programmers. It offers educational tools, such as visualization and interaction facilities that greatly aid the learning of object-oriented concepts. While BlueJ covers the introductory phase of learning to program, and NetBeans offers powerful tools for professional developers, the inevitable step from one into the other has been a difficult barrier for students - until now.

This tool offers a seamless migration path for students that supports the switch from educational tools into a full-featured, professional IDE. The BlueJ plug-in adds two significant features to the NetBeans IDE:

It allows NetBeans to open, work with, and create BlueJ projects in the BlueJ-native format (without converting them to-and-from the NetBeans IDE standard projects), so that you can do some of your work in the NetBeans IDE,and some back in BlueJ, wherever you feel comfortable working.
It adds a BlueJ View tab to the NetBeans Project Window, which gives a familiar view of your BlueJ projects.

Download The Netbeans BlueJ Plug-in Tutorial

An extended tutorial by Dana Nourie.
A video on NetBeans/BlueJ from the Sun Developer Network.
A set of Lab Notes to help in the transition from BlueJ, and show a few of the facilities that the NetBeans IDE offers to programmers.
If you really want to see how far you can take the Zuul-for-NetBeans project, check out Brian Leonard's excellent Zuul everywhere tutorial.

Tutorials for Learning the Java Programming Language

Once you are using BlueJ or the NetBeans BlueJ Edition, you'll also need to learn the basics of the Java programming language. Your best resource for this is The Java Tutorial. Don't let these online tutorials overwhelm you. Take it little by little as you work through projects in the tool you are using. The Java Tutorial teaches the syntax of the Java programming language as well as how to use the thousands of classes available to you.

Bookmark the New to Java Programming Center. Articles and tutorials posted in the center are aimed at learning developers, and are updated often. The level of programming covered varies from beginning to intermediate. The Learning Tab in the center also has a list of articles and tutorials to get you started that should be helpful in the beginning of your learning path. Young Developers is designed specifically for people 13 years old and up.

Additionally, you can subscribe to Java Technology Fundamentals through convenient RSS feeds. Articles aimed at beginners to intermediate programmers go out in the feed several times a month. Some of these are articles that were published on java.sun.com, some are lessons from the Java Tutorial, and some are specifically written for Java Technology Fundamentals and the New to Java Programming Center. All are designed to help you learn the Java platform.

If you have a Facebook account, be sure to Become a Fan of the Getting Started with Java Programming page and visit it regularly, as new content is added automatically through RSS feeds.

When your programming skills are more intermediate, then also consider subscribing to Core Tech Tips. Like Java Technology Fundamentals, Core Tech Tips go out several times a month, but these programming tips are aimed at intermediate to advanced Java developers.

Summary

Choose your learning tool, use the resources, start programming, and have fun!

Creating a Custom Java Desktop Database Application

2008-07-28T09:23:32-07:00

This tutorial guides you through the creation of a complete desktop database application that enables its user to browse and edit customer records and purchase history. The resulting application includes the following main features:

A main view that enables users to browse customer records and customer purchases.
A search field for the customer records.
Separate dialog boxes for entering new records or modifying existing records.
Code to interact with multiple related database tables.

Contents

To follow this tutorial, you need the following software and resources.

Software or Resource	Version Required
NetBeans IDE	Version 6.1
Java Development Kit (JDK)	Version 6 or version 5
SQL script to create the database tables
zip file of utility classes

Note: You can download the final working project created in this tutorial at any time and open it in the IDE to view the classes. If you want to run the downloaded project, be sure to clean and build it before running.

Introduction

This application takes advantage of the following technologies:

The Java Persistence API (JPA), which helps you interact with a database using Java code.
Beans Binding, which enables you to keep Swing component properties synchronized.
The Swing Application Framework, which simplifies basic application functions such as persisting session information, handling actions, and managing resources.

The tutorial makes use of IDE wizards and other code generation features to provide much of the boilerplate code. It also shows you how to customize the generated code and hand code other parts of the application.

This tutorial takes approximately 2 hours to complete. For a shorter tutorial that shows the creation of a less customized user interface, see Building a Java Desktop Database Application.

Below is a screenshot of the working application that you will have when you complete the tutorial.

Setting Up the Database

Before creating any application code, we will set up the database. We will then be able to take advantage of wizards that generate much of the application code based on the structure of the database.

The instructions in this tutorial are based using a MySQL database that you create with this SQL script.

Note: You can use other database management software, but doing so might require making some adjustments to the SQL script. In addition, you will need to create the database from outside of the IDE.

To set up the IDE to work with MySQL databases, see the Connecting to a MySQL Database page.

To create the database:

In the Services window, right-click the MySQL Server node and choose Start.
Right-click the MySQL Server node and choose Create Database.
If the Create Database item isn't enabled, choose Connect. You might then need to enter a password. The Create Database item should then be enabled.
For Database Name, type MyBusinessRecords and click OK.
In the New Database Connection dialog, type nbuser as the password and click OK.
If the Advanced tab of the dialog box opens, click OK to close the dialog box.
Scroll down to the node for connection that you have just created. The node should have the icon.
Right-click the connection node and choose Execute Command.
Copy the contents of the MyBusinessRecords SQL script and paste them into the SQL Command 1 tab of the Source Editor.
Click the Run SQL button ()in the toolbar of the Source Editor to run the script.
Output of the script should appear in the Output window.
Right-click the connection node again and choose refresh.
Expand the node, and expand its Tables subnode.
You should see four database tables listed.

The database structure was designed with normalization and referential integrity in mind. Here are some notes on the structure:

The data is split among several tables to reduce duplication and the possibility for inconsistencies. Some tables are connected to each other through foreign keys.
All of the tables use MySQL's AUTO_INCREMENT attribute so that there is a unique identifier for each row in those tables. This identifier is created by the database management software, so your application and/or your application's user do not have to create this identifier. (For AUTO_INCREMENT to work properly within the application, you need to add the @GeneratedValue(strategy=GenerationType.IDENTITY annotation for that column in the table's entity class. Otherwise, the application does not try to submit a value for that column when you create a new record.)
The foreign key in the ORDERS table is there to link each order record with a customer. In the application's user interface, ORDER records are only displayed for the selected CUSTOMER.
The ON CASCADE DELETE attribute for the foreign key to the CUSTOMERS class ensures that a customer's orders are also deleted when a customer is deleted.
The foreign key in the CUSTOMERS table points to a COUNTRIES table. We will use this relationship in the application to enable the user to select a customer's country from a combo box.
The ORDERS table has a foreign key to the PRODUCTS table. When adding a new order record, the user will be able to choose a product from a combo box.
The COUNTRIES and PRODUCTS tables are pre-populated with data so that you can choose from those tables when the user of the application is adding customer and order records.
Though this tutorial does not cover it, you might find it useful to create separate applications to populate the COUNTRIES and PRODUCTS tables. Such applications could be created with the Java Desktop Application project template and would not require additional hand-coding.

Creating the Application Skeleton

We will use the IDE's Java Desktop Application project template to create much of the base code for the application. This template generates code for the following features:

Connection to the database.
A main application frame that contains tables for customer details and customer orders.
A main application class that handles basic application life-cycle functions, including persisting of window state between sessions and resource injection.
Actions (and corresponding buttons) for standard database application commands.

Read the rest of this tutorial.

For general tips and tricks on using the GUI Builder in NetBeans IDE, see the GUI Editor FAQ and Patrick Keegan's web log.

*******************

Get Started with Java Programming!

Now Facebook users have a page to lead them to content that can help them learn Java programming. Log in to your Facebook account and Become a Fan of Get Started with Java Programming!

Lesson: Interfaces

2008-07-21T09:59:54-07:00

The core collection interfaces encapsulate different types of collections, which are shown in the figure below. These interfaces allow collections to be manipulated independently of the details of their representation. Core collection interfaces are the foundation of the Java Collections Framework. As you can see in the following figure, the core collection interfaces form a hierarchy.
blogs.sun.com: New Entry

The core collection interfaces.
A Set is a special kind of Collection, a SortedSet is a special kind of Set, and so forth. Note also that the hierarchy consists of two distinct trees — a Map is not a true Collection.
Note that all the core collection interfaces are generic. For example, this is the declaration of the Collection interface.
public interface Collection<E>...
The <E> syntax tells you that the interface is generic. When you declare a Collection instance you can and should specify the type of object contained in the collection. Specifying the type allows the compiler to verify (at compile-time) that the type of object you put into the collection is correct, thus reducing errors at runtime. For information on generic types, see the Generics lesson.

When you understand how to use these interfaces, you will know most of what there is to know about the Java Collections Framework. This chapter discusses general guidelines for effective use of the interfaces, including when to use which interface. You'll also learn programming idioms for each interface to help you get the most out of it.

To keep the number of core collection interfaces manageable, the Java platform doesn't provide separate interfaces for each variant of each collection type. (Such variants might include immutable, fixed-size, and append-only.) Instead, the modification operations in each interface are designated optional — a given implementation may elect not to support all operations. If an unsupported operation is invoked, a collection throws an UnsupportedOperationException. Implementations are responsible for documenting which of the optional operations they support. All of the Java platform's general-purpose implementations support all of the optional operations.

The following list describes the core collection interfaces:

Collection — the root of the collection hierarchy. A collection represents a group of objects known as its elements. The Collection interface is the least common denominator that all collections implement and is used to pass collections around and to manipulate them when maximum generality is desired. Some types of collections allow duplicate elements, and others do not. Some are ordered and others are unordered. The Java platform doesn't provide any direct implementations of this interface but provides implementations of more specific subinterfaces, such as Set and List. Also see The Collection Interface section.

Set — a collection that cannot contain duplicate elements. This interface models the mathematical set abstraction and is used to represent sets, such as the cards comprising a poker hand, the courses making up a student's schedule, or the processes running on a machine. See also The Set Interface section.

List — an ordered collection (sometimes called a sequence). Lists can contain duplicate elements. The user of a List generally has precise control over where in the list each element is inserted and can access elements by their integer index (position). If you've used Vector, you're familiar with the general flavor of List. Also see The List Interface section.

Queue — a collection used to hold multiple elements prior to processing. Besides basic Collection operations, a Queue provides additional insertion, extraction, and inspection operations.
Queues typically, but do not necessarily, order elements in a FIFO (first-in, first-out) manner. Among the exceptions are priority queues, which order elements according to a supplied comparator or the elements' natural ordering. Whatever the ordering used, the head of the queue is the element that would be removed by a call to remove or poll. In a FIFO queue, all new elements are inserted at the tail of the queue. Other kinds of queues may use different placement rules. Every Queue implementation must specify its ordering properties. Also see The Queue Interface section.

Map — an object that maps keys to values. A Map cannot contain duplicate keys; each key can map to at most one value. If you've used Hashtable, you're already familiar with the basics of Map. Also see The Map Interface section.

The last two core collection interfaces are merely sorted versions of Set and Map:

SortedSet — a Set that maintains its elements in ascending order. Several additional operations are provided to take advantage of the ordering. Sorted sets are used for naturally ordered sets, such as word lists and membership rolls. Also see The SortedSet Interface section.

SortedMap — a Map that maintains its mappings in ascending key order. This is the Map analog of SortedSet. Sorted maps are used for naturally ordered collections of key/value pairs, such as dictionaries and telephone directories. Also see The SortedMap Interface section.

To understand how the sorted interfaces maintain the order of their elements, see the Object Ordering section.

« Previous • Trail • Next »

*******************

Get Started with Java Programming!

Now Facebook users have a page to lead them to content that can help them learn Java programming. Log in to your Facebook account and Become a Fan of Get Started with Java Programming!

How to Use Actions

2008-07-09T09:38:10-07:00

An Action can be used to separate functionality and state from a component. For example, if you have two or more components that perform the same function, consider using an Action object to implement the function. An Action object is an action listener that provides not only action-event handling, but also centralized handling of the state of action-event-firing components such as tool bar buttons, menu items, common buttons, and text fields. The state that an action can handle includes text, icon, mnemonic, enabled, and selected status.

You typically attach an action to a component using the setAction method. Here's what happens when setAction is invoked on a component:

The component's state is updated to match the state of the Action. For example, if the Action's text and icon values were set, the component's text and icon are set to those values.

The Action object is registered as an action listener on the component.

If the state of the Action changes, the component's state is updated to match the Action. For example, if you change the enabled status of the action, all components it's attached to change their enabled states to match the action.

Here's an example of creating a tool-bar button and menu item that perform the same function:
Action leftAction = new LeftAction(); //LeftAction code is shown later
...
button = new JButton(leftAction)
...
menuItem = new JMenuItem(leftAction);
To create an Action object, you generally create a subclass of AbstractAction and then instantiate it. In your subclass, you must implement the actionPerformed method to react appropriately when the action event occurs. Here's an example of creating and instantiating an AbstractAction subclass:
leftAction = new LeftAction("Go left", anIcon,
             "This is the left button.",
             new Integer(KeyEvent.VK_L));
...
class LeftAction extends AbstractAction {
    public LeftAction(String text, ImageIcon icon,
                      String desc, Integer mnemonic) {
        super(text, icon);
        putValue(SHORT_DESCRIPTION, desc);
        putValue(MNEMONIC_KEY, mnemonic);
    }
    public void actionPerformed(ActionEvent e) {
        displayResult("Action for first button/menu item", e);
    }
}
When the action created by the preceding code is attached to a button and a menu item, the button and menu item display the text and icon associated with the action. The L character is used for mnemonics on the button and menu item, and their tool-tip text is set to the SHORT_DESCRIPTION string followed by a representation of the mnemonic key.

For example, we have provided a simple example, ActionDemo.java, which defines three actions. Each action is attached to a button and a menu item. Thanks to the mnemonic values set for each button's action, the key sequence Alt-L activates the left button, Alt-M the middle button, and Alt-R the right button. The tool tip for the left button displays This is the left button. Alt-L. All of this configuration occurs automatically, without the program making explicit calls to set the mnemonic or tool-tip text. As we'll show later, the program does make calls to set the button text, but only to avoid using the values already set by the actions.

Try this:

Click the Launch button to run ActionDemo using Java™ Web Start (download JDK 6). Or, to compile and run the example yourself, consult the example index.

Choose the top item from the left menu (Menu > Go left).
The text area displays some text identifying both the event source and the action listener that received the event.

Click the leftmost button in the tool bar.
The text area again displays information about the event. Note that although the source of the events is different, both events were detected by the same action listener: the Action object attached to the components.

Choose the top item from the Action State menu.
This disables the "Go left" Action object, which in turn disables its associated menu item and button.

Here is what the user sees when the "Go left" action is disabled:

Here's the code that disables the "Go left" action:
boolean selected = ...//true if the action should be enabled;
                      //false, otherwise
leftAction.setEnabled(selected);
After you create components using an Action, you might well need to customize them. For example, you might want to customize the appearance of one of the components by adding or deleting the icon or text. For example, ActionDemo.java has no icons in its menus, and no text in its buttons. Here's the code that accomplishes this:
menuItem = new JMenuItem();
menuItem.setAction(leftAction);
menuItem.setIcon(null); //arbitrarily chose not to use icon in menu
...
button = new JButton();
button.setAction(leftAction);
button.setText(""); //an icon-only button
We chose to create an icon-only button and a text-only menu item from the same action by setting the icon property to null and the text to an empty string. However, if a property of the Action changes, the widget may try to reset the icon and text from the Action again.

The Action API

The following tables list the commonly used Action constructors and methods. The API for using Action objects falls into three categories:

Components that Support set/getAction

Creating and Using an AbstractAction

Action Properties

Components that Support set/getAction

Class Purpose

AbstractButton
JComboBox
JTextField These components and their subclasses may have an action directly assigned to them via setAction. For further information about components that are often associated with actions, see the sections on tool bar buttons, menu items, common buttons, and text fields. For details on which properties each component takes from the Action, see the API documentation for the relevant class's configurePropertiesFromAction method. Also refer to the buttonActions table.

Creating and Using an AbstractAction

Constructor or Method Purpose

AbstractAction()
AbstractAction(String)
AbstractAction(String, Icon) Create an Action object. Through arguments, you can specify the text and icon to be used in the components that the action is attached to.

void setEnabled(boolean)
boolean isEnabled() Set or get whether the components the action controls are enabled. Invoking setEnabled(false) disables all the components that the action controls. Similarly, invoking setEnabled(true) enables the action's components.

void putValue(String, Object)
Object getValue(String) Set or get an object associated with a specified key. Used for setting and getting properties associated with an action.

Action Properties

This table defines the properties that can be set on an action. The second column lists which components automatically use the properties (and what method is specifically called). For example, setting the ACCELERATOR_KEY on an action that is then attached to a menu item, means that JMenuItem.setAccelerator(KeyStroke) is called automatically.

Property Auto-Applied to:
Class
(Method Called) Purpose

ACCELERATOR_KEY JMenuItem
(setAccelerator) The KeyStroke to be used as the accelerator for the action. For a discussion of accelerators versus mnemonics, see Enabling Keyboard Operation. Introduced in 1.3.

ACTION_COMMAND_KEY AbstractButton, JCheckBox, JRadioButton
(setActionCommand) The command string associated with the ActionEvent.

LONG_DESCRIPTION None The longer description for the action. Can be used for context-sensitive help.

MNEMONIC_KEY AbstractButton, JMenuItem, JCheckBox, JRadioButton
(setMnemonic) The mnemonic for the action. For a discussion of accelerators versus mnemonics, see Enabling Keyboard Operation. Introduced in 1.3.

NAME AbstractButton, JMenuItem, JCheckBox, JRadioButton
(setText) The name of the action. You can set this property when creating the action using the AbstractAction(String) or AbstractAction(String, Icon) constructors.

SHORT_DESCRIPTION AbstractButton, JCheckBox, JRadioButton
(setToolTipText) The short description of the action.

SMALL_ICON AbstractButton, JMenuItem
(setIcon) The icon for the action used in the tool bar or on a button. You can set this property when creating the action using the AbstractAction(name, icon) constructor.

Examples that Use Actions

The following examples use Action objects.

Example	Where Described	Notes
`ActionDemo`	This section	Uses actions to bind buttons and menu items to the same function.
`TextComponentDemo`	Text Component Features	Uses text actions to create menu items for text editing commands, such as cut, copy, and paste, and to bind key strokes to caret movement. Also implements custom `AbstractAction` subclasses to implement undo and redo. The text action discussion begins in Concepts: About Editor Kits.



		From the Java Tutorial

Java University and Sun Training Library

2008-07-01T13:10:40-07:00

Java University Online

We understand you're busy and may not have been able to attend Java University at JavaOne. So, Sun is bringing the same Java University technical sessions led by the same Leading Sun Technical Experts directly to you. These convenient online sessions provide you training on the latest advancements in Sun and related technologies to help you advance your business.

Get your Free iPod Touch

Java Technology CD-ROM Training

Learning the Java Programming Language CD Library (CDLJ-100)
Enterprise Java Application Developer CD Library (CDLJ-200)
Java Complete Learning CD Library (CDLJ-300)

» Purchase Now

Using Beans Binding to Search in a Table

2008-06-25T10:36:53-07:00

by Patrick Keegan

Now and again someone will ask me how you can search records in a desktop database app. Here's a reasonably simple way to do so, using mechanisms that exist in Swing and the Beans Binding library. We will create a binding between the rowSorter property of the master table in the example in my previous entries and a text field that I've just added for the search string. For this binding we will need a binding converter so that the table knows how to respond to the search string.

To follow along, you can either continue with the project created in previous entries or begin with a new NetBeans project (Java Desktop Application project template) that connects to a database.

Let's get started. First of all, we'll add a label and a text field for the search field as shown below.

Now we will add a converter class to the project.

Create a new Java class in your project. Call it RowSorterToStringConverter.

Replace the generated code in the new class with the following code:

package clientpurchaseapp;

import javax.swing.JTable;
import javax.swing.RowFilter;
import javax.swing.table.TableRowSorter;
import org.jdesktop.beansbinding.Converter;

/**
 * Binding converter between String and regex RowFilter (encapsulated by RowSorterToStringConverter).
 *  */
public class RowSorterToStringConverter extends Converter {

    private JTable table;

    public JTable getTable() {
        return table;
    }

    public void setTable(JTable table) {
        this.table = table;
    }

    @Override
    public Object convertForward(Object value) {
        return value.toString();
    }

    @Override
    public Object convertReverse(Object mask) {
        TableRowSorter sorter = new TableRowSorter(table.getModel());

        // The following statement makes the filter case-sensitive. If you want 
        //filter to work in a case-insensitive way, uncomment the line below, comment 
        //the 7 code lines below
        //sorter.setRowFilter(RowFilter.regexFilter(".*" + mask + ".*"));

        //The following 7 lines create a case-insensitive filter. If you want 
        //the filter to be case-sensitive, comment them out and uncomment the 
        //line above
        String m = mask.toString();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < m.length(); i++) {
            char c = m.charAt(i);
            sb.append('[').append(Character.toLowerCase(c)).append(Character.toUpperCase(c)).append(']');
        }
        sorter.setRowFilter(RowFilter.regexFilter(".*" + sb + ".*"));
        return sorter;
    }
}

Adjust the package statement, if necessary.
Save the file and compile it. Compiling the file enables you to treat it as a bean that you can add to the form by dragging and dropping from within the IDE's GUI builder.
Drag the class from the Projects window and drop it in white area surrounding the form, as shown in the screenshot below.
A node called rowSorterToStringConverter1 should appear in the Inspector window.
Select the rowSorterToStringConverter1 node and set its table property to masterTable.

We'll use this converter when we create the binding.

To create the binding:

In the main form, right-click the text field and choose Bind | text.
In the Bind dialog, select masterTable as the binding source and rowSorter as the expression.
Click the Advanced tab of the dialog box.
From the Converter combo box, select rowSorterToStringConverter1.
Click OK to close the dialog and generate the binding code.

Now when you run the application, you should be able to type in the Search Filter field and see that the list of rows is reduced to only rows that contain text matching what you have typed.

Note: If you have been following this whole series of posts, you will need to make a few changes to get the New Record and Edit Record buttons to work correctly. The Edit Record button doesn't work correctly because the number of the record to display is determined according to the records displayed but applied to the whole list of records in the database. In other words, if you select the first record in a filtered list, the first record of the whole database appears for editing in the dialog.

The New Record button fails with an exception because the code to select the new row is determined according to number of records in the database table, not according to the number of records currently displayed in the table.

To fix the first problem, replace the line:

ec.setCurrentRecord(list.get(masterTable.getSelectedRow()));

with:

ec.setCurrentRecord(list.get(masterTable.convertRowIndexToModel(masterTable.getSelectedRow())));

To fix the second problem, replace the line:

int row = list.size() - 1;

with:

int row = masterTable.getRowCount() - 1;

Read the other blogs in this series.

Passing Dialog Input to the Main View and Database

2008-06-17T09:57:13-07:00

by Patrick Keegan

This is the fourth in a series of posts on creating a Java database application. In my last few posts, I started with skeleton code generated by the IDE and provided my own customizations, including adding a dialog to use for data entry and binding those fields with a table on the main form. In this post, I finish coding the connection between the dialog and the main form. I'll also add an Edit Client button and its corresponding Action code to the main form.

First let's hook up the buttons in the EditClient dialog with appropriate event-handling code. We already have save() and refresh() actions that are provided with the skeleton application. We will code the dialog so that the buttons reuse these actions. We can accomplish this by setting up a boolean property in the dialog that returns true when the Save Record button is pushed and returns false when Cancel is selected. Based on the value that is returned when the dialog is closed, the the save() or the refresh() action will be run from the main view class.

To set up the property, do the following:

Open up the EditClient file and select the Source view.
Place the cursor somewhere below the block of generated code that contains the initComponents() method.
Press Alt-Insert and choose Add Property.
In the Add Property dialog, type clientConfirmed as the property name.
Set the type to boolean.
Make sure the Generate Getters and Setters checkbox is selected.
Click OK to close the dialog box and generate the code.

We'll set this property's value in event handling code for the buttons. Let's create the event listeners and handlers now:

Switch to the Design view for the EditClient class.
Select the Save button in the EditClient form.
In the Properties window, click the Events button.
Click the ellipsis (...) button next to the actionPerformed property.
In the Handlers for actionPerformed dialog box, add a handler called saveNewClient.
Within the saveNewClient method in the Source Editor (where the cursor jumps after you create the new handler), type the following code:
```
setClientConfirmed(true);
setVisible(false);
```
Repeat steps 2-5 for the Cancel button and call its handler cancelNewClient.
In the cancelNewRecord method, type the following:
```
setClientConfirmed(false);
setVisible(false);
```

Navigate to the newRecord() method and add the following code to the bottom of the method:

        if (ec.isClientConfirmed()) {
            save().run();
        } else {
            refresh().run();
        }

In the RefreshTask inner class, Thread.sleep is called four times to slow down the rollback code to better demonstrate how Swing Application Framework tasks work. We don't need this code for this application, so delete those four statements. Similarly, we don't need a try/catch block here, so delete the try and catch statements as well (but leave the rest of the body of the try block).

Since the save() and refresh() actions act on any changes made during the application's session, we will want to make the dialog modal and make the tables in the main form uneditable. We also need to make the dialog modal so that when the user presses either the Save or Cancel button, the setVisible() method doesn't return until the event handler (which includes the setClientConfirmed method) has run.

To make the dialog modal:

Open the Design view of the EditClient class.
Select the dialog.
In the Properties window, click Properties and select the checkbox for the modal property.

To make the main form's Clients table uneditable:

Open the main view class in the Source Editor and select the Design view.
Right-click the top table and choose Table Contents.
In the Customizer dialog, select the Columns tab.
For each column, clear the Editable checkbox.
Click Close.

You can now run the application and click New Client to add a new record. When you press Save in the New Client dialog, the record is saved. When you press Cancel, the new record you have changed is rolled back.

This is all well and good, but by disabling the editability of the table on the main form, we can no longer edit existing records. To solve this, we'll add an Edit button to the main client form so that we can edit existing records. For event-handling, we'll take advantage of the Swing Application Framework's Action facility.

To add the button and its corresponding event-handling code, do the following:

Drag the New Client Button a bit to the left.
Drag a button from the palette into the opening just created.
Right-click the button and choose Set Action.
In the Action field, select Create New Action.
For Action Method, type editClient.
For Text, type Edit Client.
Click the Advanced Tab and select recordSelected for the Enabled Property.
This generates an annotation attribute to ensure that the button and any other trigger for the action (e.g. a menu item) are only enabled when a record is selected.
Click OK to close the dialog box.
The Source view of the file should appear with the cursor in the following new method:
```
    @Action(enabledProperty = "recordSelected")
    public void editClient() {
    }
```

Within the method, paste the following code:

        setSaveNeeded(true);
        JFrame mainFrame = ClientAndPurchaseApp.getApplication().getMainFrame();
        EditClient ec = new EditClient(mainFrame, false);
        ec.setCurrentRecord(list.get(masterTable.getSelectedRow()));
        ec.setVisible(true);
        if (ec.isClientConfirmed()) {
            save().run();
        } else {
            refresh().run();
        }

Most of that code is copied straight from the newRecord action. The key difference is the line ec.setCurrentRecord(list.get(masterTable.getSelectedRow()));, which populates the current record in the dialog with the currently selected record.

The Client part of the application is almost completely set. You should be able to freely add, edit, and delete records from your CLIENTS table using the specialized GUI we have created.

One last detail: the main form still has the title of Database Application Example, and it's not obvious where to change. Hint: it's not within the GUI Builder.

To change the title of the main frame of the application:

In the Projects window, select the project's node and choose Properties.
In the Project Properties dialog box, select the Application node.
Edit the Title property and any other properties that are important to you.

Now when you run the application, most of the key elements are in place. In the screenshot below, you can see the Edit Client dialog as it appears after having selected a record and pressed the Edit button.

I could continue with customization of the bottom part of the main form and other fine tuning of the application, but I'll save most of those details for the tutorial and individual blog posts with more atomic examples. As always, keep your questions coming and I'll try to deal with as many of them as I can.

Binding JComboBox's Elements and Selected Item

2008-06-09T11:07:19-07:00

by Patrick Keegan

This is part 3 in a series of posts that I'm doing to show how to use beans binding and JPA to create a Java desktop database application. In this installment, I concentrate on combo boxes, namely how to populate combo boxes from a table and then how to bind the user selection to a record. If you want to code along with me, be sure to read my previous two posts.

When we created the skeleton for this application, we (or, rather, the New Java Desktop Application wizard) did not take into account the foreign key from the Clients table to the Countries table. The only relationship between tables that was acknowledged was the one pertinent to the master/detail relationship between the Clients and the Orders tables. So now we will need to take some extra steps to establish the Clients/Countries relationship in the entity classes:

Create an entity class for the Countries table by right-clicking the package that contains your classes and choosing New | Entity Classes from Database.
In the generated Countries class add the following line below the @ID annotation, just as we did for the Clients and Orders classes.
```
    @GeneratedValue(strategy=GenerationType.IDENTITY)
```
Press Ctrl-Shift-I to add the necessary import statements.
Modify the Clients entity class so that countryId property is of type Countries instead of Integer and that it is joined with the Countries db table. The following changes are necessary:
- Replace this field declaration and annotations
```
    @Column(name = "COUNTRY_ID")
    private Integer countryId;
```
  with this code:
```
    @JoinColumn(name = "COUNTRY_ID", referencedColumnName = "COUNTRY_ID")
    @ManyToOne
    private Countries countryId;
```
- Change the type of the getCountryId() method from Integer to Countries.
- In the getCountryId() method, change the types of countryId and countryId from Integer to Countries.
- Press Ctrl-Shift-I to add the imports for the pasted code.

We also need to update the column binding for the country field so that it refers to the country property of the Countries object instead of an Integer. (Code to use a country ID Integer was generated by the project since the skeleton was generated without having an entity class for the COUNTRIES table. If we don't make a change here, a ClassCastException will be thrown when you run the application.) Here are the steps:

In the main form, right-click the top table and choose Table of Contents and then click the Columns tab.
In the customizer, select the Country Id row.
Change the Expression to ${countryId.country}. After you do so, the type should also change to String.
Change the Title from Country Id to Country (this affects the column heading in the running application).

Now it's time to do the binding for the Country combo box in the dialog.

Read the rest of this tutorial.

New and Free Courses, and Updated Tutorials Page

2008-06-04T12:14:11-07:00

Sun Offers Free Training to All Students

Sun Student Courses: Get real-world training and earn a certificate:
- NetBeans GUI Builder, JRuby, JavaFX, and Java ME
- Introduction to Solaris and OpenSolaris.org
- Introduction to Sun SPOTs
Sun Academic Initiative (SAI): This tool gives students access to all types of courses, including web scripting, open source, mobile Java development, beginner Java training, operating systems, and much more...

New Training Courses (fee based):

Reference:

Updated Online Tutorials Page (free)
See the updated listing of online tutorials and training to learn about various Java technologies and tools.

See Online Tutorials

Beans Binding Between Separate Forms

2008-06-02T18:06:18-07:00

by Patrick Keegan

Continuing from my last post, I'll show the next steps in the creation of this simple (but not too simple) client purchase application. This time, our main focus is in creating a separate dialog which we will use for data entry. We'll need to do a few tricks so that input from the dialog is propagated to the main form and then the database.

But first we'll need to clear up a few loose ends. As I alluded to last time, I use AUTO_INCREMENT attributes for the ID columns of the CLIENTS, COUNTRIES, and ORDERS tables. This means that whenever a new row is added to those tables, that row's AUTO_INCREMENT field is given a unique value (the value of the last new record + 1). For me using AUTO_INCREMENT is a handy way to ensure having unique records.

When you generate the skeleton of the application in the New Java Desktop Application wizard, the IDE generates two entity classes (Clients.java and Orders.java) that represent database tables with the same names. However, these entity classes are missing code to deal with the AUTO_INCREMENT fields. Without that code, you will get errors when trying to enter new records. To fix that:

Open the Clients.java class.
Navigate to the line after the one containing @Id.
Enter the line @GeneratedValue(strategy=GenerationType.IDENTITY).
Press Ctrl-Shift-I to generate the necessary import statements for this annotation.
Repeat the process for Orders.java.

Note: You can also use code completion here. It takes three selections to get the entire line, but the import statements are generated for free.

Once you have added these annotations, you can run the application and start adding data. Click the top New button to add a client. With a client selected, click the bottom New button to add an order for that client. Click Save to push your changes to the database. Click Refresh to back out any unsaved changes.

I like tables for browsing data, but I think they leave something to be desired for data entry. So for this application, we'll add dialogs for data entry.

To create and populate the JDialog, follow these steps:

Right-click the package that contains your classes and choose New | Other. Select Swing GUI Forms | JDialog Form template and name it EditClient.
From the Palette window drag, drop, and arrange components for the customer's personal details.
You should have JLabels for each of the following fields: first name, last name, address, city, state, zip code, country, and phone number. You should have JTextFields for each of those fields, except for country, for which we will use a JComboBox.
Edit the display text for JLabels.
Add two buttons and name them Save and Cancel.
(Optional) Rename all of the components you have added to more memorable names, such as firstNameLabel. You can do this inline in the Inspector window.

The resulting layout should look something like what you see below.

Read the rest of this tutorial.

Input on a New Desktop Java Database Tutorial

2008-05-27T09:23:42-07:00

by Patrick Keegan

Recently I've found time again to work on actual tutorials. I don't have anything written yet, but I have something resembling a plan, which you can find here: http://wiki.netbeans.org/PlanGuiBuilderDocImprovements.

Over the next few weeks, I'll be blogging about creating a Swing desktop application with database connectivity. These postings will essentially serve as a rough sneak preview of a full-fledged tutorial on the subject that I'll later post to netbeans.org. The tutorial will go beyond simple database connectivity and show things such as one-to-many and many-to-one relationships as well as how to bind database tables to a variety of GUI components. We'll use a MySQL database that has tables for client info, order info, and countries. There will be a one-to-many relationship between the client and order tables. There will be a many-to-one relationship between client and countries tables. Along the way, I'll be looking at any feedback that comes through and do my best to respond to it, whether in quick responses, in separate articles, or by modifying the final tutorial. Chances are that I'll also tweak the structure along the way as I find better ways of doing things.

To start off, I'll provide an SQL script that provides a beginning database structure:

CREATE TABLE CLIENTS (
	ID INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,
	FIRST_NAME VARCHAR(20),
	SURNAME VARCHAR(30),
        ADDRESS VARCHAR(30),
	CITY VARCHAR(30),
	STATE_ VARCHAR(30),
	ZIP INTEGER,
	COUNTRY_ID INTEGER,
	PHONE INTEGER
);

    CREATE TABLE EMAIL_ADDRESSES (
    CLIENT_ID INTEGER NOT NULL,
    ADDRESS VARCHAR(50) NOT NULL PRIMARY KEY,
    FORMAT INTEGER,
    FOREIGN KEY (CLIENT_ID) REFERENCES CLIENTS(ID)
    );
    
CREATE TABLE ORDERS (
    ID INTEGER NOT NULL AUTO_INCREMENT,
    CLIENT_ID INTEGER NOT NULL,
    PRODUCT VARCHAR(50) NOT NULL,
    AMOUNT INTEGER NOT NULL,
    PRIMARY KEY(ID),
    FOREIGN KEY (CLIENT_ID) REFERENCES CLIENTS(ID)
);

CREATE TABLE PRODUCTS (
    MODEL VARCHAR(50) NOT NULL PRIMARY KEY,
    PRICE DECIMAL NOT NULL
);

CREATE TABLE COUNTRIES (
    COUNTRY_ID INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,
    COUNTRY VARCHAR(30) 
);

ALTER TABLE CLIENTS    
ADD CONSTRAINT COUNTRIES_FK Foreign Key (COUNTRY_ID)
   REFERENCES COUNTRIES (COUNTRY_ID);

Read the rest of this tutorial

Trail: The Reflection API

2008-05-20T12:16:19-07:00

Uses of Reflection

Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.
Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.
Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

Drawbacks of Reflection
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.
Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.
Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.
Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

Trail Lessons
This trail covers common uses of reflection for accessing and manipulating classes, fields, methods, and constructors. Each lesson contains code examples, tips, and troubleshooting information.
Classes
This lesson shows the various ways to obtain a Class object and use it to examine properties of a class, including its declaration and contents.
Members
This lesson describes how to use the Reflection APIs to find the fields, methods, and constructors of a class. Examples are provided for setting and getting field values, invoking methods, and creating new instances of objects using specific constructors.
Arrays and Enumerated Types
This lesson introduces two special types of classes: arrays, which are generated at runtime, and enum types, which define unique named object instances. Sample code shows how to retrieve the component type for an array and how to set and get fields with array or enum types.

Note: The examples in this trail are designed for experimenting with the Reflection APIs. The handling of exceptions therefore is not the same as would be used in production code. In particular, in production code it is not recommended to dump stack traces that are visible to the user.

Read the rest of this trail

The 2008 JavaOne Conference: For New Developers

2008-04-24T11:25:30-07:00

by Dana Nourie

The 2008 JavaOne Conference, with events from May 5 to 9 in San Francisco, California, is a great place for new developers to learn about many Java technologies and see how these technologies fit together. In addition, you can learn about other technologies and scripting languages, such as Ruby and Groovy.

The conference kicks off on Monday, May 5, with Java University, which consists of classes you can take to learn how to program for the Java platform and how to incorporate other technologies and use tools, such as the NetBeans IDE.

The rest of the week is filled with technical sessions that last about one hour each and that cover many different topics. In addition, the JavaOne conference also has Birds-of-a-Feather (BOF) sessions where you can hear what fellow developers think, what they're doing professionally, and where they want to see technologies go. It's a week jam-packed with technical how-to and information that can be hard to find elsewhere.

This year, Sun will allow some student developers to attend the JavaOne conference for free!

Recommended sessions for students include the following:

Session ID	Session Title	Speaker Name and Company
TS-5925	A City-Driving Robotic Car Named Tommy Jr.	Paul Perrone, Perrone Robotics
TS-5841	Project Aura: Recommendation for the Rest of Us	Stephen Green and Paul Lamere, Sun Microsystems
TS-6656	Extreme GUI Makeover: Swing Meets FX	Christopher Campbell and Shannon Hickey, Sun Microsystems
TS-6611	Filthy-Rich Clients: Filthier, Richer, Clientier	Romain Guy, Google; Chet Haase, Adobe
TS-5286	Introduction to Web Beans	Gavin King, JBoss
TS-6169	Spring Framework 2.5: New and Notable	Rod Johnson, SpringSource
TS-6528	Listen and Speak: Teach Your Old Device New Tricks	Charles Hemphill, Conversay; Steve Rondel, Conversay
TS-6623	More "Effective Java"	Joshua Bloch, Google
TS-5579	Closures Cookbook	Neal Gafter, Google
TS-5165	Programming With Functional Objects in Scala	Martin Odersky, EPFL
TS-5152	Overview of the JavaFX Script Programming Language	Christopher Oliver, Sun Microsystems
TS-6050	Comparing JRuby and Groovy	Neal Ford, ThoughtWorks
TS-4842	Designing an MMORPG With Project Darkstar	Jeffrey Kesselman, Sun Microsystems
TS-6807	What's New in Ajax	Dion Almaer, Ajaxian; Ben Galbraith, MediaBank
TS-6537	Applications for the Masses by the Masses: Why Engineers Are an Endangered Species	Girish Balachandran and Todd Fast, Sun Microsystems
TS-5249	The NetBeans Ruby IDE: You Thought Rails Development Was Fun Before	Brian Leonard and Tor Norbye, Sun Microsystems

Additionally, you can attend fun sessions on how Java technologies are being used in the world of science: Mapping Mars (TS-6608); Universal Translator -- Breaking the Communication Barrier With JSAPI (TS-5908); Pushing Java OpenGL (JOGL) to the Limit With Stellarium (TS-4964); and Mars Rover Operations Imaging and Mapping With Java Technology (BOF-5044).

If you're interested in gaming, check out Video Game Development on the Java Platform: Past, Present, and Future of Java Technology Games (BOF-5832); Creating Games on the Java Platform with the jMonkeyEngine (TS-5711); Using Comet to Create a Two-Player Web Game (BOF-6584); and Project Wonderland: A Toolkit for Building 3-D Virtual Worlds (TS-6125).

Check the 2008 JavaOne Conference home page for more information, including a complete content catalog searchable by keyword, speaker name, track, and other parameters.

If you can't make it to the conference this year, you can read about the sessions as Sun writers blog from the trenches, sharing technical information and their impressions of the conference.

Hope to see you there!

Young Developers Section in the New to Java Programming Center

2008-04-15T14:56:31-07:00

Programming isn't just for adults any longer. Young people are learning programming languages from the earliest ages and up. The New to Java Programming Center is delighted to present a new section just for young developers, that lists tools and web sites that focus on teaching young developers how to program using the Java programming language, as well as languages developed for ease of use.

See Young Developers in the New to Java Programming Center.

Building an Ajax Chat Room with the Ajax Transaction Dynamic Faces Component

2008-04-09T12:07:55-07:00

In this tutorial, you build an Ajax chat room web application with components that are themselves Ajax-unaware, also known as POJC (Plain Old JavaServer Faces Components). You achieve this using Dynamic Faces technology, an extension to JavaServer Faces technology that lets you easily implement Ajax functionality. In particular, you use the Ajax Transaction component included with the Dynamic Faces component library (0.2), which lets you visually configure Ajax functionality at design time. The chat room application comprises one rendered page, shown below, and is entirely Ajax-based. No conventional page submissions occur. Specifically, an Ajax request is sent when the user sends a comment by typing text in the text field and clicking the Send button or pressing the Enter key. The page also uses Ajax requests to poll the server continually in order to update the transcript of comments.

Contents
-     Tutorial Requirements
-     Creating the Project
-     Configuring the Deployment Descriptor
-     Adding the Dynamic Faces Component Library to the Project
-     Adding Code to the Application Bean
-     Adding Code to Store the Username
-     Adding the transcript Property to Page1.java
-     Creating the User Interface
-     Configuring Ajax Transactions for Sending Comments and Polling
-     Setting JavaScript Properties of the Body and Form Components
-     Adding JavaScript
-     Deploying the Project

This tutorial works with the following technologies and resources

JavaServer Faces Components/ Java EE Platform	1.1 with J2EE 1.4
Travel Database	Not Required

Tutorial Requirements

Before you begin, you need to install the following software on your computer:

NetBeans IDE 6.0 with Web and Java EE functionality (included in the Web and Java EE download and the All download). (download)
Visual Web Samples Plugin. This plugin includes the Dynamic Faces Component Library (0.2). Follow the instructions in the section entitled "Installing the Plugin" in Installing the Visual Web Samples Plugin. Be sure to select the entries for both the Visual Web JSF Post Release Samples and the Visual Web JSF Backwards Compatibility Kit.

Follow the tutorial

**********************************

Sun Student Courses

Real World Technologies: NetBeans GUI Builder, JRuby, JavaFX, and JavaME is an introduction level course that leads you to the basics of JavaFX, NetBeans GUI, JRuby, and JavaME programming. When you finish this course you will earn a certificate.

Trail: The Extension Mechanism

2008-03-26T10:01:43-07:00

The extension mechanism was introduced as a new feature in the Java^TM 1.2 platform. The extension mechanism provides a standard, scalable way to make custom APIs available to all applications running on the Java platform. As of the Java 1.3 platform release, Java extensions are also referred to as optional packages. This trail may use both terms interchangeably.

Extensions are groups of packages and classes that augment the Java platform through the extension mechanism. The extension mechanism enables the runtime environment to find and load extension classes without the extension classes having to be named on the class path. In that respect, extension classes are similar to the Java platform's core classes. That's also where extensions get their name -- they, in effect, extend the platform's core API.

Since this mechanism extends the platform's core API, its use should be judiciously applied. Most commonly it is used for well standarized interfaces such as those defined by the Java Community Process^SM, although it may also be appropriate for site wide interfaces.

As the diagram indicates, extensions act as "add-on" modules to the Java platform. Their classes and public APIs are automatically available to any applications running on the platform.

The extension mechanism also provides a means for extension classes to be downloaded from remote locations for use by applets.

Extensions are bundled as Java Archive (JAR) files, and this trail assumes that you are familiar with the JAR file format. If you're not up to speed on JAR files, you might want to review some JAR-file documentation before proceeding with the lessons in this trail:

The Packaging Programs in JAR Files lesson in this tutorial.
The JAR Guide in the JDK^TM documentation.

This trail has two lessons:

Creating and Using Extensions

This section shows you what you need to do to add an extension to your Java platform and how applets can benefit from the extension mechanism by downloading remote extension classes.

Making Extensions Secure

This section describes security privileges and permissions that are granted to extensions on your platform. You'll see how to use the Java platform's security architecture if you're writing extensions classes of your own.

Additional Documentation

You can find further information about extensions in the The Java Extensions Mechanism section of the JDK documentation.

***********

Download NetBeans IDE 6.1 Beta – Win Big!
Download Sun NetBeans IDE 6.1 Beta to preview for yourself. Post a blog describing your experience using NetBeans and you could win $500.

Creating a Simple Web Application Using a MySQL Database

2008-03-10T10:35:53-07:00

This document describes how to create a simple web application that connects to a MySQL database server. It also covers some basic ideas and technologies in web development, such as JavaServer Pages™ (JSP), JavaServer Pages Standard Tag Library™ (JSTL), the Java Database Connectivity™ (JDBC) API, and two-tier, client-server architecture. This tutorial is designed for beginners who have a basic understanding of web development and are looking to apply their knowledge using a MySQL database.

MySQL is a popular Open Source database management system commonly used in web applications due to its speed, flexibility and reliability. MySQL employs SQL, or Structured Query Language, for accessing and processing data contained in databases.

This tutorial continues from the Connecting to a MySQL Database tutorial and assumes that you already have a connection to a MySQL database created and registered in NetBeans IDE. The table data that is included in ifpwafcad.sql. is also required for this tutorial. This SQL file creates two tables, Subject and Counselor, then populates them with sample data. Save this file to a local directory, then open it in NetBeans IDE and run it on the MySQL database. The database used in this tutorial is named MyNewDatabase.

Read Creating a Simple Web Application Using a MySQL Database.

Easy Web Site Creation in the NetBeans IDE

2008-02-19T19:29:08-08:00

by Dana Nourie

Last year I attended a Tech Days event and learned about the ease of use of jMaki widgets for web site building, and then I gave a chat in Second Life on the topic of web programming using the NetBeans IDE, including what I had learned at Tech Days. This article is based on those talks, showing how incredibly easy it is to create a web site in NetBeans through drag-and-drop without writing code, and how you can gradually learn Java programming by adding to your JavaServer Pages (JSP), and creating other features or programs that may be added to your site.

This article is aimed at new developers and programmers, and developers new to the NetBeans IDE. To follow the examples, you must have the following software installed on your computer:

The Java Standard Edition Platform (Java SE) (Note, you can download the JDK with the NetBeans IDE).
The NetBeans IDE 6.0 or greater.

NetBeans IDE Benefits for Web Site Developers

As many of you know, web applications often require many different programming languages, and a way of combining various technologies. For instance, you may use HTML and CSS for your page formatting, JavaScript for some rollover buttons, and a Java servlet or JSP to process a form. The latter is a good way to learn the syntax of the Java programming language and is a great entry point if you are new to the Java platform.

One of the wonderful things about the NetBeans IDE is that you don't have to know all the languages or how to combine the technologies. NetBeans handles the languages, and combines technologies seamlessly for you. In addition, the NetBeans IDE has some wonderful drag-and-drop widgets from various built-in palettes. For instance, you can drag and drop HTML components to create a form, Swing components to create great looking buttons or menus, or drop in interactive Ajax components using jMaki widgets.

The web site you see below in Figure 1 is not beautiful, nor is it a design I recommend. However, all of its components were simply dragged onto a page, and are fully functional, requiring no code to be written from scratch. You can do a lot of web site creation in the NetBeans IDE with very little programming.

Figure 1: Sample Web Site

Notice the clock that keeps time (on the right), a form (on the left) that gathers data from users with the all important CAPTCHA (the image above the submit button) to prevent spam, a tab layout in the center that makes for nice organization, and a fisheye effect on the photos at the top. No programming was needed for any of these. All of these features were added through drag and drop, which is far less time consuming than coding those components yourself.

There are also many services available that you can simply drop onto a page, then add URLs, or whatever you need to include to pull in that service, such as with a mashup. For instance, adding RSS feeds to your page is very easy.

NetBeans also handles writing to and pulling data from a database, as described in the Using Databound Components to Access a Database tutorial.

To create the web site shown above, read the rest of this article

Constructor or Method	Purpose
AbstractAction() AbstractAction(String) AbstractAction(String, Icon)	Create an `Action` object. Through arguments, you can specify the text and icon to be used in the components that the action is attached to.
void setEnabled(boolean) boolean isEnabled()	Set or get whether the components the action controls are enabled. Invoking `setEnabled(false)` disables all the components that the action controls. Similarly, invoking `setEnabled(true)` enables the action's components.
void putValue(String, Object) Object getValue(String)	Set or get an object associated with a specified key. Used for setting and getting properties associated with an action.

Property	Auto-Applied to: Class (Method Called)	Purpose
ACCELERATOR_KEY	`JMenuItem` (setAccelerator)	The `KeyStroke` to be used as the accelerator for the action. For a discussion of accelerators versus mnemonics, see Enabling Keyboard Operation. Introduced in 1.3.
ACTION_COMMAND_KEY	`AbstractButton`, `JCheckBox`, `JRadioButton` (setActionCommand)	The command string associated with the `ActionEvent`.
LONG_DESCRIPTION	None	The longer description for the action. Can be used for context-sensitive help.
MNEMONIC_KEY	`AbstractButton`, `JMenuItem`, `JCheckBox`, `JRadioButton` (setMnemonic)	The mnemonic for the action. For a discussion of accelerators versus mnemonics, see Enabling Keyboard Operation. Introduced in 1.3.
NAME	`AbstractButton`, `JMenuItem`, `JCheckBox`, `JRadioButton` (setText)	The name of the action. You can set this property when creating the action using the `AbstractAction(String)` or `AbstractAction(String, Icon)` constructors.
SHORT_DESCRIPTION	`AbstractButton`, `JCheckBox`, `JRadioButton` (setToolTipText)	The short description of the action.
SMALL_ICON	`AbstractButton`, `JMenuItem` (setIcon)	The icon for the action used in the tool bar or on a button. You can set this property when creating the action using the `AbstractAction(name, icon)` constructor.