How do you define a class of constants in Java

Question

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    Interface Abstract Class 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

User · Answer

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

User · Answer

Or 4  Put them in the class that contains the logic that uses the constants the most      sorry  couldn t resist  -

User · Answer

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

User · Answer

Use a final class  for simplicity you may then use a static import to reuse your values in another class  public final class MyValues     public static final String VALUE1    foo     public static final String VALUE2    bar       in another class    import static MyValues          if variable equals VALUE1

User · Answer

Or 4  Put them in the class that contains the logic that uses the constants the most      sorry  couldn t resist  -

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

Or 4  Put them in the class that contains the logic that uses the constants the most      sorry  couldn t resist  -

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

Use a final class  for simplicity you may then use a static import to reuse your values in another class  public final class MyValues     public static final String VALUE1    foo     public static final String VALUE2    bar       in another class    import static MyValues          if variable equals VALUE1

User · Answer

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

User · Answer

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

User · Answer

Aren t enums best choice for these kinds of stuff

User · Answer

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

User · Answer

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

User · Answer

Use a final class  for simplicity you may then use a static import to reuse your values in another class  public final class MyValues     public static final String VALUE1    foo     public static final String VALUE2    bar       in another class    import static MyValues          if variable equals VALUE1

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

Aren t enums best choice for these kinds of stuff

User · Answer

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

User · Answer

Or 4  Put them in the class that contains the logic that uses the constants the most      sorry  couldn t resist  -

User · Answer

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

User · Answer

Aren t enums best choice for these kinds of stuff

User · Answer

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

User · Answer

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

User · Answer

Aren t enums best choice for these kinds of stuff

User · Answer

Use a final class  for simplicity you may then use a static import to reuse your values in another class  public final class MyValues     public static final String VALUE1    foo     public static final String VALUE2    bar       in another class    import static MyValues          if variable equals VALUE1

User · Answer

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

User · Answer

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

[java] How do you define a class of constants in Java?

Examples related to java

Examples related to class-constants