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

// 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");
    }
}
Producción

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

// 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();
    }
}
Producción

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:

Patrón único Clase estática
Singleton es un patrón de diseño. Las clases estáticas son básicamente una forma de agrupar clases en Java.
La memoria se asigna una vez que se crea el objeto. La memoria se asigna inmediatamente después de acceder a cualquiera de los miembros de la clase.
La implementación de Singleton puede tener miembros estáticos o miembros de instancia. Las clases estáticas solo pueden contener miembros estáticos.
Puede implementar cualquier otra interfaz o clase base que se requiera. No puede implementar la interfaz ni ninguna otra clase base.
Las clases Singleton se pueden utilizar como parámetro de método. La clase estática no se puede utilizar como parámetro de método. 
El patrón Singleton usa la memoria Heap. Las clases estáticas usan memoria de pila.
Funciona dentro del ámbito de Garbage Collector, ya que utiliza memoria Heap. Fuera del alcance de Garbage Collector ya que usa memoria de pila.
Es compatible con la implementación de inyección de dependencia (DI) ya que Singleton sigue los conceptos de OOPS. No puede implementar la Inyección de dependencia (DI) ya que la DI está impulsada por la interfaz.
Singleton es un patrón arquitectónico y no una característica del lenguaje. La estática es una característica del lenguaje y no un patrón arquitectónico.
La eliminación de objetos es posible. No puede deshacerse de la clase estática ya que no se ha creado ninguna instancia.

Publicación traducida automáticamente

Artículo escrito por vanshitatwr620 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *