SingleTon Class creating more than one object when called from outside the class

Question

I wrote a program to call a singleton class from inside the class main. I also wrote an other class from which I am trying to create a object for the Singleton class. I found that I am able to create only one object when I tried from the other class but when I tried to call the method from the same class it creates more than one object. I couldnt understand what is different from same class main method and other class main method. Here are the classes:

SingleTonClass.java

public class SingleTonClass {

    private static SingleTonClass obj = null;

    private SingleTonClass() {
        System.out.println("Private Constructor is called");
    }

    public static SingleTonClass CreateObj() {
        if (obj == null) {
            obj = new SingleTonClass();
        }
        return obj;
    }

    public void display() {
        System.out.println("The Ojecte creation complete");
    }

    public void display1() {
        System.out.println("The second obj creation is comeplete");
    }

    public static void main(String[] args) {
        SingleTonClass stc = new SingleTonClass();
        SingleTonClass stc1 = new SingleTonClass();
        SingleTonClass stc2 = new SingleTonClass();
        // stc.display();
        // stc1.display1();

    }
}

SingleTonClassTest.java

public class SingleTonClassTest {

    public static void main(String[] args) {
        SingleTonClass stc=SingleTonClass.CreateObj();
        SingleTonClass stc1=SingleTonClass.CreateObj();
        SingleTonClass stc2=SingleTonClass.CreateObj();
    }
}

Answer 1

Rather than doing:

private static SingleTonClass obj=null;

You should use: (sorry for changing your weird class name at the same time).

private static final Singleton INSTANCE = new Singleton();

To instantiate the only instance of your Singleton.

After that, you are not going to do some mystical retrieval like:

public static SingleTonClass CreateObj()
    {
        if (obj==null)
        {
            obj= new SingleTonClass();
        }
        return obj;
    }

Instead, you should define getInstance() method for retrieving your Singleton.

public static Singleton getInstance() {
    return INSTANCE;
}

After these modiciations, your Singleton class should look like the following:

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {
        // This is called only once
        System.out.println("Private Constructor is called");
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {

        // Even if you ask 100 times, this will only return the same INSTANCE
        Singleton stc  = Singleton.getInstance();
        Singleton stc1 = Singleton.getInstance();
        Singleton stc2 = Singleton.getInstance();

    }

}

And running it will, output:

Private Constructor is called

to your cmd or terminal.

As a final note, as @Swapnil stated already: private Singleton() { ... } declaration is used to indicate that only the Singleton class itself is able to create the instance, which makes sense and rather than doing private static final Singleton INSTANCE = new Singleton(); you can further optimize your code by using an enum constant to store instance (noted by @JonK). For further reading I recommend: singleton pattern in java

Cheers.

Answer 2

The whole point of having a private constructor in implementing a singleton pattern is that you shouldn't be able to invoke it from outside the class, to avoid object creation directly. You're invoking it from inside the class. Hence, the problem.

Singleton is no magic, you need to have a method like getInstance() inside your singleton and this method should ensure there's only once instance.

Answer 3

Rather than creating new object of Singleton class every time get the instance of singleton class. There are various ways to define singleton class. Here is one way to crate thread safe Singleton class. for more check out this link http://www.journaldev.com/1377/java-singleton-design-pattern-best-practices-examples#bill-pugh-singleton

public class BillPughSingleton {

private BillPughSingleton(){}

private static class SingletonHelper{
    private static final BillPughSingleton INSTANCE = new BillPughSingleton();
}

public static BillPughSingleton getInstance(){
    return SingletonHelper.INSTANCE;
}

}

Answer 4

Singleton Class: We can create only one object of this class.

Let's take an example:Since every thing in Java is object so I am giving you a real life example. You have a house and there is lock in it. This lock has only one key and if any one from outside wants to enter or access any thing in your house then he should have that unique key. Means this constraint applies only on outsiders. If anyone already present in the house then he can do anything and there is no restriction for him.

In the same way private constructor does not let any anyone to create second object of that class but you can make multiple objects within the same class because private methods only accessed by same class.

Singleton is Design pattern and here in your code design is like this, CreateObj() is static method of SingletonClass which checks if object is null then create the object by calling the constructor otherwise it is returning the same object.

Answer 5

You can not make objects of singleton class outside the class because the constructor is private. Constructor instantiate the object. if the constructor itself is private then the object will never be instantiated outside the class rather you can use getInstance method. then you can access its features outside the class.