Diferencia entre el patrón Singleton y la clase estática en Java

Singleton Pattern pertenece al patrón de tipo Creacional. Como sugiere el nombre, el tipo de diseño creacional se ocupa de los mecanismos de creación de objetos. Básicamente, para simplificar esto, el patrón creacional nos explica la creación de objetos de una manera adecuada a una situación dada. El patrón de diseño Singleton se usa cuando necesitamos asegurarnos de que solo se crea una instancia de un objeto de una clase en particular. Esa única instancia creada es responsable de coordinar acciones en toda la aplicación.

Diferentes objetos que intentan invocar un objeto instanciado como singleton.

Si observa el diagrama ilustrado de arriba, verá diferentes objetos que intentan invocar un objeto instanciado como un singleton. Esta única instancia del objeto es responsable de invocar métodos o eventos subyacentes.

Las pautas para el patrón Singleton son las siguientes: 

ventajas:

• Singleton controla el acceso simultáneo al recurso.
• Garantiza que solo haya un objeto disponible en la aplicación en un estado controlado.

Implementación:

• Asegúrese de que solo exista una instancia de la clase.
• Proporcione una instancia global a ese acceso declarando que todos los constructores de la clase sean privados, proporcionando un método estático que devuelve una referencia a la instancia, y la instancia se almacena como una variable estática privada.

Ejemplo

// Java Program to illustrate Difference Between
// Singleton Pattern vs Static Class.
 
// Here illustrating Singleton Pattern
 
// Importing input output classes
import java.io.*;
 
// Class 1
// Helper class
class SingletonEagar {
 
    // Declaration and definition of variable occur
    // simultaneously
    //  Eager initialisation
    private static SingletonEagar instance
        = new SingletonEagar();
 
    // Private constructor of class 1
    private SingletonEagar() {}
 
    public static SingletonEagar getInstance()
    {
        return instance;
    }
}
 
// Class 2
// Helper Class
class Singleton {
 
    // Lazy  declaration and initialisation
    private static Singleton instance;
 
    // Private constructor of Class 2
    private Singleton() {}
 
    public static Singleton getInstance()
    {
 
        // Condition check
        // When instance is null
        // a new object of Singleton class is created
        if (instance == null) {
            instance = new Singleton();
        }
 
        return instance;
    }
}
 
// Class 3
// Helper class
class SingletonSynchronizedMethod {
 
    private static SingletonSynchronizedMethod instance;
 
    // Private constructor of Class 3
    private SingletonSynchronizedMethod() {}
 
    public static synchronized SingletonSynchronizedMethod
    getInstance()
    {
 
        // Condition check
        // When instance is null
        // a new object of Singleton class is created
        if (instance == null) {
            instance = new SingletonSynchronizedMethod();
        }
 
        return instance;
    }
}
 
// Class 4
// Helper class
class SingletonSynchronized {
 
    private static SingletonSynchronized instance;
 
    // Private constructor of Class 4
    private SingletonSynchronized() {}
 
    public static SingletonSynchronized getInstance()
    {
 
        // Again, condition check
        if (instance == null) {
 
            // synchronized block
            synchronized (SingletonSynchronized.class)
            {
 
                if (instance == null) {
                    instance = new SingletonSynchronized();
                }
            }
        }
        return instance;
    }
}
 
// Class 5
// Main class (SingletonExample)
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating instance in main() method of class 1
        SingletonEagar instance1
            = SingletonEagar.getInstance();
 
        // Display message only
        System.out.println(
            instance1
            + " : Singleton Eager initialisation ");
 
        // Creating instance in main() method of class 2
        Singleton instance2 = Singleton.getInstance();
 
        // Display message only
        System.out.println(
            instance2
            + " : Singleton Lazy initialisation ");
 
        // Creating instance in main() method of class 4
        SingletonSynchronized instance3
            = SingletonSynchronized.getInstance();
 
        // Display message only
        System.out.println(instance3
                           + " : Synchronized Singleton");
    }
}

SingletonEagar@2f4d3709 : Singleton Eager initialisation 
Singleton@1d81eb93 : Singleton Lazy initialisation 
SingletonSynchronized@34a245ab : Synchronized Singleton

Clase estática 

Las clases anidadas estáticas son clases anidadas que se declaran estáticas. En Java, las clases estáticas son una forma conveniente de agrupar clases. Java no le permite crear clases estáticas de alto nivel; solo clases anidadas (internas). Es por eso que una clase estática también se conoce como clase interna estática o clase anidada estática. 

Las pautas para la clase estática son las siguientes:

ventajas:

• Es posible definir las clases auxiliares o relacionadas dentro de la clase haciéndola estática.
• Puede acceder al miembro privado de la clase envolvente a través de la referencia del objeto.
• La clase estática proporciona un buen espacio de nombres para la clase anidada.
• Si la clase adjunta se actualiza, también podemos actualizar la clase estática en la misma ubicación.
• En JVM, Classloader carga la clase estática solo en el momento del primer uso, no cuando se carga su clase adjunta.

Implementación: 

• La clase estática solo puede ser una clase interna o una clase anidada.
• Las clases estáticas pueden usar cualquier tipo de modificador de acceso (privado, protegido, público o predeterminado) como cualquier otro miembro estático.
• Las clases estáticas solo pueden acceder a los miembros estáticos de su clase adjunta.
• La clase estática puede interactuar con el miembro no estático solo a través del objeto de su clase envolvente, ya que no puede acceder directamente a los miembros no estáticos de su clase envolvente.

Ejemplo 

// Java Program to illustrate Difference Between
// Singleton Pattern vs Static Class.
 
// Here illustrating Static Class
 
// Importing input output classes
import java.io.*;
 
// Class 1
// Helper Class
class GFG_Outer {
 
    // Custom input integer value
    static int x = 20;
 
    public static void display() { System.out.println(x); }
    // Class 2
    // Static inner class
 
    // Can access all static variables of outer class
    // Can't access non-static members
    static class GFG_Inner {
 
        GFG_Inner()
        {
 
            // Display message
            System.out.println(
                "This is Inner Class Constructor...");
 
            // Print the value of x from inside class thrown
            // on console
            System.out.println(
                "Value of \"x\" from inside Inner Class is : "
                + x);
        }
    }
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Printing value of x in the main() method
        System.out.println(GFG_Outer.x);
 
        // Calling display() method from class 1
        GFG_Outer.display();
 
        // static inner class object which is as follows:
        // OuterClass.InnerClass variable = new
        // OuterClass.InnerClass();
        GFG_Outer.GFG_Inner object
            = new GFG_Outer.GFG_Inner();
    }
}

20
20
This is Inner Class Constructor...
Value of "x" from inside Inner Class is : 20

Ahora hemos entendido los conceptos y el funcionamiento de ambos y hemos visto diferencias concluyentes en ambos. Ahora terminemos ilustrando todas las diferencias en un formato tabular que es el siguiente: