Constants Class

[Keith Jones]

Hi all,

What is the feeling in this forum about constants?

For things like the title of the frame of the gui Ddo you all think that it is better to:

a) create a constants class containing these constants such as:

class Constants {
public final static String GUI_TITLE = "Bogitt and Scarper Application";
}

b) just put the string into the method that uses it since it's only going to be used once:

class GUI extends JFrame {

...

setTitle("Bogitt and Scarper Application");

...

}

c) Or shall I just have it as a constant in the class in which it is to be used?

class GUI extends JFrame {

...

private final static String GUI_TITLE = "Bogitt and Scarper Application";

...

}

Cheers

[Mike Ngo]

I use (b). The reason is those strings are more likely to come from resource bundle files.

[Chulwoo Choi]

Hi,

In my case, I separated all texts for GUI labels, exception messages, etc. into a resource bundle, a properties file.

For example, in the properties file, say, "MyProj.properties" under the "suncertify" directory, you will have a line:

application.title=Bogitt and Scarper Application

Then, in the program code (JFrame), you access the value in the following way:

setTitle(java.util.ResourceBundle.getBundle("suncertify/MyProj").getString("application.title"));

(Note it's a common practice using the resource bundle in web component development for internationalization (i18n) purpose, etc.)

Chulwoo

[Cameron Wallace McKenzie]

Two things came to mind when I read this post.

First of all, most String values should come from resource bundles, so that limits the scope of the question. But even the name of the resource bundle will be a String, so that String has to be placed somewhere as well.

I actually prefer to use an interface to declare all of my constants, as opposed to a class. Just a style thing. And just to clarify, I'm not recommending the Constant Interface Java anti-pattern where classes implement the interface to access the constants. That's just plain bad.

For me, the big point is that String values should not be found in the body of code. String values are not 'type-checked', which is of huge significance in any sized project, they are often used in different places by different users, which can cause confusion, and they often need to change, so having them all defined in one place makes sense.

You should take my advice. I have a Science degree, and my concentration was String theory.

Cheers!

-Cameron McKenzie
[ November 07, 2006: Message edited by: Cameron W. McKenzie ]

[Mike Ngo]

setTitle(java.util.ResourceBundle.getBundle("suncertify/MyProj").getString("application.title"));

You should make a class to read the resource bundle or you will have to change lots of files if you ever change the name of your properties file.

[Chulwoo Choi]

A few comments:

I actually prefer to use an interface to declare all of my constants, as opposed to a class. Just a style thing.

For me, the big point is that String values should not be found in the body of code. String values are not 'type-checked', which is of huge significance in any sized project, they are often used in different places by different users, which can cause confusion, and they often need to change, so having them all defined in one place makes sense.

You should take my advice. I have a Science degree, and my concentration was String theory.

1. It is recommended not to use interfaces for constants. For example, from Effective Java (by Bloch):

Item 17: User interfaces only to define types
...
The constant interface pattern is a poor use of interfaces.
(explanation follows in two pages)
...

2. You can have a constant for the file name and use it (in JFrame's setTitle(...) for example) if you are worried about file name change in the future:

final String BUNDLE = "suncertify/MyProj";

Resource bundles are known to be widely used for text labels in applications.
User preference is another thing. See below.
3. For user preference values, you can consider using:

java.util.prefs.Preferences

It provides methods for values of various types.
(But this class is NOT for SCJD project as you're required to use a properties file (at least according to my requirements doc).)

Regards,
Chulwoo

[Sam Codean]

I have saved all the Labels in the suncertify.properties file itself and am using it to store both the labels and the user preferences. I know it is stupid to merge both but then a MUST made that decision, <B>must have only one properties file</B>

[Chulwoo Choi]

Sam,

You said:

...
must have only one properties file
...

In my instructions document:

...
configuration information must be stored in a file called suncertify.properties
...

This sentence doesn't imply suncertify.properties must be the only properties file. I think it should be okay to use this properties file for configuration purpose and another one for GUI labels, etc.

Chulwoo

[Keith Jones]

Please tell me that we can use the java.util.Properties class to do the reading and writing from our properties file(s).

[Jeremy Botha]

It's part of the standard Java API, so I see no reason why you can't use it. I used it.

I defined various application strings in a Constants class. Bad practice, I know.

Jeremy

[Jeroen T Wenting]

Originally posted by Keith Jones:
Please tell me that we can use the java.util.Properties class to do the reading and writing from our properties file(s).

we can use the java.util.Properties class to do the reading and writing from our properties file(s).

happy?

For reading resourcebundles you should use ResourceBundle instead though, as it handles things like internationalisation semi-automatically by selecting the locale to load based on user OS language and available bundles.

But I think that's overkill for an application on this scale and coding the titles into the screens as fixed strings would be quite acceptable.

[Keith Jones]

what's the difference between using a resource bundle and the properties class. Isn't the latter simpler?

[Chulwoo Choi]

Keith,

1. When to use which:
For text labels, e.g. JFrame's title, button's label, etc., use resource bundles.
For configuration values, e.g., port number (an int value), DB file path (a String value), etc., use java.util.Properties.

2. Similarity:
They (resource bundle and config properties) both use a properties file that contains a list of key/value pairs:

# Text label
app.title=My Application
...
 
# A config value (in another properties file)
...
host=localhost     
...

3. Differences:
For labels, key/value pairs are stored in properties file and this properties file is read only. You just use the texts in the file.
For config values, key/value pairs are read/written from/to a properties.

Note labels and config values are used for different purposes. For example, button labels are not config values and DB file path is not a label (it is a data used in operating the application).

4. Requirements
For sun developer exam, you must save/retrieve config values to/from a properties file.
You do not have to use resource bundle for texts. But resource bundles are easy enough to use (see my post above) and are sometimes required in Java EE projects. So why don't you consider using it?

5. Alternatives
For config values, it is recommended to use java.util.prefs.Preferences instead of java.util.Properties. Preferences is similar to Properties but with Preferences you don't have to worry about properties file (files are created automatically by Preferences).
But you CANNOT use Preferences class as you have to use a properties file for SCJD project.

Regards,
Chulwoo

[Keith Jones]

Thanks Chulwoo you're very helpfull.