Coffee break #143. Mga selyadong klase sa Java 17. 4 na paraan para ipatupad ang Singleton

Mga selyadong klase sa Java 17

Source: Codippa Sa post na ito titingnan natin ang mga selyadong klase, isang bagong feature na ipinakilala sa Java 17, at kung paano ideklara at gamitin ang mga ito kasama ng mga halimbawa. Ang mga selyadong klase ay unang lumitaw sa Java 15 bilang isang tampok na preview, at nang maglaon sa Java 16 na may parehong katayuan. Ang tampok na ito ay naging ganap na gumagana sa paglabas ng Java 17 ( JEP 409 ).

Ano ang mga selyadong klase?

Ang isang selyadong klase ay nagbibigay-daan sa iyong paghigpitan o piliin ang mga subclass. Ang isang klase ay hindi maaaring mag-extend ng isang pribadong klase maliban kung ito ay nasa listahan ng parent class ng mga pinapayagang child class. Ang klase ay tinatakan gamit ang selyadong keyword . Ang selyadong klase ay dapat na sundan ng mga permit keyword, kasama ng isang listahan ng mga klase na maaaring pahabain ito. Narito ang isang halimbawa:

public sealed class Device permits Computer, Mobile {
}

Ang deklarasyon na ito ay nangangahulugan na ang Device ay maaari lamang i-extend ng mga klase ng Computer at Mobile . Kung ang anumang ibang klase ay sumusubok na palawigin ito, isang error sa compiler ang itatapon. Ang isang klase na nagpapalawak ng isang selyadong klase ay dapat mayroong pangwakas , selyadong , o hindi selyadong keyword sa deklarasyon nito . Kaya mayroon kaming isang nakapirming hierarchy ng klase. Paano ito nauugnay sa paggawa ng klase ng bata?

1. pangwakas ay nangangahulugang hindi na ito maaaring i-subclass pa.

2. selyadong nangangahulugan na kailangan nating magdeklara ng mga klase ng bata na may mga permit .

3. ibig sabihin ng hindi selyado na dito natin tinatapos ang hierarchy ng magulang-anak .

Halimbawa, pinahihintulutan ng Computer ang mga klase ng Laptop at Desktop hangga't ang Laptop mismo ay nananatiling hindi selyado . Nangangahulugan ito na ang Laptop ay maaaring i-extend ng mga klase tulad ng Apple , Dell , HP at iba pa.

Ang mga pangunahing layunin ng pagpapakilala ng mga selyadong klase ay:

1. Hanggang ngayon, maaari mo lamang limitahan ang extension ng isang klase gamit ang panghuling keyword . Kinokontrol ng isang selyadong klase kung aling mga klase ang maaaring pahabain ito sa pamamagitan ng pagsasama sa kanila sa pinapayagang listahan.

2. Pinapayagan din nito ang klase na kontrolin kung alin sa mga ito ang magiging mga child class nito.

Mga tuntunin

Ilang panuntunang dapat tandaan kapag gumagamit ng mga selyadong klase:

1. Ang isang selyadong klase ay dapat tukuyin ang mga klase na maaaring palawigin ito gamit ang mga permit . Hindi ito kinakailangan kung ang mga child class ay tinukoy sa loob ng parent class bilang isang panloob na klase.

2. Ang klase ng bata ay dapat na final , selyadong , o hindi selyado .

3. Ang isang pinahihintulutang klase ng bata ay dapat pahabain ang parent sealed class nito.

   Iyon ay, kung pinahihintulutan ng selyadong klase A ang klase B, dapat palawigin ng B ang A.

4. Kung ang sealed class ay nasa isang module, ang mga child class ay dapat na nasa parehong module, o sa parehong package kung ang parent sealed class ay nasa isang unnamed module.

5. Ang mga direktang pinahihintulutang klase lang ang makakapagpalawig ng selyadong klase. Iyon ay, kung ang A ay isang selyadong klase na nagpapahintulot sa B na palawigin ito, ang B ay isa ring selyadong klase na nagpapahintulot sa C.

   Pagkatapos ay maaari lamang i-extend ng C ang B, ngunit hindi maaaring direktang pahabain ang A.

Mga Selyadong Interface

Tulad ng mga selyadong klase, ang mga interface ay maaari ding selyuhan. Maaaring payagan ng naturang interface ang pagpili ng mga child interface o klase nito, na maaaring palawigin ito gamit ang mga permit . Narito ang isang magandang halimbawa:

public sealed interface Device permits Electronic, Physical,
DeviceImpl {
}

Dito, pinapayagan ng interface ng Device ang mga Electronic at Physical na interface na palawigin ito at ang klase ng DeviceImpl para sa kasunod na pagpapatupad.

Mga Selyado na Tala

Maaaring gamitin ang mga selyadong klase sa mga entry na ipinakilala sa Java 16. Ang isang entry ay hindi maaaring mag-extend ng isang regular na klase, kaya maaari lamang itong magpatupad ng pribadong interface. Bilang karagdagan, ang notasyon ay nagpapahiwatig ng pangwakas na . Samakatuwid, ang isang entry ay hindi maaaring gumamit ng permit keyword dahil hindi ito maaaring i-subclass. Iyon ay, mayroon lamang isang antas na hierarchy na may mga talaan. Narito ang isang halimbawa:

