Just saying that from a completeness point of view, something like this would be required:

class Singleton {
    private volatile static Singleton instance;
    public static String str;
    private Singleton() {}
    
    static Singleton getSingleInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

This utilizes the "double-checked locking" design pattern, and guarentees the following for the singleton:

• Lazy initialization (great for resource allocation, and means we don't waste resources with eager initialization)
• No race condition for lazy initialization (two+ more threads each trying to create a singleton will fail, guarenteed by syncronized)
• Acquiring a lock (expensive operation) is done once and only once, thus there is no performance penalty
• Only allows the singleton to be used when it is fully instantiated (thanks to the volatile keyword there)

An even more clever way is this:

class Singleton{
	private Singleton() {}
    
    private static class SingletonHolder {
    	private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
    	return SingletonHolder.INSTANCE;
    }
}

The second way still retains all the requirements from the first, and is just more concise. (technically speaking it's a form of lazy initialization, since it eagerly initializes on demand).

More reading available here: cs.nyu.edu/courses/fall16/CSCI-UA.0470-001/slides/lecture25.pdf#page=52.

Java 8 (make sure to NOT remove the import statements foolishly like me or you will get errors):

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.lang.reflect.*;

class Singleton {
    private Singleton() {}
    public String str;
    private static Singleton instance = new Singleton();
    public static Singleton getSingleInstance() { return instance; }
}

Mine

class Singleton{
    public String str;
    private static Singleton instance = null;
    private Singleton(){
    }
    public static Singleton getSingleInstance(){
        if (instance==null) instance = new Singleton();
        return instance;
    }
}

Guys, why did my solution with static holder class had some weird assertion? It's definetely the best singleton implementation for Java:

class Singleton {
    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    private static class SingletonHolder {
        public static final Singleton INSTANCE = new Singleton();
    }
}

This Work's Fine...

public static String str;
    private Singleton(){}
    public static Singleton getSingleInstance()
    {   
        Singleton instance = new Singleton();
        return instance;
    }

import java.io.; import java.util.; import java.text.; import java.math.; import java.util.regex.; import java.lang.reflect.;

class Singleton{ static Singleton s= new Singleton(); String str="Hello I am a singleton! Let me say hello world to you"; private Singleton() {

}

public static Singleton getSingleInstance() { return s; }

}

class Driver { public static void main(String[] args) { Singleton singleObject= Singleton.getSingleInstance(); System.out.println(singleObject.str); } }

Here is my solution, have a look into it

class Singleton{

   //create an object of Singleton
   private static Singleton instance = new Singleton();
   public String str;
   //make the constructor private so that this class cannot be
   //instantiated
   private Singleton(){}

   //Get the only object available
   public static Singleton getSingleInstance(){
      return instance;
   }
}

To find solution visit.:- https://javagoodpractices.blogspot.com/2019/04/java-singleton-pattern.html

Hi, I have a quick question. This question maybe is dumb but I gotta ask. My first try was create the instance inside the function and return. It doesn't work. Therefore, what is difference between create it as private member and inside of function ?

class Singleton {

public String str;
private static Singleton singleton;

private Singleton() {}
public static Singleton getSingleInstance() {

    if(singleton == null) {
        singleton = new Singleton();
    }

    return singleton;
}

}