Here is the class declaration and it contains just one variable. A private and static instance of an object that is the same type as the class itself.

class SingletonClass {

private static SingletonClass mOurInstance;
}

The name of the class is not relevant just that the name of the class is the same as the type being declared.

Next, we can look at the constructor method.

private SingletonClass() {
   // This is only here to prevent instantiation
}

It has the same name as the class as do all constructor methods but note it is private. When a method is private it can only be called by code within the class. Note that depending upon the needs of the project, it is perfectly acceptable to have some code in the constructor, just as long as the constructor is private.

This next method is default access and returns an object of type SingletonClass. Take a look over the code.

// Calling this method is the only way to get a SingletonClass
static SingletonClass getInstance(Context context) {
   
   if(mOurInstance == null) {
          mOurInstance = new SingletonClass();
   }

   return mOurInstance;
}

As the class is default access, any code in the same package can call the method. In addition, because it is static, it can be called without an instance of the class. Now look at the code in the body. The first line checks whether the private member, mOurInstance has been initialized with if(mOurInstance == null). If the object has not been initialized (is null) then the private constructor is called, and the instance is initialized. The final line of code returns a reference to the private instance. Also note as will be the case in the platform game, it might not even be necessary to return an instance.

Now we add a method that actually does something. After all, a class must have a purpose.

static void someUsefulMethod() {
   // Do something useful
}

Note the previous method, someUsefulMethod is static so it too, like getInstance can be called without a reference to the class. This is why I said the getInstance method doesn't necessarily have to return an instance of the class.

Next, we add another method. Note that it is not static.

void someOtherUsefulMethod() {
   // Do something else useful
}

As someOtherUsefulMethod is not static, an instance of the class would be needed in order to call it. So, in this specific case getInstance would need to return a reference to the object.

Now let's see how we could use our new class in some other class of our project. First, we declare an instance of SingletonClass but as we cannot call the constructor we initialize it by calling the static getInstance method.

SingletonClass sc = SingletonClass.getInstance();

The getInstance method will check whether the member SingletonClass object needs to be initialized and if required calls the constructor. Either way, getInstance returns a reference to the private member instance of SingletonClass which initializes sc.

Now we can use the two methods that actually do something useful.

// Call the static method
SingletonClass.someUsefulMethod();

// Call the other method
sc.someOtherUsefulMethod();

The first method, someUsefulMethod is called without using a reference because it is static. The second method is called using the sc reference we initialized using getInstance.

Next, we will learn about the Java HashMap class and then we will get to code a Singleton for real.