Setting Program Attributes in Java

Application attributes are often called preferences and can often allow the user to configure various start up options, preferred window size, or whatever.

Setting Program Attributes

A program typically needs this information about the system and application environment to make decisions about how to do something, or what to do. Also, a program may wish to modify certain attributes itself, or allow a user to change them. Thus a program needs to be able to read and write various system attributes and program-specific attributes. Java programs can manage these attributes through three mechanisms: properties, application command line arguments, and applet parameters.

Properties
Use properties to define environmental attributes on a persistent basis. That is, use properties when they need to be in effect for each invocation of a program.
Application Command Line Arguments
Use command line arguments to define or modify environmental attributes on a non-persistent basis. That is, use command line arguments to change one or more attributes for just one invocation of a program.
Applet Parameters
Use applet parameters to define or modify environmental attributes on a non-persistent basis for applets. That is, use parameters to set one or more attributes for a single invocation of an applet.

Converting Objects to Strings

You can use the Properties class from java.util to manage attributes specific to your Java programs. A Properties object manages a set of key/value pairs: the key represents the name of a property and the value is the current value of the property. You can load key/value pairs into a Properties object from a stream, save the properties to a stream, and get information about the properties represented by the Properties object.

Setting up Your Properties Object

Often when a program starts up, it will use code similar to the following to set up the properties object:

// set up default properties
Properties defaultProps = new Properties();
FileInputStream defaultStream = new FileInputStream("defaultProperties");
defaultProps.load(defaultStream);
defaultsStream.close();
// set up real properties
Properties applicationProps = new Properties(defaultProps);
FileInputStream appStream = new FileInputStream("appProperties");
applicationProps.load(appStream);
appStream.close();

First the application sets up a default Properties object. This object contains the set of properties to use if values are not explicitly set elsewhere. This code snippet uses the load() method to read the default values from a file on disk named defaultProperties. Applications usually save and restore properties to files on the disk.

Next, the program uses a different constructor to create a second Properties object, applicationProps. This object uses defaultProps to provide its default values. Then the code snippet loads a set of properties into applicationProps from a file named appProperties. The properties loaded into appProperties can be set on a per user basis, a per site basis, or whatever is appropriate for the current application.

Getting Property Information

Once you've set up your Properties object, you can query it for information about various properties it contains. The Properties class provides several methods for getting property information

getProperty() (2 versions)

returns the value for the specified property. One version allows you to provide a default value--if the key is not found the default is returned.

list()

writes all the properties to the specified stream. This is useful for debugging.

propertyNames()

returns an Enumeration containing all of the keys contained in the Properties object.

Command Line Arguments

Your Java application can accept any number of arguments from the command line. Command line arguments allow the user to affect the operation of an application. For example, a program might allow the user to specify verbose mode--that is, specify that the application display a lot of trace information--with the command line argument -verbose.

When invoking an application, the user types the command line arguments after the application name. For example, suppose you had a Java application, called Sort, that sorted lines in a file, and that the data you want sorted is in a file named ListOfFriends. If you were using DOS, you would invoke the Sort application on your data file like this:

C:\> java Sort ListOfFriends

Echo Command Line Arguments
This simple application displays each of its command line arguments on a line by itself:

class Echo
{
public static void main (String args[])
{
for (int i = 0; i < args.length; i++)
System.out.println(args[i]);
}
}

Try this: Invoke the Echo application with the command line shown in this DOS example:

C:\> java Echo Drink Hot Java Drink Hot Java

You'll notice that the application displays each word--Drink, Hot, and Java--on a line by itself. This is because The Space Character Separates Command Line Arguments.

Share And Enjoy:These icons link to social bookmarking sites where readers can share and discover new web pages.