Singleton

• Ensure unique instance by defining class final to prevent cloning.
• May be extensible by the subclass by defining subclass final.
• Make a method or a variable public or/and static.
• Access to the instance by the way you provided.
• Well control the instantiation of a class.
• Define one value shared by all instances by making it static.
• Related patterns include
  • Abstract factory, which is often used to return unique objects.
  • Builder, which is used to construct a complex object, whereas a singleton is used to create a globally accessible object.
  • Prototype, which is used to copy an object, or create an object from its prototype, whereas a singleton is used to ensure that only one prototype is guaranteed.

Example

One file system, one window manager, one printer spooler, one Test engine, one Input/Output socket and etc.

To design a Singleton class, you may need to make the class final like java.Math, which is not allowed to subclass, or make a variable or method public and/or static, or make all constructors private to prevent the compiler from creating a default one.

For example, to make a unique remote connection,

final class RemoteConnection {
    private Connect con;
    private static RemoteConnection rc = new RemoteConnection(connection);
    private RemoteConnection(Connect c) { 
        con = c;
        ....
    }
    public static RemoteConnection getRemoteConnection() {
        return rc;
    }
    public void setConnection(Connect c) {
        this(c);
    }
}

usage:
RemoteConnection rconn = RemoteConnection.getRemoteConnection;
rconn.loadData();
...


The following statement may fail because of the private constructor
RemoteConnection con = new RemoteConnection(connection); //failed

//failed because you cannot subclass it (final class)
class Connection extends RemoteConnection {}

For example, to use a static variable to control the instance;

class Connection {
    public static boolean haveOne = false;
    public Connection() throws Exception{
        if (!haveOne) {
           doSomething();
           haveOne = true;
        }else {
          throw new Exception("You cannot have a second instance");
        }
    }
    public static Connection getConnection() throws Exception{
        return new Connection();
    }
    void doSomething() {}
    //...
    public static void main(String [] args) {
        try {
            Connection con = new Connection(); //ok
        }catch(Exception e) {
            System.out.println("first: " +e.getMessage());
        }
        try {
            Connection con2 = Connection.getConnection(); //failed.
        }catch(Exception e) {
            System.out.println("second: " +e.getMessage());
        }
    }
}

 C:\ Command Prompt

C:\> java Connection second: You cannot have a second instance

For example to use a public static variable to ensure a unique.

class Employee {
   public static final int companyID = 12345;
   public String address;
   //...
   
}
class HourlyEmployee extends Employee {
   public double hourlyRate;
   //....
}
class SalaryEmployee extends Employee {
   public double salary;
   //...
}
class Test {
   public static void main(String[] args) {
      Employee Evens = new Employee();
      HourlyEmployee Hellen = new HourlyEmployee();
      SalaryEmployee Sara = new SalaryEmployee();
      System.out.println(Evens.companyID == Hellen.companyID); //true
      System.out.println(Evens.companyID == Sara.companyID); //true
   }
}
 C:\ Command Prompt
 
C:\> java Test
true
true


The companyID is a unique and cannot be altered by all subclasses.  

Note that Singletons are only guaranteed to be unique within a given class
loader. If you use the same class across multiple distinct enterprise
containers, you'll get one instance for each container.

Return to top