Inleiding tot Singleton Class op Java
De klasse Singleton beperkt het maken van objecten voor een klasse tot slechts één in de Java virtuele machine. Het helpt ook bij het bieden van een wereldwijd toegangspunt tot het object. Dit ontwerppatroon wordt vaak gebruikt in caching, Abstract Factory, logging, Prototype, enz. Het wordt ook gebruikt in kern Java-klassen zoals java.awt.Desktop, java.lang.Runtime. In java.lang.Runtime biedt Java een klasse Runtime die de huidige Runtime-omgeving aangeeft waar de toepassing wordt uitgevoerd. Dit helpt bij het koppelen van de applicatie- en runtime-omgeving. Er zou één object moeten zijn omdat de JRE uniek is. In java.awt.Desktop stelt klasse Desktop toepassingen in staat een URI of een bestand te starten met de standaardbrowser van de gebruiker, e-mailclient, etc. Ook hier moet er slechts één instantie van de klasse zijn.
Hoe Singleton Class werkt op Java
Singleton Class kan op twee manieren worden gemaakt.
- Stel de constructor in als privé om het maken van een object te beperken.
- Maak een statische methode om een exemplaar van het object te krijgen, zodat u alleen de creatie van een object binnen de klasse aankan.
Laten we nu het Class UML-diagram (Unified Modeling Language) van Singleton Class bekijken.
In het Class UML-diagram vertegenwoordigt de eerste partitie de naam van een klasse, de tweede partitie de attributen en de derde partitie de methoden. + Geeft ook openbare kenmerken of methoden aan en - geeft privékenmerken of -methoden aan. In ons Singleton Class UML-diagram is de klassennaam Singleton en deze heeft een hoofdmethode. Hoofdmethode, getInstance-methode en sampleMethod zijn de enige methoden die openbaar zijn in het bovenstaande diagram. Het kenmerk Constructor en instance is ingesteld als privé als onderdeel van onze implementatie. Deze openbare hoofdmethode vraagt om de instantie en getInstance geeft deze terug naar de hoofdmethode.
Op basis van Instantiation is het enige verschil tussen de normale Java Class en Singleton Class dat we een constructor in Java Class gebruiken, terwijl we in Singleton de methode getInstance () gebruiken.
Singleton ontwerppatroon bestaat uit twee vormen.
- Lazy Instantiation: instantie maken wanneer nodig
- Vroege instantiatie: het maken van exemplaren tijdens het laden.
1. Luie instantiatie
In Lazy Instantiation wordt een klasse-instantie gemaakt wanneer deze nodig is. Het is gemaakt in de gesynchroniseerde methode of blok om de race-omstandigheden te voorkomen die kunnen optreden in een multi-threaded omgeving.
2. Vroege instantiatie
In Early Instantiation wordt een exemplaar gemaakt tijdens het laden. Hoewel dit de eenvoudigste aanpak is, heeft het een nadeel dat het maken van een instantie ongeacht is of deze wordt geopend of niet.
Een voorbeeld van Lazy Instantiation en Early Instantiation wordt in de volgende sectie uitgelegd.
Implementatie van Singleton Class in Java
Zoals hierboven besproken, kan Singleton Class worden gemaakt in Early Instantiation of Lazy Instantiation.
Lazy Instantiation
Hierna volgen de stappen om de Lazy Instantiation te implementeren
1. Stel Constructor in als privé.
We maken bijvoorbeeld een klasse LazyClass. De constructor zal zijn zoals hieronder getoond.
private LazyClass ()
(
)
2. Maak een statische privé-instantie voor de gemaakte klasse.
private static LazyClass instance;
3. Maak een statische gesynchroniseerde methode waarmee de klasse-instantie wordt gemaakt.
public static synchronized LazyClass getInstance()
(
)
4. Controleer in de methode getInstance () eerst of een exemplaar aanwezig is of niet. Als er geen wordt gevonden, maakt u er een. Anders geef de instantie terug.
if(instance == null)
(
instance = new LazyClass ();
)
return instance;
Laten we er nu naar kijken met behulp van voorbeeldcode.
//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();
)
)
Output:
In plaats van een instantie te maken tijdens het laden, wordt deze hier in het gesynchroniseerde blok gemaakt. Voor een beter begrip wordt ook een voorbeeldmethode gegeven die wordt beschermd tegen het maken van meerdere objecten.
Vroege instantiatie
Laten we nu de stappen voor vroege instantiëring bekijken. Het is vergelijkbaar met Lazy instantiation, behalve dat het geen gesynchroniseerde methode of blok gebruikt.
1. Stel Constructor in als privé.
We maken bijvoorbeeld een klasse EarlyClass. De constructor zal zijn zoals hieronder getoond.
private EarlyClass () ()
(
)
2. Maak een statische privé-instantie voor de gemaakte klasse.
private static EarlyClass ins = new EarlyClass();
3. Maak een statische methode waarmee de klasse-instantie wordt gemaakt.
public static EarlyClass getInstance()
(
)
Hierna volgt de voorbeeldcode voor Early Instantiation.
//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();
)
)
Output:
In het bovenstaande programma wordt een instantie gemaakt in laadtijd en deze wordt geretourneerd met de methode getInstance (). Bovendien is Constructor ingesteld als privé als onderdeel van singleton-instantiatie.
Geheugenbesparing is het belangrijkste voordeel van het gebruik hiervan omdat een object opnieuw wordt gebruikt en niet steeds opnieuw wordt gemaakt.
Conclusie
In dit document hebben we besproken hoe een Singleton Class werkt met behulp van Class UML-diagram, algoritme en voorbeeldcode. Singleton Class wordt gebruikt wanneer we slechts één object nodig hebben voor een klasse en een wereldwijd toegangspunt tot dat object. De twee vormen zoals Early instantiation en Lazy Instantiation kunnen worden gebruikt op basis van de vereiste.
Aanbevolen artikelen
Dit is een gids voor Singleton Class op Java. Hier bespreken we hoe de singleton-klasse in Java werkt, samen met de implementatie die luie instantiatie en vroege instantiatie omvat. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -
- Wat is ontwerppatroon in Java?
- Abstracte klasse in Java
- Java-annotaties
- BorderLayout in Java
- JRE vs JVM | Top 8 verschillen met (infographics)
- Hoe statische methode in JavaScript te werken?