CODEWITHSUNDEEP
javaclass-constants
Yuval Adam
Yuval Adam

Reputation: 165322

How do you define a class of constants in Java?

Suppose you need to define a class which all it does is hold constants.

public static final String SOME_CONST = "SOME_VALUE";

What is the preferred way of doing this?

  1. Interface
  2. Abstract Class
  3. Final Class

Which one should I use and why?

Clarifications to some answers:

Enums - I'm not going to use enums, I am not enumerating anything, just collecting some constants which are not related to each other in any way.

Interface - I'm not going to set any class as one that implements the interface. Just want to use the interface to call constants like so: ISomeInterface.SOME_CONST.

Upvotes: 117

Views: 170277

Answers (11)

kapitanrum
kapitanrum

Reputation: 180

The best approach for me, is enum:

public enum SomeApiConstants {;
  // private constant 
  private static final String PREFIX = "/user";
  private static final String DT_FORMAT = "yyyyMMdd HH:mm:ss";

  // public constants
  public static final String SOME_CONST = "SOME_VALUE";
  public static final String STARTED = ofPattern(DT_FORMAT).format(Instant.now());

  //may be in hierarchy (public/private)
  public enum ApiMapping {;
    public static final String VERSION = PREFIX + "/version";
    public static final String VERSION_LIST = PREFIX + "/list/{type}";
  }
}

Pros:

  • clean code
  • core Java
  • the private constructor does not need to be defined
  • attempt to instantiate is validated at compile time as java: enum types cannot be instantiated
  • prevents to clone and deserialization
  • cannot be extended (Enum is final)
  • access modifier public/private/(package private) can be used.

Upvotes: 4

Boris Pavlović
Boris Pavlović

Reputation: 64642

Aren't enums best choice for these kinds of stuff?

Upvotes: 4

user54579
user54579

Reputation: 4688

Use a final class, and define a private constructor to hide the public one.
For simplicity you may then use a static import to reuse your values in another class

public final class MyValues {

  private MyValues() {
    // No need to instantiate the class, we can hide its constructor
  }

  public static final String VALUE1 = "foo";
  public static final String VALUE2 = "bar";
}

in another class :

import static MyValues.*
//...

if (VALUE1.equals(variable)) {
  //...
}

Upvotes: 134

kenj0418
kenj0418

Reputation: 6848

My suggestions (in decreasing order of preference):

1) Don't do it. Create the constants in the actual class where they are most relevant. Having a 'bag of constants' class/interface isn't really following OO best practices.

I, and everyone else, ignore #1 from time to time. If you're going to do that then:

2) final class with private constructor This will at least prevent anyone from abusing your 'bag of constants' by extending/implementing it to get easy access to the constants. (I know you said you wouldn't do this -- but that doesn't mean someone coming along after you won't)

3) interface This will work, but not my preference giving the possible abuse mention in #2.

In general, just because these are constants doesn't mean you shouldn't still apply normal oo principles to them. If no one but one class cares about a constant - it should be private and in that class. If only tests care about a constant - it should be in a test class, not production code. If a constant is defined in multiple places (not just accidentally the same) - refactor to eliminate duplication. And so on - treat them like you would a method.

Upvotes: 39

Guizhou Feng
Guizhou Feng

Reputation: 121

  1. One of the disadvantage of private constructor is the exists of method could never be tested.

  2. Enum by the nature concept good to apply in specific domain type, apply it to decentralized constants looks not good enough

The concept of Enum is "Enumerations are sets of closely related items".

  1. Extend/implement a constant interface is a bad practice, it is hard to think about requirement to extend a immutable constant instead of referring to it directly.

  2. If apply quality tool like SonarSource, there are rules force developer to drop constant interface, this is a awkward thing as a lot of projects enjoy the constant interface and rarely to see "extend" things happen on constant interfaces

Upvotes: -2

Tom Hawtin - tackline
Tom Hawtin - tackline

Reputation: 147154

enums are fine. IIRC, one item in effective Java (2nd Ed) has enum constants enumerating standard options implementing a [Java keyword] interface for any value.

My preference is to use a [Java keyword] interface over a final class for constants. You implicitly get the public static final. Some people will argue that an interface allows bad programmers to implement it, but bad programmers are going to write code that sucks no matter what you do.

Which looks better?

public final class SomeStuff {
     private SomeStuff() {
         throw new Error();
     }
     public static final String SOME_CONST = "Some value or another, I don't know.";
}

Or:

public interface SomeStuff {
     String SOME_CONST = "Some value or another, I don't know.";
}

Upvotes: 5

Sébastien RoccaSerra
Sébastien RoccaSerra

Reputation: 17211

As Joshua Bloch notes in Effective Java:

  • Interfaces should only be used to define types,
  • abstract classes don't prevent instanciability (they can be subclassed, and even suggest that they are designed to be subclassed).

You can use an Enum if all your constants are related (like planet names), put the constant values in classes they are related to (if you have access to them), or use a non instanciable utility class (define a private default constructor).

class SomeConstants
{
    // Prevents instanciation of myself and my subclasses
    private SomeConstants() {}

    public final static String TOTO = "toto";
    public final static Integer TEN = 10;
    //...
}

Then, as already stated, you can use static imports to use your constants.

Upvotes: 14

Jon Skeet
Jon Skeet

Reputation: 1503090

Your clarification states: "I'm not going to use enums, I am not enumerating anything, just collecting some constants which are not related to each other in any way."

If the constants aren't related to each other at all, why do you want to collect them together? Put each constant in the class which it's most closely related to.

Upvotes: 47

Simon Groenewolt
Simon Groenewolt

Reputation: 10665

Or 4. Put them in the class that contains the logic that uses the constants the most

... sorry, couldn't resist ;-)

Upvotes: 1

cletus
cletus

Reputation: 625317

My preferred method is not to do that at all. The age of constants pretty much died when Java 5 introduced typesafe enums. And even before then Josh Bloch published a (slightly more wordy) version of that, which worked on Java 1.4 (and earlier).

Unless you need interoperability with some legacy code there's really no reason to use named String/integer constants anymore.

Upvotes: 7

Megacan
Megacan

Reputation: 2518

Just use final class.

If you want to be able to add other values use an abstract class.

It doesn't make much sense using an interface, an interface is supposed to specify a contract. You just want to declare some constant values.

Upvotes: 3

Related Questions