Reputation: 165322
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?
Which one should I use and why?
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
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:
java: enum types cannot be instantiated
Upvotes: 4
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
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
Reputation: 121
One of the disadvantage of private constructor is the exists of method could never be tested.
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".
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.
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
Reputation: 147154
enum
s 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
Reputation: 17211
As Joshua Bloch notes in Effective Java:
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
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
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
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
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