Ang blog na ito ay maglalarawan ng paggamit ng mga static na bloke sa Java.
Ano ang 'Static Blocks' sa Java?
Ang isang bloke ay inilalaan bilang ' static ” sa pamamagitan ng pag-uugnay ng static na keyword dito. Ang mga bloke na ito ay may mas mataas na priyoridad kaysa sa ' pangunahing 'kaya't sila ay pinapatay bago ang' pangunahing() ” paraan.
Syntax
classMain {
static {
Sistema . palabas . println ( 'Hello World' ) ;
} }
Sa syntax sa itaas, ang kasamang bloke ay itinalaga bilang “ static ” at ipapatawag bago ang pangunahing.
Mahahalagang Pagsasaalang-alang Tungkol sa 'Mga Static Blocks'
- Ang mga static na bloke sa Java ay awtomatikong ginagamit kapag ang klase ay na-load sa memorya.
- Ang mga ito ay isinasagawa nang isang beses, kahit na maraming mga bagay sa klase ay nilikha.
- Walang limitasyon/paghihigpit sa bilang ng mga static na initialization block sa loob ng isang klase.
- Ang mga bloke na ito ay maaaring magamit upang simulan din ang mga static na variable.
Halimbawa 1: Paggamit ng “Static Blocks” sa Java
Sa halimbawang ito, ang static na bloke ay maaaring gamitin upang obserbahan ang pagkakasunud-sunod kung saan maaari itong maisakatuparan sa pangunahing:
Halimbawa ng publicclass {
static {
Sistema . palabas . println ( 'Ito ay isang static block!' ) ;
}
publicstaticvoidmain ( String [ ] args ) {
Sistema . palabas . println ( 'Ito ang pangunahing!' ) ;
} }
Sa bloke ng code sa itaas, isama lang ang isang “ static ” i-block ang pag-iipon ng nakasaad na mensahe at sa susunod na hakbang, ipakita ang ibinigay na mensahe sa “ pangunahing ”.
Output
Sa output na ito, masusuri na ang static block ay ini-invoke bago ang main.
Halimbawa 2: Pagpapatupad ng Static Value sa loob ng 'Static Block' sa Java
Sa partikular na paglalarawang ito, ang isang static na halaga ay maaaring masimulan sa static na bloke at sa paglaon ay ipapakita sa pangunahing:
classcustom {staticint i ;
static {
i = 10 ;
Sistema . palabas . println ( 'Tumawag ang Static Block!' ) ;
} }
Halimbawa ng publicclass {
publicstaticvoidmain ( String [ ] args ) {
Sistema . palabas . println ( kaugalian. i ) ;
} }
Sa itaas na mga linya ng code:
- Una sa lahat, lumikha ng isang klase na pinangalanang ' kaugalian ”.
- Sa loob ng klase, tukuyin ang isang “ static ” variable at simulan ito sa inilaan na “ static ” block.
- Panghuli, i-invoke ang inisyal na variable sa main sa pamamagitan ng pagtukoy sa klase kung saan ito nakapaloob.
Output
Sa kinalabasan sa itaas, makikita na, gayundin, ang ' static ” block ay unang pinaandar, at ang inisyal na halaga sa bloke na ito ay ipinapakita din, ayon sa pagkakabanggit.
Halimbawa 3: Pagpapatupad ng 'Static Block' Bago ang Constructor
Sa halimbawang ito, maaaring tukuyin ang static block bago ang constructor, at ang pag-uuna at pagpapatupad nito ay maaaring sundin nang naaayon:
classcustom {static {
Sistema . palabas . println ( 'Ito ay isang Static Block' ) ;
}
kaugalian ( ) {
Sistema . palabas . println ( 'Ito ay isang Konstruktor' ) ;
} }
Halimbawa ng publicclass {
publicstaticvoidmain ( String [ ] args ) {
pasadyang obj1 = bago kaugalian ( ) ;
pasadyang obj2 = bago kaugalian ( ) ;
} }
Sa itaas na mga linya ng code:
- Gayundin, tukuyin ang isang klase na pinangalanang ' kaugalian ”.
- Ngayon, tukuyin ang ' static ” i-block at isama ang tagabuo ng klase, ibig sabihin, “ custom() ” pagkakaroon ng mga nakasaad na mensahe, ayon sa pagkakabanggit.
- Sa pangunahin, lumikha ng dalawang bagay ng nilikhang klase upang i-invoke ang mga functionality ng klase sa pagkakasunud-sunod ng naaayon.
Output
Sa output na ito, maaaring isagawa ang mga sumusunod na pagsasaalang-alang:
- Ang static block ay binibigyan ng mas mataas na precedence kumpara sa nakapaloob na constructor.
- Dalawang bagay ng klase ang nilikha, ngunit ang static na bloke ay isinasagawa nang isang beses, tulad ng tinalakay dati.
Konklusyon
Ang ' mga static na bloke 'sa Java ay isasagawa lamang kapag ang isang klase ay na-load sa memorya at naisakatuparan bago ang ' pangunahing() ” paraan. Ang mga tinalakay na halimbawa sa artikulo ay nagpapatunay na ang mga bloke na ito ay may mas mataas na priyoridad kaysa sa pangunahing at ang tagabuo ng klase, ayon sa pagkakabanggit, at isang beses lamang ini-invoke, hindi isinasaalang-alang ang bilang ng mga nilikhang bagay. Tinalakay ng blog na ito ang paggamit ng mga static na bloke sa Java.