10 bagay na kailangan mong malaman tungkol sa static na modifier sa Java

Sa Java, ang static na modifier ay nangangahulugan ng isang bagay na direktang nauugnay sa isang klase: kung ang isang field ay static, kung gayon ito ay kabilang sa klase; kung ang isang pamamaraan ay static, kung gayon ito ay kabilang sa klase. Bilang resulta, maaari mong gamitin ang pangalan ng klase upang tumawag sa isang static na pamamaraan o sumangguni sa isang static na field. Halimbawa, kung countstatic ang field sa Counterklase, nangangahulugan ito na maaari mong i-reference ang variable gamit ang sumusunod na expression: Counter.count. Siyempre, dapat isaalang-alang ang mga access modifier. Halimbawa, privateang mga patlang ay magagamit lamang sa loob ng klase kung saan idineklara ang mga ito. At protectedang mga patlang ay magagamit sa lahat ng mga klase sa loob ng isang pakete, gayundin sa lahat ng kanilang mga subclass sa labas ng pakete. Ipagpalagay na ang Counterklase ay may static increment()na pamamaraan na ang trabaho ay dagdagan angcountpatlang. Upang tawagan ang paraang ito, maaari mong gamitin ang Counter.increment(). Hindi na kailangang lumikha ng isang instance ng Counterklase upang ma-access ang isang static na field o pamamaraan. Ito ang pangunahing pagkakaiba sa pagitan ng mga static (class) na variable at pamamaraan at NON-static (halimbawa) na mga variable at pamamaraan. Isang mahalagang tala. Huwag kalimutan na ang mga static na miyembro ng klase ay direktang nabibilang sa klase, hindi sa anumang instance ng klase. Iyon ay, ang halaga ng static countna variable ay magiging pareho para sa lahat Counterng mga bagay. Sa artikulong ito, titingnan natin ang mga pangunahing aspeto ng paggamit ng static na modifier sa Java, pati na rin ang ilang feature na makakatulong sa iyong maunawaan ang mga pangunahing konsepto ng programming.

Ano ang dapat malaman ng bawat programmer tungkol sa static na modifier sa Java.

Sa seksyong ito, tinitingnan natin ang mga pangunahing aspeto ng paggamit ng mga static na pamamaraan, field, at klase. Magsimula tayo sa mga variable.

1. HINDI mo maa-access ang mga hindi static na miyembro ng isang klase sa loob ng isang static na konteksto, tulad ng isang static na paraan o block. Ang pag-compile ng code sa ibaba ay magreresulta sa isang error:

   
   public class Counter {
   private int count;
   public static void main(String args []) {
      System.out.println(count); //  Compile time error
   }
   }
   

   Ito ay isa sa mga pinakakaraniwang pagkakamali na ginawa ng mga programmer ng Java, lalo na ang mga baguhan. Dahil ang mainpamamaraan ay static at ang countvariable ay hindi, ang paggamit ng printlnpamamaraan sa loob ng mainpamamaraan ay magbubunga ng isang "compile time error".

2. Hindi tulad ng mga lokal na variable, ang mga static na field at pamamaraan ay HINDI thread safesa Java. Sa pagsasagawa, ito ay isa sa mga madalas na sanhi ng mga problema sa seguridad sa multi-threaded programming. Isinasaalang-alang na ang bawat instance ng isang klase ay tumutukoy sa parehong kopya ng isang static na variable, ang naturang variable ay kailangang protektahan o "i-lock" ng klase. Samakatuwid, kapag gumagamit ng mga static na variable, siguraduhing maayos ang mga ito synchronizedupang maiwasan ang mga problema tulad ng race conditions.

3. Ang mga static na pamamaraan ay may praktikal na kalamangan dahil hindi na kailangang lumikha ng isang bagong bagay sa bawat oras na gusto mong tawagan ang mga ito. Maaaring tawagan ang isang static na pamamaraan gamit ang pangalan ng klase na nagdedeklara nito. Iyon ang dahilan kung bakit ang mga pamamaraan na ito ay perpekto para sa factorymga pamamaraan at utilitypamamaraan. Ang java.lang.Mathklase ay isang magandang halimbawa: halos lahat ng mga pamamaraan nito ay static. Ang mga utility class ng Java ay minarkahan finalpara sa parehong dahilan.

