Comment créer une seule instance d'une classe dans…

Pour créer une seule instance d'une classe en Android, le pattern Singleton est généralement utilisé.

Il existe plusieurs façons d'implémenter le Singleton :

Initialisation paresseuse avec synchronisation :

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // Le constructeur privé empêche la création d'autres instances
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Avantages : Sûr pour les threads.
Inconvénients : La synchronisation peut réduire la performance lors d'appels fréquents.

Initialisation lors du chargement de la classe (initialisation eager) :
```
public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}
```
- Avantages : Sûr pour les threads sans synchronisation explicite. Plus simple.
- Inconvénients : L'instance est créée dès le chargement de la classe, même si elle n'est pas utilisée.

Verrouillage à double vérification :

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Avantages : Meilleure performance que la synchronisation simple, initialisation uniquement si nécessaire.
Inconvénients : Nécessite volatile pour un fonctionnement correct en environnement multithread (depuis Java 5). Plus complexe.

Classe interne statique :

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        public static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

Avantages : Sûr pour les threads, initialisation paresseuse, facile à implémenter. La méthode la plus recommandée dans les versions modernes de Java.

Utilisation d'Enums :
```
public enum Singleton {
    INSTANCE;

    // Ajoutez des méthodes à la classe
    public void doSomething() {
        // ...
    }
}
```
- Avantages : La méthode la plus simple et sûre pour les threads, résistante à la sérialisation et à la réflexion. Considérée comme une bonne pratique.

Le choix de l'implémentation dépend des exigences spécifiques en termes de performance et de complexité. En Android, les Enum ou classes internes statiques sont souvent utilisés.

Comment créer une seule instance d'une classe dans Android?