Implemetinng the interface with all static final variables

[Baiju Varugese]

hi all,

in my project we have an interface application constants which has all the application level constants defined there and most all the other classes implements ApplicationConstants interface,

i have a doubt that if we implements the interface is there is a seperate copy of all the variables in the heap

[Jeff Albertson]

I have no doubt that you are using the "Constant Interface Antipattern"

In any case, if you define "static final int MAX = 10", the compiler is likely to fold that 10 into code. Try the following: compile and run this code. Change the value of MAX and compile only I, then run again.

public interface I {
    int MAX = 10;
}
 
public class C implements I {
public static void main(String[] args) {
System.out.println(MAX);
}
}

As far as worrying about separate copyies of constants, why worry? I doubt if that could be a space issue.

[Baiju Varugese]

hi
thank you,

my consern with the space is my interface consists more than 100 variable and my most of the application classes implements this interface, so i think it as a poor design instead of that access directly Appinterface.var where ever it is required

[Jeff Albertson]

I think the results of inheriting the anti-pattern constants interfaces versus using the interface directly will be the same. Inheriting itself doesn't imply copying. I think what whereever you *use* a constant, there may be constant folding, but that doesn't take up space and in fact may save in both space and time as it facilittates further optimization.

On the other hand, good OOD would suggest that if these constants are global and not associated with any one class you should define them in a class:

public final class AppConstants {
    private AppConstants () {}
 
    public static final int MAX = 10;
}

If you don't like writing AppConstants.MAX elsewhere, you can use static imports.

Client code still will probably fold in constants at compile time. You can test that with the following program: run C, edit and compile only AppConstants and run C again.

public class C {
public static void main(String[] args) {
System.out.println(AppConstants.MAX);
}
}

To avoid this behavior (to make it easier to recompile and run, versus any worries of runtime size), you can write the constant class as follows.

public final class AppConstants {
    private AppConstants () {}
 
    public static final int MAX;
    
    static {
MAX = 10;
}
}

[Pratheep Nair]

If your class implements the constants interface, it becomes part of your concrete class's public API, which is not a good practice. Implementation details, such as using the static members of another class, should not leak into public APIs. As someone mentioned, if you are on 5.0, you can use static imports.

[Baiju Varugese]

Hi,

Thanks for All.

I think static imports works for me.

[thomas davis]

String is immutable,then why do we need to make it a public static final?
Is there any performance advantage or simply a best practice?

[Baiju Varugese]

string is immmutable if you change the value of the string then it will create a new string reference to avoid this

[Paul Clapham]

Originally posted by thomas davis:
String is immutable,then why do we need to make it a public static final?

The "final" modifier applied to a variable means the value of the variable can't be changed. This has nothing to do with whether the variable contains a reference to a mutable or immutable object. Example:

public static String name = "Bozo";
// later in the code...
name = "Fluffy";

is legal because name isn't final. No string objects are changed, they are immutable anyway. But

public static final String name = "Bozo";
// later in the code...
name = "Fluffy";

is not legal because name is final.