Private Constructors

A railway station has exactly one station master's office; you can't open a second one by walking in and asking. Some classes need that kind of control over how their objects are made, or whether they're made at all. Marking a constructor private means only code inside the class can call it. Other code can't write new, and the class decides how objects come into existence.

Three Reasons to Make a Constructor Private

A Utility Class

public class Gst {
    static class GstUtil {
        private GstUtil() {}
 
        static long tax(long amount, int ratePercent) {
            return amount * ratePercent / 100;
        }
    }
 
    public static void main(String[] args) {
        System.out.println("GST on Rs. 2000: Rs. " + GstUtil.tax(2000, 18));
    }
}

GST on Rs. 2000: Rs. 360

Line 3 makes the constructor private, so new GstUtil() from another class fails:

Priv.java:2: error: Util() has private access in Util
public class Priv { public static void main(String[] a) { new Util(); } }
                                                          ^

Factory Methods with Rules

public class Fares {
    static class Fare {
        final int km;
 
        private Fare(int km) {
            this.km = km;
        }
 
        static Fare of(int km) {
            if (km <= 0) {
                throw new IllegalArgumentException("Distance must be positive");
            }
            return new Fare(km);
        }
 
        int rupees() { return km * 2; }
    }
 
    public static void main(String[] args) {
        System.out.println("300 km: Rs. " + Fare.of(300).rupees());
    }
}

300 km: Rs. 600

Outside code can only use Fare.of(...), so every Fare goes through the check. The name of also reads better than a bare new.

A Singleton

public class Config {
    static class AppConfig {
        private static final AppConfig INSTANCE = new AppConfig();
        final String currency = "INR";
 
        private AppConfig() {}
 
        static AppConfig getInstance() { return INSTANCE; }
    }
 
    public static void main(String[] args) {
        AppConfig a = AppConfig.getInstance();
        AppConfig b = AppConfig.getInstance();
        System.out.println(a.currency + ", same object: " + (a == b));
    }
}

INR, same object: true

How it works

1. Line 3 creates the only AppConfig object when the class is loaded, and keeps it in a static final field.
2. Line 6: the private constructor stops anyone else from making another.
3. Line 8: everyone gets the same object through getInstance(), as a == b shows.

Try it yourself: add a counter to the private constructor and call getInstance() five times. How many times does the constructor run?

Common Mistakes

Forgetting the private constructor on a utility class. The compiler adds a public one, and new GstUtil() becomes possible.

Thinking private stops all creation. Reflection can still call a private constructor; serialization and cloning also create objects. Singletons that must be bulletproof use an enum.

Making a constructor private but no factory method. Then nobody, not even you, can get an object.

Interview Corner

Practice

1. Easy: Write a utility class Temp with a private constructor and static methods cToF and fToC.
2. Harder: Write a class PinCode with a private constructor and a factory method of(String digits) that accepts only exactly six digits.

Key Takeaways