Use of private constructor to prevent instantiation of class?

Question

Hi guys!

Right now I'm thinking about adding a private constructor to a class that only holds some String constants.

public class MyStrings {
  // I want to add this:
  private MyString() {}

  public static final String ONE = "something";
  public static final String TWO = "another";
  ...
}

Is there any performance or memory overhead if I add a private constructor to this class to prevent someone to instantiate it?

Do you think it's necessary at all or that private constructors for this purpose are a waste of time and code clutter?

UPDATE

I'm going for a final class with private constructor and a descriptive javadoc for the class. I can't use a ENUM (which I'd prefer) because I'm stuck on Java 1.4 for now. This would be my modification:

/**
 * Only for static access, do not instantiate this class.
 */
public final class MyStrings {
  private MyString() {}

  public static final String ONE = "something";
  public static final String TWO = "another";
  ...
}

Answer 1

A synthetic public constructor would have been generated any way. So no.

Really a few bytes out of hundreds of millions at runtime isn't going to make much difference.

I also suggest making the class final and just for completeness have the constructor throw an exception.

If you want terse source code, you could create an enum with no values. Might cause some confusion with beginner programmers though.

Answer 2

I would rather use an enum to hold that Strings. This would ensure that wherever you use that Strings, you only get passed in one of the allowed Strings.

Answer 3

That's the right way to store some constants, as also suggested in Effective Java (2nd Ed.), item 19.

Answer 4

If your class has only static members, then there is no need to have a private or public constructor. All members are accessible even without an object. In fact I find it confusing to have a constructor in such a case.

Answer 5

If you don't won't anyone to make an object of the class you could make it abstract like this

public abstract class MyStrings {
  public static final String ONE = "something";
  public static final String TWO = "another";
}

and access your static variables like this

String val1 = MyStrings.ONE;
String val2 = MyStrings.TWO;

I think this would be a nicer solution.

Answer 6

You could add a private constructor, but there are two other options.

In the same situation I would use an enumerator. If it makes sense to your implementation, you could use that instead, if it's public or private depends on where you need to use it:

public enum MyStrings {

  ONE ("something"),

  TWO ("something else");

  private String value;

  private MyStrings(String str) {
     this.value = str;
  }

}

Another option would be to put it in an abstract class, those can not be instantiated:

public abstract MyStrings {

  public static final String STUFF = "stuff";
  public static final String OTHER = "other stuff";
}

Access for both enumerator and abstract class works just like with the implementation you presented:

MyStrings.STUFF

Answer 7

There is no performance or memory overhead if you add a private constructor in this case. As well, it is not needed since your public static variables are shared among all instances of your object.

Answer 8

Use of private constructor to prevent instantiation of class?

There are several ways you can think of users preventing from the Instantiations for the purpose of creating the Constants

1. As you have mentioned a class with the private Constructors and has all the string contants, is one way, even there ia a overhead, that can be negligible
2. Else you can create a Class with Final Modidifier and Define your string constants
3. You can use the Abstract Class with the String Constants
4. You can define the string constants in the properties files and can access from that, this will defnitely reduce the memory and increase the flexibility of your code.