Coffee break #142. Anong papel ang ginagampanan ng static na keyword sa Java?

Pinagmulan: FreeCodeCamp Ang static na keyword ay maaaring gamitin sa iba't ibang bahagi ng Java code gaya ng mga variable, pamamaraan, at static na bloke. Ngayon ay malalaman natin nang eksakto kung paano ito mailalapat sa pagsasanay. Ang pangunahing layunin ng paggamit ng static na keyword sa Java ay upang makatipid ng memorya. Kapag gumawa tayo ng variable sa isang klase na maa-access ng ibang mga klase, kailangan muna nating gumawa ng instance ng klase at pagkatapos ay magtalaga ng bagong value sa bawat instance ng variable. Ito ay kinakailangan upang ang mga halaga ng mga bagong variable ay pareho para sa lahat ng mga bagong klase/bagay. Ngunit kapag gumawa kami ng mga static na variable, nananatiling pare-pareho ang value ng mga ito sa lahat ng iba pang klase at hindi namin kailangang gumawa ng instance para magamit ang variable. Sa ganitong paraan ginagawa namin ang variable nang isang beses, kaya isang beses lang inilalaan ang memorya. Mas mauunawaan mo ito sa ilang mga halimbawa sa artikulong ito.

Paano lumikha ng isang static na variable sa Java

Upang maunawaan kung paano gamitin ang static na keyword kapag gumagawa ng mga variable, tingnan natin ang karaniwang paraan ng paggawa ng mga variable na ibinabahagi ng bawat instance ng isang klase.

class Student {
    String studentName;
    String course;
    String school;

    public static void main(String[] args) {
        Student Student1 = new Student();
        Student Student2 = new Student();

        Student1.studentName = "Ihechikara";
        Student1.course = "Data Visualization";
        Student1.school = "freeCodeCamp";

        Student2.studentName = "John";
        Student2.course = "Data Analysis with Python";
        Student2.school = "freeCodeCamp";

        System.out.println(Student1.studentName + " " + Student1.course + " " + Student1.school + "\n");
        // Ihechikara Data Visualization freeCodeCamp
        System.out.println(Student2.studentName + " " + Student2.course + " " + Student2.school);
        // John Data Analysis with Python freeCodeCamp
    }
}

Ipapaliwanag ko kung ano ang nangyari sa code sa itaas nang hakbang-hakbang. Gumawa kami ng klase ng Mag - aaral na may tatlong variable - studentName , kurso at paaralan . Pagkatapos ay lumikha kami ng dalawang pagkakataon ng klase ng Mag-aaral :

Student Student1 = new Student();
Student Student2 = new Student();

Ang unang pagkakataon ay Student1 , na may access sa mga variable na nilikha sa klase nito, ay may mga sumusunod na halaga:

Student1.studentName = "Ihechikara";
Student1.course = "Data Visualization";
Student1.school = "freeCodeCamp";

Ang pangalawang pagkakataon ay may mga sumusunod na kahulugan:

Student2.studentName = "John";
Student2.course = "Data Analysis with Python";
Student2.school = "freeCodeCamp";

Kung titingnan mong mabuti, makikita mo na ang parehong mga mag-aaral ay may parehong pangalan ng paaralan - "freeCodeCamp". Ngunit paano kung kailangan nating lumikha ng 100 mag-aaral para sa parehong paaralan? Nangangahulugan ito na pasisimulan namin ang variable na may parehong halaga nang 100 beses, na naglalaan ng bagong memorya sa bawat oras. Ito ay maaaring hindi isang problema para sa ilan, ngunit sa isang malaking codebase maaari itong makabuluhang pabagalin ang programa. Upang malutas ang isyung ito, gagamitin namin ang static na keyword upang gawin ang variable ng paaralan . Pagkatapos nito, magagamit ng lahat ng instance ng klase ang variable na ito. Isang bagay na tulad nito:

class Student {
    String studentName;
    String course;
    static String school;

    public static void main(String[] args) {
        Student Student1 = new Student();
        Student Student2 = new Student();


        Student1.studentName = "Ihechikara";
        Student1.course = "Data Visualization";
        Student1.school = "freeCodeCamp";


        Student2.studentName = "John";
        Student2.course = "Data Analysis with Python";

        System.out.println(Student1.studentName + " " + Student1.course + " " + Student1.school + "\n");
        // Ihechikara Data Visualization freeCodeCamp
        System.out.println(Student2.studentName + " " + Student2.course + " " + Student2.school);
        // John Data Analysis with Python freeCodeCamp
    }
}

