Introdução à classe Singleton em Java
A classe Singleton restringe a criação do objeto de uma classe para apenas uma na máquina virtual java. Também ajuda a fornecer um ponto de acesso global ao objeto. Esse padrão de design é comumente usado em cache, Abstract Factory, log, Prototype etc. Ele também é usado em classes java principais, como java.awt.Desktop, java.lang.Runtime. No java.lang.Runtime, Java fornece uma classe Runtime que significa o Runtime Environment atual em que o aplicativo está sendo executado. Isso ajuda na interface do aplicativo e do ambiente de tempo de execução. Deve haver um objeto, pois o JRE é único. No java.awt.Desktop, a classe Desktop permite que os aplicativos iniciem um URI ou um arquivo com o navegador padrão do usuário, cliente de email etc. Aqui também deve haver apenas uma instância da classe.
Como a classe Singleton funciona em Java
A Classe Singleton pode ser criada de duas maneiras.
- Defina o construtor como privado para limitar a criação de um objeto.
- Crie um método estático para obter uma instância do objeto, para que você possa manipular a criação do objeto somente dentro da classe.
Agora, vamos ver o diagrama da classe UML (Unified Modeling Language) da classe Singleton.
No diagrama UML de classe, a primeira partição representa o nome de uma classe, a segunda partição representa os atributos e a terceira partição representa os métodos. Além disso, + indica atributos ou métodos públicos e - indica atributos ou métodos privados. Em nosso diagrama UML de classe Singleton, o nome da classe é Singleton e possui um método principal. O método principal, getInstance Method e sampleMethod são os únicos métodos públicos no diagrama acima. O atributo construtor e instância é definido como privado como parte de nossa implementação. Esse método Main público solicita a instância e getInstance o retorna ao método principal.
Com base na instanciação, a única diferença entre a classe Java normal e a classe Singleton é que usaremos um construtor na classe Java, enquanto que no Singleton usaremos o método getInstance ().
O padrão de design Singleton é de duas formas.
- Instanciação Preguiçosa: criação da instância quando necessário
- Instanciação Antecipada: criação da instância no tempo de carregamento.
1. Instanciação Preguiçosa
No Lazy Instantiation, uma instância de classe é criada quando é necessária. Ele é criado no método ou bloco Sincronizado para evitar as condições de corrida que podem ocorrer em um ambiente multithread.
2. Instanciação Antecipada
No Early Instantiation, uma instância é criada no tempo de carregamento. Embora essa seja a abordagem mais simples, há uma desvantagem de que a criação da instância seja, independentemente de ser acessada ou não.
Um exemplo de instanciação lenta e instanciação precoce é explicado na seção a seguir.
Implementação da Classe Singleton em Java
Conforme discutido acima, a Classe Singleton pode ser criada em Instanciação precoce ou Instância lenta.
Instanciação preguiçosa
A seguir, estão as etapas para implementar o Lazy Instantiation
1. Defina o Construtor como privado.
Por exemplo, estamos criando uma classe LazyClass. O construtor será como mostrado abaixo.
private LazyClass ()
(
)
2. Crie uma instância estática privada para a classe criada.
private static LazyClass instance;
3. Crie um método estático sincronizado que obtenha a instância da classe criada.
public static synchronized LazyClass getInstance()
(
)
4. No método getInstance (), primeiro verifique se há alguma instância presente ou não. Se não encontrado, crie um. Caso contrário, retorne a instância.
if(instance == null)
(
instance = new LazyClass ();
)
return instance;
Agora, vamos analisar usando código de exemplo.
//Java Program for Lazy Instantiation
public class LazyClass (
private static LazyClass instance;
//set the constructor as private
private LazyClass () ()
//Checks whether an instance is already in the getInstance method
public static synchronized LazyClass getInstance() (
//if instance is not present already, create a new one
if(instance == null) (
instance = new LazyClass ();
)
// if an instance is present, then return it
return instance;
)
//Sample method that is protected from more than one object creation
public void sampleMethod( ) (
System.out.println("sampleMethod for lazy singleton");
)
public static void main(String() args) (
LazyClass temp=LazyClass.getInstance();
temp.sampleMethod();
)
)
Resultado:
Aqui, em vez de criar uma instância no tempo de carregamento, ela é criada dentro do bloco sincronizado. Para melhor entendimento, também é fornecido um método de amostra que é protegido contra mais de uma criação de objeto.
Instanciação Antecipada
Agora vamos ver as etapas para a instanciação antecipada. É semelhante à instanciação lenta, exceto pelo fato de não usar nenhum método ou bloco sincronizado.
1. Defina o Construtor como privado.
Por exemplo, estamos criando uma classe EarlyClass. O construtor será como mostrado abaixo.
private EarlyClass () ()
(
)
2. Crie uma instância estática privada para a classe criada.
private static EarlyClass ins = new EarlyClass();
3. Crie um método estático que obtenha a instância da classe criada.
public static EarlyClass getInstance()
(
)
A seguir, é apresentado o código de exemplo da Instanciação Antecipada
//Java Program for Early Instantiation
public class EarlyClass (
//Create an instance of the class at load time
private static EarlyClass ins = new EarlyClass();
//set the constructor as private
private EarlyClass () ()
//A static method to get the instance
public static EarlyClass getInstance() (
return ins ;
)
//A sample method that is protected from more than one object creation
public void sampleMethod() (
System. out .println("sampleMethod for Early singleton");
)
//Main method
public static void main(String() args) (
EarlyClass tmp = getInstance ();
tmp.sampleMethod();
)
)
Resultado:
No programa acima, uma instância é criada no tempo de carregamento e é retornada usando o método getInstance (). Além disso, o Construtor é definido como privado como parte da instanciação de singleton.
A economia de memória é a principal vantagem de usá-lo como um objeto que é reutilizado e não é criado repetidamente.
Conclusão
Neste documento, abordamos como uma classe Singleton funciona com a ajuda do diagrama, algoritmo e código de amostra da classe UML. A Classe Singleton é usada quando precisamos apenas de um objeto para uma classe e um ponto de acesso global a esse objeto. As duas formas, como Instanciação precoce e Instância lenta, podem ser usadas com base no requisito.
Artigos recomendados
Este é um guia para a classe Singleton em Java. Aqui discutimos como a classe singleton funciona em java junto com a implementação, que inclui instanciação lenta e instanciação precoce. Você também pode consultar nossos outros artigos sugeridos para saber mais -
- O que é Design Pattern em Java?
- Classe abstrata em Java
- Anotações Java
- BorderLayout em Java
- JRE vs JVM | As 8 principais diferenças com (infográficos)
- Como trabalhar o método estático em JavaScript?