Cum să creezi o singură instanță a unei clase în…

Pentru a crea o singură instanță a unei clase în Android, se folosește de obicei pattern-ul Singleton.

Există mai multe moduri de a implementa Singleton:

Inițializare leneșă cu sincronizare:

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // Constructor privat împiedică crearea altor instanțe
    }

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

Avantaje: Sigur pentru fire de execuție.
Dezavantaje: Sincronizarea poate reduce performanța în apelurile frecvente.

Inițializare la încărcarea clasei (Eager initialization):
```
public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}
```
- Avantaje: Sigur pentru fire de execuție fără sincronizare explicită. Mai simplu.
- Dezavantaje: Instanța este creată imediat la încărcarea clasei, chiar dacă nu este utilizată.

Blocare cu verificare dublă:

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;
    }
}

Avantaje: Performanță îmbunătățită față de sincronizarea simplă, inițializare doar dacă este necesar.
Dezavantaje: Necesită volatile pentru funcționare corectă în medii multi-thread (începând cu Java 5). Mai complex.

Clasă internă statică:

public class Singleton {
    private Singleton() {}

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

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

Avantaje: Sigur pentru fire de execuție, inițializare leneșă, ușor de implementat. Abordarea cea mai recomandată în versiunile moderne de Java.

Utilizarea Enumurilor:
```
public enum Singleton {
    INSTANCE;

    // Adăugați metode ale clasei
    public void doSomething() {
        // ...
    }
}
```
- Avantaje: Cel mai simplu și sigur mod pentru fire de execuție, rezistent la serializare și reflecție. Adesea considerat o bună practică.

Alegerea implementării depinde de cerințele specifice de performanță și complexitate. În Android, se folosesc adesea Enum sau clasă internă statică.

Cum să creezi o singură instanță a unei clase în Android?