Sa code na ito, lumikha kami ng isang static na variable na tinatawag na school . Pansinin na ang static na keyword ay nauuna sa uri ng data at pangalan ng variable: static String school = "freeCodeCamp"; . Ngayon kapag gumawa kami ng bagong instance ng aming klase, hindi namin kailangang simulan ang variable ng paaralan para sa bawat instance. Sa aming code, nagtalaga kami ng isang halaga sa isang variable sa unang pagkakataon lamang, at pagkatapos ay minana ito ng susunod na pagkakataon. Tandaan na ang pagpapalit ng halaga ng isang static na variable saanman sa code ay nag-o-override sa halaga sa ibang bahagi ng code kung saan ito dati nang idineklara. Kaya, dapat mo lamang gamitin ang static na keyword para sa mga variable na nilalayong manatiling pare-pareho sa programa. Maaari ka ring magtalaga ng value sa isang variable kapag nilikha mo ito upang hindi mo na ito kailangang ideklara muli kapag ginawa mo ang klase: static String school = "freeCodeCamp"; . Ito ang makukuha mo kung gagamitin mo ang paraang ito:

class Student {
    String studentName;
    String course;
    static String school = "freeCodeCamp";

    public static void main(String[] args) {
        Student Student1 = new Student();
        Student Student2 = new Student();


        Student1.studentName = "Ihechikara";
        Student1.course = "Data Visualization";

        Student2.studentName = "John";
        Student2.course = "Data Analysis with Python";

        System.out.println(Student1.studentName + " " + Student1.course + " " + Student1.school + "\n");
        // Ihechikara Data Visualization freeCodeCamp
        System.out.println(Student2.studentName + " " + Student2.course + " " + Student2.school);
        // John Data Analysis with Python freeCodeCamp
    }
}

Ngayon ay makikita mo kung paano simulan ang mga static na variable gamit ang mga static na bloke.

Paano lumikha ng isang static na pamamaraan sa Java

Bago natin tingnan ang halimbawa, narito ang ilang bagay na kailangan mong malaman tungkol sa mga static na pamamaraan sa Java:

• Ang mga static na pamamaraan ay maaari lamang mag-access at magbago ng mga static na variable.
• Maaaring tawagan/gamitin ang mga static na pamamaraan nang hindi lumilikha ng isang halimbawa ng klase.

Narito ang isang halimbawa upang matulungan kang maunawaan ito:

class EvenNumber {

    static int evenNumber;

    static void incrementBy2(){
        evenNumber = evenNumber + 2;
        System.out.println(evenNumber);
    }

    public static void main(String[] args) {
        incrementBy2(); // 2
        incrementBy2(); // 4
        incrementBy2(); // 6
        incrementBy2(); // 8
    }
}

Sa code sa itaas, gumawa kami ng integer ( evenNumber ) sa isang klase na tinatawag na EvenNumber . Ang aming static na pamamaraan ay tinatawag na incrementBy2() . Ang pamamaraang ito ay nagdaragdag ng halaga ng integer evenNumber at nagpi-print ng halaga nito. Nang hindi gumagawa ng isang instance ng klase, natawagan namin ang incrementBy2() na paraan sa pangunahing pamamaraan ng programa . Sa bawat oras na tinawag namin ang pamamaraan, ang evenNumber ay dinadagdagan ng 2 at nai-print. Maaari mo ring idagdag ang pangalan ng klase sa isang pamamaraan gamit ang tuldok na notasyon kapag tinatawag ang pamamaraan: EvenNumber.incrementBy2(); . Ang bawat static na pamamaraan ay kabilang sa klase, hindi sa mga pagkakataon ng klase.

Paano lumikha ng isang static na bloke sa Java

Ang mga static na bloke sa Java ay katulad ng mga konstruktor. Maaari naming gamitin ang mga ito upang simulan ang mga static na variable, ang mga ito ay isinasagawa ng compiler bago ang pangunahing pamamaraan .

class Block {

    static int year;

    static {
        year = 2022;
        System.out.println("This code block got executed first");
    }

    public static void main(String[] args) {

        System.out.println("Hello World");
        System.out.println(year);
    }
}

Sa code sa itaas, lumikha kami ng isang static na integer variable year . Pagkatapos ay sinimulan namin ito sa isang static na bloke:

static {
        year = 2022;
        System.out.println("This code block got executed first");
    }

Gaya ng nakikita mo, maaaring gumawa ng static block gamit ang static na keyword na sinusundan ng curly braces. Sa static na bloke ng aming code, sinimulan namin ang variable ng taon na may value na 2022. Nag-print din kami ng ilang text - "Naunang naisakatuparan ang code block na ito." Sa pangunahing paraan , nag-print kami ng "Hello World" at isang static na variable na taon . Sa console, ang code ay isasagawa sa ganitong pagkakasunud-sunod: Ito ay malinaw na nagpapakita kung paano ang code sa static na bloke ay pinaandar muna bago ang pangunahing pamamaraan .

Konklusyon

Sa artikulong ito, pinag-usapan natin ang static na keyword sa Java. Ito ay isang keyword na karaniwang tumutulong sa amin na i-optimize ang memorya sa mga program na nakasulat sa Java. Nakita rin namin kung paano lumikha ng mga static na variable at pamamaraan na may mga halimbawa. Sa wakas, napag-usapan namin ang tungkol sa mga static na bloke, na maaaring magamit upang simulan ang mga static na variable. Ang mga static na bloke ay isinasagawa bago ang pangunahing pamamaraan. Maligayang coding!