public sealed interface Device permits Laptop {
}
public record Laptop(String brand) implement Device {
}

Suporta sa pagninilay

Ang Java Reflection ay nagbibigay ng suporta para sa mga selyadong klase. Ang sumusunod na dalawang pamamaraan ay naidagdag sa java.lang.Class :

1. getPermittedSubclasses()

Nagbabalik ito ng array java.lang.Class na naglalaman ng lahat ng klase na pinapayagan ng object ng klase na ito. Halimbawa:

Device c = new Device();
Class<? extends Device> cz = c.getClass();
Class<?>[] permittedSubclasses = cz.getPermittedSubclasses();
for (Class<?> sc : permittedSubclasses){
  System.out.println(sc.getName());
}

Konklusyon:

2.isSealed()

Nagbabalik ito ng totoo kung ang klase o interface kung saan ito tinatawag ay selyadong. Iyon lang sa ngayon ang tungkol sa mga selyadong klase na idinagdag sa Java 17. Sana ay nakapagtuturo ang artikulong ito.

4 na Paraan para Ipatupad ang Singleton

Source: Medium Ngayon ay matututunan mo ang ilang paraan para ipatupad ang pattern ng disenyo ng Singleton. Ang pattern ng disenyo ng singleton ay malawakang ginagamit sa mga proyekto ng Java. Nagbibigay ito ng kontrol sa pag-access sa mga mapagkukunan, tulad ng isang socket o koneksyon sa database. Minsan ay hiniling sa akin na magpatupad ng singleton sa isang panayam para sa posisyon ng web developer sa isang malaking kumpanya ng chip. Ito ang aking unang pagkakataon na makapanayam para sa isang posisyon sa web, at hindi ako masyadong naghahanda, kaya pinili ko ang pinakamahirap na solusyon: Lazy instantiation. Ang aking code ay 90% lamang at hindi sapat na episyente, natalo ako sa huling pag-ikot... Kaya't sana ay maging kapaki-pakinabang sa iyo ang aking artikulo.

Maagang Instantiation

class Singleton {
    private Singleton() {}
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
}

Dahil nalikha na ang bagay sa pagsisimula, walang isyu sa kaligtasan ng thread dito, ngunit nag-aaksaya ito ng mga mapagkukunan ng memorya kung walang gumagamit nito.

Tamad na pagpapatupad

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

Kapag gumagamit ng isang lazy initialization pattern, ang object ay nilikha on demand. Gayunpaman, ang pamamaraang ito ay may problema sa kaligtasan ng thread: kung magsisimula ang dalawang thread sa linya 5 nang magkasabay, gagawa sila ng dalawang instance ng Singleton. Upang maiwasan ito, kailangan naming magdagdag ng lock:

class Singleton {
    private Singleton() {}
    private static Singleton instance = null;

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

Double-Checked Locking (DCL): Walang pag-lock sa linya 6, kaya ang linyang ito ay gagana nang napakabilis kung ang bagay ay nagawa na. Bakit kailangan nating i-double-check instance == null ? Dahil marahil mayroong dalawang thread na ipinakilala sa linya 7: ang una ay nagpasimula ng bagay, ang pangalawa ay naghihintay para sa Singleton.class lock . Kung walang tseke, ang pangalawang thread ay muling gagawa ng singleton object. Gayunpaman, ang pamamaraang ito ay mapanganib pa rin para sa mga thread. Ang linya 9 ay maaaring nahahati sa tatlong linya ng byte code:

1. Maglaan ng memorya.
2. Init object.
3. Magtalaga ng object sa instance reference.

Dahil ang JVM ay maaaring maubusan ng order, ang virtual machine ay maaaring magtalaga ng isang object sa isang instance reference bago ang pagsisimula. Nakikita na ng isa pang thread ang != null instance , magsisimula itong gamitin at magdulot ng problema. Kaya kailangan nating magdagdag ng pabagu-bago ng isip sa halimbawa, pagkatapos ay magiging ganito ang code:

class Singleton {
    private Singleton() {}
    private volatile static Singleton instance = null;

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

Gamit ang isang static na panloob na klase

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

Ang SingletonHolder ay isang static na panloob na klase, ito ay sinisimulan lamang kapag ang getInstance na pamamaraan ay tinatawag na . Ang init class sa JVM ay tatakbo <clinit> cmd , pagkatapos ang JVM mismo ay titiyakin na isang thread lang ang makakatawag sa <clinit> sa target na klase, maghihintay ang ibang mga thread.

Enum bilang singleton

public enum EnumSingleton {
    INSTANCE;
    int value;
    public int getValue() {
        return value;
    }
    public int setValue(int v) {
        this.value = v;
    }
}

Bilang default, ang isang enum instance ay thread-safe, kaya hindi na kailangang mag-alala tungkol sa double-checked na pag-lock, at medyo madali itong magsulat.