4. Ang isa pang mahalagang punto ay hindi mo maaaring i-override ( @Override) ang mga static na pamamaraan. Kung idineklara mo ang ganitong paraan sa isang subclass, ibig sabihin, isang pamamaraan na may parehong pangalan at lagda, "itago" mo lang ang paraan ng superclasssa halip na i-override ito. Ang phenomenon na ito ay kilala bilang method hiding. Nangangahulugan ito na kung ang isang static na pamamaraan ay idineklara sa parehong mga klase ng magulang at anak, ang pamamaraang tinatawag ay palaging ibabatay sa uri ng variable sa oras ng pag-compile. Hindi tulad ng pag-overriding ng pamamaraan, ang mga naturang pamamaraan ay hindi isasagawa kapag tumakbo ang programa. Isaalang-alang natin ang isang halimbawa:

   
   class Vehicle {
        public static void kmToMiles(int km) {
             System.out.println("Inside the parent class / static method");
        } 
   }
   
   class Car extends Vehicle {
        public static void kmToMiles(int km) {
             System.out.println("Inside the child class / static method");
        } 
   }
   
   public class Demo {   
      public static void main(String args []) {
         Vehicle v = new Car();
          v.kmToMiles(10);
     }
   }
   

   Output ng console:

   Sa loob ng parent class / static na pamamaraan

   Ang code ay malinaw na nagpapakita na sa kabila ng katotohanan na ang bagay ay isang Car, ang static na pamamaraan sa Vehicleklase ay tinatawag, dahil ang pamamaraan ay tinawag sa oras ng pag-compile. At tandaan na walang mga error sa compilation!

5. Higit pa, maliban sa mga top-level na klase, maaari mong ideklara ang mga klase na static. Ang ganitong mga klase ay kilala bilang nested static classes. Ang mga ito ay kapaki-pakinabang para sa pagbibigay ng mas mahusay na pagkakaisa. Ang isang kapansin-pansin na halimbawa ng isang nested static na klase ay HashMap.Entry, na isang istraktura ng data sa loob HashMap. Kapansin-pansin na, tulad ng mga panloob na klase, ang mga static na nested na klase ay idineklara sa isang hiwalay na .class na file. Kaya, kung magdedeklara ka ng limang nested na klase sa iyong pangunahing klase, magkakaroon ka ng 6 na file na may extension na .class. Ang isa pang halimbawa ay ang deklarasyon ng sarili nating Comparator, tulad ng age comparator ( AgeComparator) sa Employeeklase.

6. Ang static na modifier ay maaari ding tukuyin sa isang static block, na mas kilala bilang isang "static initialization block", na isinasagawa kapag na-load ang klase. Kung hindi mo idineklara ang gayong bloke, kinokolekta ng Java ang lahat ng mga static na field sa isang listahan at sinisimulan ang mga ito kapag na-load ang klase. Ang isang static na bloke ay HINDI maaaring magtapon ng mga naka-check na exception, ngunit maaari itong magtapon ng mga hindi naka-check. Sa kasong ito, isang ExceptionInInitializerErrormangyayari. Sa pagsasagawa, ang anumang pagbubukod na magaganap sa panahon ng pagsisimula ng mga static na patlang ay ibalot sa error na ito ng Java. Ito rin ang pinakakaraniwang sanhi ng NoClassDefFoundError, dahil ang klase ay hindi nasa memorya kapag ito ay isinangguni.

