Classe Singleton en Java

La classe Singleton restreint la création d'objets pour une classe à un seul dans la machine virtuelle Java. Cela aide également à fournir un point d’accès global à l’objet. Ce modèle de conception est couramment utilisé dans la mise en cache, Abstract Factory, la journalisation, le prototype, etc. Il est également utilisé dans les classes Java principales telles que java.awt.Desktop, java.lang.Runtime. Dans java.lang.Runtime, Java fournit une classe Runtime qui désigne l'environnement d'exécution actuel dans lequel l'application est exécutée. Cela aide à interfacer l’application et l’environnement d’exécution. Il ne devrait y avoir qu'un seul objet car le JRE est unique. Dans java.awt.Desktop, la classe Desktop permet aux applications de lancer une URI ou un fichier avec le navigateur, le client de messagerie par défaut de l'utilisateur, etc. Ici aussi, il ne doit y avoir qu'une seule instance de la classe.

Comment fonctionne la classe Singleton en Java ?

La classe Singleton peut être créée de deux manières.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

1. Définissez le constructeur comme privé afin de limiter la création d'un objet.
2. Créez une méthode statique pour obtenir une instance de l'objet afin de pouvoir gérer la création de l'objet à l'intérieur de la classe uniquement.

Voyons maintenant le diagramme de classe UML (Unified Modeling Language) de la classe Singleton.

Dans le diagramme Classe UML, la première partition représente le nom d'une classe, la deuxième partition représente les attributs et la troisième partition représente les méthodes. De plus, + indique des attributs ou des méthodes publics et – indique des attributs ou des méthodes privés. Par exemple, dans notre diagramme UML de classe Singleton, le nom de la classe est Singleton et possède une méthode principale. La méthode principale, la méthode getInstance et la méthode sampleMethod sont les seules méthodes publiques dans le diagramme ci-dessus. L'attribut constructeur et instance est défini comme privé dans le cadre de notre implémentation. Cette méthode publique Main demande l'instance et getInstance la renvoie à la méthode principale.

Basé sur l'instanciation, la seule différence entre la classe Java normale et la classe Singleton est que nous utiliserons un constructeur dans la classe Java alors que, dans Singleton, nous utiliserons la méthode getInstance().

Le modèle de conception de Singleton se présente sous deux formes.

• Instanciation paresseuse : Création d'instance si nécessaire
• Instanciation précoce : Création d'instance au moment du chargement.

1. Instanciation paresseuse

Dans Lazy Instantiation, une instance de classe est créée lorsqu'elle est requise. Il est créé dans la méthode ou le bloc Synchronisé afin d'éviter les conditions de concurrence qui peuvent survenir dans un environnement multithread.

2. Instanciation précoce

Dans Early Instanciation, une instance est créée au moment du chargement. Même s'il s'agit de l'approche la plus simple, elle présente l'inconvénient que la création de l'instance se fait indépendamment du fait qu'on y accède ou non.

Un exemple d'instanciation paresseuse et d'instanciation précoce est expliqué dans la section suivante.

Implémentation de la classe Singleton en Java

Comme indiqué ci-dessus, la classe Singleton peut être créée en instanciation précoce ou en instanciation paresseuse.

Instanciation paresseuse

Voici les étapes pour mettre en œuvre l'instanciation paresseuse.

1. Définissez le constructeur comme privé.

Par exemple, nous créons une classe, LazyClass. Le constructeur sera comme indiqué ci-dessous.

private LazyClass ()
{
}

2. Créez une instance statique privée pour la classe créée.

private static LazyClass instance;

3. Créez une méthode synchronisée statique qui crée l'instance de classe.

public static synchronized LazyClass getInstance()
{
}

4. Dans la méthode getInstance(), vérifiez d’abord si une instance est présente ou non. S’il n’est pas trouvé, créez-en un. Sinon, renvoyez l'instance.

if(instance == null)
{
instance = new LazyClass ();
}
return instance;

Maintenant, examinons-le à l'aide d'un exemple de code.

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

Sortie :

Ici, au lieu de créer une instance au moment du chargement, elle est créée à l'intérieur du bloc synchronisé. Pour une meilleure compréhension, un exemple de méthode est également donné, indiquant qu'elle est protégée contre plusieurs créations d'objets.

Instanciation précoce

Voyons maintenant les étapes de l'instanciation précoce. Elle est similaire à l'instanciation paresseuse, sauf qu'elle n'utilise aucune méthode ou bloc synchronisé.

1. Définissez le constructeur comme privé.

Par exemple, nous créons une classe, EarlyClass. Le constructeur sera comme indiqué ci-dessous.

private EarlyClass () ()
{
}

2. Créez une instance statique privée pour la classe créée.

private static EarlyClass <em>ins</em>= new EarlyClass();

3. Créez une méthode statique qui crée l'instance de classe.

public static EarlyClass getInstance()
{
}

Voici un exemple de code pour l'instanciation précoce.

//Java Program for Early Instantiation
public class EarlyClass {
//Create an instance of the class at load time
private static EarlyClass <em>ins</em>= 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();
}
}

Sortie :

Dans le programme ci-dessus, une instance est créée au moment du chargement et elle est renvoyée à l'aide de la méthode getInstance(). De plus, le constructeur est défini comme privé dans le cadre de l'instanciation singleton.

L'économie de mémoire est le principal avantage de son utilisation, car un objet est réutilisé et non créé encore et encore.

Conclusion

Dans ce document, nous avons expliqué le fonctionnement d'une classe Singleton à l'aide d'un diagramme UML de classe, d'un algorithme et d'un exemple de code. La classe Singleton est utilisée lorsque nous n'avons besoin que d'un seul objet pour une classe et d'un point d'accès global à cet objet. Les deux formes, telles que l'instanciation anticipée et l'instanciation paresseuse, peuvent être utilisées en fonction des besoins.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!