Hoe maak je een enkele instantie van een klasse in…

Om een enkele instantie van een klasse in Android te maken, wordt meestal het Singleton-patroon gebruikt.

Er zijn verschillende manieren om Singleton te implementeren:

Lui initialisatie met synchronisatie:

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // Privé constructor voorkomt het maken van andere instanties
    }

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

Voordelen: Thread-veilig.
Nadelen: Synchronisatie kan de prestaties verminderen bij veelvuldig gebruik.

Initialisatie bij het laden van de klasse (Eager initialization):
```
public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}
```
- Voordelen: Thread-veilig zonder expliciete synchronisatie. Eenvoudiger.
- Nadelen: Het exemplaar wordt meteen gemaakt bij het laden van de klasse, ook als het niet wordt gebruikt.

Dubbele controle locking:

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

Voordelen: Betere prestaties dan eenvoudige synchronisatie, initialisatie alleen indien nodig.
Nadelen: Vereist volatile voor correcte werking in multithread-omgevingen (sinds Java 5). Complexer.

Statische innerlijke klasse:

public class Singleton {
    private Singleton() {}

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

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

Voordelen: Thread-veilig, lazy initialisatie, eenvoudig te implementeren. De meest aanbevolen aanpak in moderne Java-versies.

Gebruik van Enums:

public enum Singleton {
    INSTANCE;

    // Voeg methoden toe aan de klasse
    public void doSomething() {
        // ...
    }
}

Voordelen: De eenvoudigste en thread-veiligste manier, bestand tegen serialisatie en reflectie. Wordt vaak als best practice beschouwd.

De keuze van implementatie hangt af van de specifieke prestatie- en complexiteitseisen. In Android worden vaak Enum of statische innerlijke klasse gebruikt.

Hoe maak je een enkele instantie van een klasse in Android?