Java constants file

Question

Hello.

I'm developing an Android application and I'm very new on Java and Android.

I want to create some constants to use in some activities. Where can I define these constants?

Thanks.

Answer 1

Normally, you'd use a Constants class, or define them in classes where they are used, a la:

class Constants {
   public static final int CONST_4 = 4;
   public static final String some_string_constant = "This is a constant";
}

Then you'd refer to them by:

String inst = Constants.some_string_constant;

Answer 2

You can define some constants in Java enumerations.

A single Java enumerator may hold multiple fields of associated data.

Oracle provides this introduction to Java enumerations.

Answer 3

It's considered bad practice in java, and most OO languages, to define a class simply to hold constants. It's much better to define the constants in a class they are associated with. Usually there is one. e.g.

interface MyComponent {
  /** The default height for a component */
  public static final int DEFAULT_HEIGHT = 5;
  // other stuff
}

If there really isn't one feel free to define a separate class.

EDIT:The key things here are:

1. Make the constants easy to find. If there is a 'natural' place to put them, put them there (i.e. the default height for Component objects belong in the Component class).
2. Don't have higher coupling than you need to. Putting all your constants in one 'Constants' class makes for high coupling, especially as subsequent modifiers tend to then put ALL constants in the Constants class, whether or not there is another class they could naturally be put in.

Answer 4

The most common way is to create 'constants' in the classes were you need them:

class Example { 
  private static final int FILENAME = "test.txt; 
} 

Instead of private it can also be declared default, protected or public. Although it is considered an OO anti pattern to define constants is a special 'constants' (God) class that stores constants for the whole application. Alternatively, you can also store configuration data in a Java properties file, this is not considered an anti-pattern.

Another option, that is rapidly gaining popularity, is the usage of the Dependency Inject (DI) pattern. Often this pattern is used for depend object, but it can also be used to inject constant values into objects. This can for example be implemented with Google's lightweight Guice DI framework:

class Example {
  String filename;

  @Inject
  public Example(@ConfigFilename String filename) {
     this.filename = filename;        
  }

In a special Binder class you will bind a value to the Strings annotated with @ConfigFilename. This way, you have minimal coupling and classes that can be independently tested.