7. Kapaki-pakinabang na malaman na ang mga static na pamamaraan ay naka-link sa oras ng pag-compile, hindi tulad ng pag-link ng mga virtual o non-static na pamamaraan, na naka-link sa oras ng pagtakbo kapag tinawag sa isang tunay na bagay. Alinsunod dito, ang mga static na pamamaraan ay hindi maaaring ma-override sa Java, dahil ang polymorphism ay hindi nalalapat sa kanila sa oras ng pagtakbo. Ito ay isang mahalagang limitasyon na dapat isaalang-alang kapag nagdedeklara ng isang paraan na static. Ang paggawa nito ay makatuwiran lamang kapag walang kakayahan o kailangang i-override ang pamamaraan sa isang subclass. Ang mga factory method at utility method ay magandang halimbawa ng wastong paggamit ng static modifier. Itinuro ni Joshua Bloch ang ilang mga pakinabang na mayroon ang mga static na pamamaraan ng pabrika sa mga constuctor sa kanyang aklat na Effective Java, na ipinag-uutos na pagbabasa para sa bawat Java programmer.

8. Ang pagsisimula ay isang mahalagang aspeto ng isang static na bloke. Ang mga static na field o variable ay sinisimulan pagkatapos ma-load ang klase sa memorya. Ang pagkakasunud-sunod ng pagsisimula ay mula sa itaas hanggang sa ibaba, sa parehong pagkakasunud-sunod kung saan idineklara ang mga ito sa source file ng Java class. Dahil ang mga static na field ay sinisimulan sa isang thread-safe na paraan, ginagamit din ang prosesong ito para ipatupad ang Singletonpattern. Kung hindi ka gumagamit ng isang Enumbilang isang Singletonpara sa ilang kadahilanan, kung gayon mayroon kang isang mahusay na alternatibo. Ngunit sa kasong ito, dapat mong isaalang-alang na hindi ito isang "tamad" na pagsisimula. Nangangahulugan ito na ang static na field ay masisimulan kahit na BAGO may "humingi" para dito. Kung ang isang bagay ay mabigat sa mapagkukunan o bihirang gamitin, kung gayon ang pagsisimula nito sa isang static na bloke ay hindi gagana sa iyong pabor.

9. Sa panahon ng serialization, ang mga static na field, tulad ng transientmga variable, ay hindi serialized. Sa katunayan, kung magse-save ka ng anumang data sa isang static na field, maglalaman ito ng paunang (default) na halaga nito pagkatapos ng deserialization. Halimbawa, kung ang isang static na field ay isang int, ang halaga nito ay magiging zero pagkatapos ng deserialization. Kung ang uri nito ay float, ang halaga ay magiging 0.0. Kung ang field ay isang Object, ang halaga ay magiging null. Sa totoo lang, isa ito sa mga madalas itanong tungkol sa serialization sa mga panayam para sa mga posisyon sa Java. Huwag mag-imbak ng mahahalagang object data sa isang static na field!

10. Panghuli, pag-usapan natin ang tungkol sa static na pag-import. Ang modifier na ito ay may maraming pagkakatulad sa karaniwang importpahayag, ngunit ito ay naiiba dahil hinahayaan ka nitong mag-port ng isa o lahat ng static na miyembro ng klase. Kapag na-import na ang mga static na pamamaraan, maa-access ang mga ito na parang idineklara sila sa parehong klase. Katulad nito, sa pamamagitan ng pag-import ng mga static na field, maa-access natin ang mga ito nang hindi tinukoy ang pangalan ng klase. Ang tampok na ito ay lumitaw sa Java 1.5 at pinapabuti ang pagiging madaling mabasa ng code kapag ginamit nang maayos. Ang construct na ito ay madalas na matatagpuan sa mga JUnit test, dahil halos lahat ng test developer ay gumagamit ng static na pag-import para sa mga paraan ng paggigiit, hal assertEquals()at ang kanilang mga overload na variant.

11. Yun lang muna. Kailangang malaman ng bawat Java programmer ang lahat ng aspeto ng static modifier na binanggit sa itaas. Sinuri ng artikulong ito ang pangunahing impormasyon tungkol sa mga static na variable, field, pamamaraan, initialization block, at import. Tinukoy din nito ang ilang mahahalagang katangian na mahalagang malaman upang magsulat at maunawaan ang mga programang Java. Umaasa ako na gagawing perpekto ng bawat developer ang kanilang mahusay na paggamit ng mga static na miyembro, dahil napakahalaga nito para sa seryosong pagbuo ng software."