Where to declare Constants in Java

Its been an topic of debate where should constants be declared. Let look at approaches :-
  1. Declared in an Interface.
  2. Declared in a Class.
  3. Enums
Going through google, i found number of explanation for both of these. Each have their pros and cons. I'll try to summarise and share my thoughts on it.

Lets start with interface. In Java, Interfaces are used as abstract type, that contain method signatures, constants and nested types as according to Oracle. We can use interfaces to defined a contract or for communication  as explained in my previous article. If we define constants here, we can have the following consequences:-
  1. We cannot stop a class to not implement an interface.So a Global constant interface can be used for subtype which is not advisable.
  2. We cannot give define constants depend on certain state condition.
  3. All the constants would stay in memory all the time.
Although, we can define constants in interfaces, we have the above constraints. Lets look how we overcome all of this in Class.

We can declare a UtilConstant class. Make it final and make the constructor private. With this, we can overcome the problem (1) of interfaces.
Also if constants to be declared need some computation or a function call, we can do in class as defined below:-
public class constantClassExample {
static final int BATCH_SIZE=getBatchsize();

   private static int getBatchsize() {
   // User defined computation
   return 0;
  }
}
So we have seen that we can define constants at runtime i.e (2). 
So to overcome (3) problem in interfaces, we can make use of static imports. It allows you to import one or two members as per requirement. Be aware, if you import all the constants using '*' , it can polluter your class space.
Afcourse, if the constants are relevent to current class, it will help keeping the code encapsulated.

Last comes the Enums. If the constants can be clubbed to one single type or we need to enumerate , we can use Enums.

For futher readings -

Comments

  1. Albert GorskiNovember 18, 2011 at 2:21 PM

    This comment has been removed by the author.

    ReplyDelete
  2. Albert GorskiNovember 18, 2011 at 2:22 PM

    I think constants in the interfaces are very poor design factor because was designed to define a CONTRACT and not to be a synthetic sugar.
    Constants in interfaces are generally very bad idea from the clean code point of view.

    So, if you need to put it "somewhere" try to put it in the business class or better create a new ENUM (which is created for such purposes).

    my 5 cents :)

    cheers
    Albert

    ReplyDelete
  3. AnonymousNovember 22, 2011 at 7:39 PM

    this is a good article..

    ReplyDelete

Post a Comment

Popular posts from this blog

When to use getClass() and instanceOf in Java

getClass() only gives equality if two objects belong to same class whereas instanceOf works for subtype also. If two objects of different classes are checked for equal, then we use instanceOf . But once you use instanceOf at some level in the class hierarchy everything below it must use instanceOf or you will violatate the symmetry clause of equals contract.  e.g. any list can be equal to any list as long they have same elements iun the same order. So any List implementation equals() method must do instanceOf and not getclass() and then compare. On the other hand, it only make sense for na instance of class X to be equal to another instance of class X ( and not any subclass ) , then use getClass().
Read more

How class.forName loads the Database Driver in JDBC

When Class.forName() is called with an argument like this: Class.forName("org.gjt.mm.mysql.Driver"); the classloader attempts to load and link the Driver class in the “org.gjt.mm.mysql” package and if successful, the static initializer is run. The MySQL Driver static initializer looks like this: static {   try {     java.sql.DriverManager.registerDriver(new Driver());   } catch (SQLException E) {     throw new RuntimeException("Can't register driver!");   } } So it calls a static method in the java.sql.DriverManager class which apparently registers a copy of itself when it loads.   To understand the why you have to look at the next line in the initial code example: Connection con = DriverManager.getConnection(url,   "myLogin", "myPassword"); The DriverManager class returns a database connection given a JDBC URL string, a username and a password. In order to create that connect...
Read more

Why Time gets truncated with ResutSet getDate() function.

Recently I stuck in an issue on populating date from stored procedure. I am reading a date from a resultset using rs.getDate(), storing in a java.util.Date instance variable and displaying on the screen. Java.util.Date  mydate = rs.getDate(1); Output is only date while time is truncated.  But why …! That confused me a lot. So I google it. Spending lot of time in reading blogs, oracle docs and trying different things on oracle server like checking  NLS_DATE_FORMAT, I am not able to get the time. Next I come across a Timestamp thing in Resultset class. Rs.getTimestamp (int colIndex) When I use it, I immediately get the time.  Now, the important question, why the resultset function getDate() does not return the Time. Now my search is preety narrow. What I found is :- In java, we have java.util.Date for java.sq.Date . So functionalities available in sql.Date are also available in util.Date. But there is one difference, sql.Date stores only Date and not Time ...
Read more