Java Singleton-klasse

In deze tutorial leren we Singleton Design Pattern in Java te implementeren met behulp van voorbeelden.

In Java is Singleton een ontwerppatroon dat ervoor zorgt dat een klasse maar één object kan hebben.

Om een singleton-klasse te maken, moet een klasse de volgende eigenschappen implementeren:

Maak een private constructor van de klasse om het maken van objecten buiten de klasse te beperken.
Maak een private attribuut van het klassetype dat verwijst naar het enkele object.
Maak een public static methode waarmee we het object dat we hebben gemaakt, kunnen maken en openen. Binnen de methode zullen we een voorwaarde creëren die ons verhindert om meer dan één object te creëren.

Voorbeeld:Java Singleton Class-syntaxis

class SingletonExample {

   // private field that refers to the object
   private static SingletonExample singleObject;
                                              
   private SingletonExample() {
      // constructor of the SingletonExample class
   }

   public static SingletonExample getInstance() {
      // write code that allows us to create only one object
      // access the object as per our need
   }
}

In het bovenstaande voorbeeld,

private static SingletonExample singleObject - een verwijzing naar het object van de klasse.
private SingletonExample() - een privéconstructor die het maken van objecten buiten de klasse beperkt.
public static SingletonExample getInstance() - deze methode retourneert de verwijzing naar het enige object van de klasse. Sinds de methode statisch , het is toegankelijk via de klassenaam.

Gebruik van Singleton in Java

Singletons kunnen worden gebruikt tijdens het werken met databases. Ze kunnen worden gebruikt om een verbindingspool te maken om toegang te krijgen tot de database, terwijl dezelfde verbinding voor alle clients wordt hergebruikt. Bijvoorbeeld,

class Database {
   private static Database dbObject;

   private Database() {      
   }

   public static Database getInstance() {

      // create object if it's not already created
      if(dbObject == null) {
         dbObject = new Database();
      }

       // returns the singleton object
       return dbObject;
   }

   public void getConnection() {
       System.out.println("You are now connected to the database.");
   }
}

class Main {
   public static void main(String[] args) {
      Database db1;

      // refers to the only object of Database
      db1= Database.getInstance();
      
      db1.getConnection();
   }
}

Wanneer we het programma uitvoeren, is de uitvoer:

You are now connected to the database.

In ons bovenstaande voorbeeld,

We hebben een singleton-klasse gemaakt Database .
Het dbObject is een klassetype veld. Dit verwijst naar het object van de klasse Database .
De privéconstructor Database() voorkomt het maken van objecten buiten de klas.
De statische klassetypemethode getInstance() geeft de instantie van de klasse terug aan de buitenwereld.
In de Hoofd class, we hebben class type variabele db1 . We bellen getInstance() met behulp van db1 om het enige object van de Database te krijgen .
De methode getConnection() is alleen toegankelijk via het object van de Database .
Sinds de Database kan slechts één object hebben, alle clients hebben toegang tot de database via een enkele verbinding.

Singleton is een ontwerppatroon in plaats van een functie die specifiek is voor Java. Een ontwerppatroon is als onze codebibliotheek die verschillende coderingstechnieken bevat die door programmeurs over de hele wereld worden gedeeld.

Het is belangrijk op te merken dat er maar een paar scenario's (zoals loggen) zijn waarin singletons zinvol zijn. We raden je aan om singletons helemaal te vermijden als je niet zeker weet of je ze wel of niet moet gebruiken. Meer informatie:wat is er zo erg aan Singleton?

Java anonieme klasse Java-opsommingen

Java