Coffee break #134. Ano ang dapat iwasan kapag nagsusulat ng Java code. Paano ginagamit ang pangwakas, pangwakas, at pag-finalize sa Java

Ano ang Dapat Iwasan Kapag Nagsusulat ng Java Code

Source: Medium Dinadala namin sa iyong pansin ang isang artikulo na naglilista ng mga karaniwang pagkakamali na ginagawa ng mga developer kapag nagsusulat ng Java code.

Gamit ang Enum.values

Nagulat ako na ito ay itinuturing na isang bug dahil regular kong ginamit ang Enum.values ​​. Ang problema dito ay ang Enum.values() ay dapat na isang hindi nababagong listahan ayon sa detalye. Upang gawin ito, dapat itong magbalik ng isang bagong halimbawa ng array na may mga halaga ng enum sa bawat oras na ito ay tinatawag.

public enum Fruits {
    APPLE, PEAR, ORANGE, BANANA;

    public static void main(String[] args) {
        System.out.println(Fruits.values());
        System.out.println(Fruits.values());
    }
}
// output
// [Lcom.test.Fruits;@7ad041f3
// [Lcom.test.Fruits;@251a69d7

Mayroong dalawang magkahiwalay na bagay sa memorya dito, kaya maaaring hindi ito mukhang isang malaking bagay. Ngunit kung gumagamit ka ng Fruit.values() kapag nagpoproseso ng isang kahilingan at mayroon kang mataas na load, maaari itong humantong sa mga problema sa memorya. Madali mong maaayos ito sa pamamagitan ng pagpapakilala ng pribadong static na final variable na VALUES para sa pag-cache.

Pagpasa ng Opsyonal na mga parameter bilang isang parameter ng pamamaraan

Isaalang-alang ang sumusunod na code:

LocalDateTime getCurrentTime(Optional<ZoneId> zoneId) {
    return zoneId.stream()
        .map(LocalDateTime::now)
        .findFirst()
        .orElse(LocalDateTime.now(ZoneId.systemDefault()));
}

Ipinapasa namin ang Opsyonal na parameter zoneId at, batay sa presensya nito, magpapasya kung ibibigay ang oras sa time zone ng system o gagamitin ang tinukoy na zone. Gayunpaman, hindi ito ang tamang paraan upang gumana sa Opsyonal. Dapat nating iwasang gamitin ang mga ito bilang isang parameter at sa halip ay gumamit ng paraan ng overloading.

LocalDateTime getCurrentTime(ZoneId zoneId) {
  return LocalDateTime.now(zoneId);
}

LocalDateTime getCurrentTime() {
  return getCurrentTime(ZoneId.systemDefault());
}

Ang code na nakikita mo sa itaas ay mas madaling basahin at i-debug.

Gamit ang StringBuilder

Ang mga string sa Java ay hindi nababago. Nangangahulugan ito na sa sandaling nilikha ang mga ito ay hindi na mae-edit. Ang JVM ay nagpapanatili ng string pool at, bago gumawa ng bago, tinatawagan ang String.intern() method , na nagbabalik ng instance mula sa string pool na tumutugma sa value, kung mayroon. Sabihin nating gusto nating lumikha ng mahabang string sa pamamagitan ng pagsasama-sama ng mga elemento dito.

String longString = new StringBuilder()
  .append("start")
  .append("middle")
  .append("middle")
  .append("middle")
  .append("end")
  .toString();

Sinabi sa amin kamakailan na ito ay isang napakasamang ideya dahil ginawa ng mga mas lumang bersyon ng Java ang sumusunod:

• sa linya 1 ang string na "start" ay ipinasok sa string pool at itinuturo ng longString
• idinaragdag ng linya 2 ang string na "startmiddle" sa pool at itinuturo ito ng longString
• sa linya 3 mayroon kaming "startmiddlemiddle"
• sa linya 4 - "startmiddlemiddle"
• at sa wakas sa linya 5 idinadagdag namin ang "startmiddlemiddlemiddleend" sa pool at ituturo ang longString dito

Ang lahat ng mga row na ito ay nananatili sa pool at hindi kailanman ginagamit, na nagreresulta sa malaking halaga ng RAM na nasasayang. Upang maiwasan ito maaari naming gamitin ang StringBuilder.

String longString = new StringBuilder()
  .append("start")
  .append("middle")
  .append("middle")
  .append("middle")
  .append("end")
  .toString();

Ang StringBuilder ay lumilikha lamang ng isang string kapag ang toString method ay tinatawag na , sa gayon ay inaalis ang lahat ng mga intermediate na string na unang idinagdag sa pool. Gayunpaman, pagkatapos ng Java 5 ito ay awtomatikong ginagawa ng compiler , kaya mas mainam na gumamit ng string concatenation gamit ang "+".

Gumamit ng primitive wrapper kapag hindi kailangan

Isaalang-alang ang sumusunod na dalawang fragment:

int sum = 0;
for (int i = 0; i < 1000 * 1000; i++) {
  sum += i;
}
System.out.println(sum);

Integer sum = 0;
for (int i = 0; i < 1000 * 1000; i++) {
  sum += i;
}
System.out.println(sum);

Ang unang halimbawa ay tumatakbo nang anim na beses na mas mabilis kaysa sa pangalawa sa aking computer. Ang pagkakaiba lang ay gumagamit kami ng klase ng Integer wrapper. Ang paraan ng paggana ng Integer ay na sa linya 3, dapat i-convert ng runtime ang sum variable sa isang primitive integer (awtomatikong pag-unbox), at pagkatapos gawin ang pagdaragdag, ang resulta ay balot sa isang bagong klase ng Integer. (awtomatikong packaging). Nangangahulugan ito na lumilikha kami ng 1 milyong mga klase ng Integer at nagsasagawa ng dalawang milyong pagpapatakbo ng packaging, na nagpapaliwanag sa matinding paghina. Ang mga klase ng wrapper ay dapat lamang gamitin kapag kailangan nilang itabi sa mga koleksyon. Gayunpaman, susuportahan ng mga hinaharap na bersyon ng Java ang mga koleksyon ng mga primitive na uri, na gagawing hindi na ginagamit ang mga wrapper.

Paano ginagamit ang pangwakas, pangwakas, at pag-finalize sa Java

Pinagmulan: Newsshare Sa artikulong ito matututunan mo kung saan, kailan at bakit ginagamit ang Finalize na keyword, at kung sulit ba itong gamitin sa Java. Malalaman mo rin ang mga pagkakaiba sa pagitan ng final, finally at finalize.

Saan ginagamit ang panghuling bloke?

Ang panghuling bloke sa Java ay ginagamit upang ilagay ang mahahalagang bahagi ng code tulad ng cleanup code, pagsasara ng file, o pagsasara ng koneksyon, halimbawa. Ang pangwakas na bloke ay nagsasagawa ng hindi alintana kung ang isang pagbubukod ay itinapon o kung ang pagbubukod na iyon ay pinangangasiwaan. Ang isang wakas ay naglalaman ng lahat ng mahahalagang pahayag kung may eksepsiyon man o hindi.

Paano mo tinatapos ang isang variable sa Java?

Mayroong 3 paraan upang simulan ang isang panghuling variable ng Java:

• Maaari mong simulan ang isang panghuling variable kapag ito ay idineklara. Ang pamamaraang ito ay ang pinakakaraniwan.
• Ang isang walang laman na panghuling variable ay sinisimulan sa isang instance-initializer block o constructor.
• Ang isang walang laman na huling static na variable ay sinisimulan sa loob ng isang static na bloke.

Maaari ba nating tawagan ang paraan ng pag-finalize nang manu-mano sa Java?

Ang finalize() na paraan ay hindi kinakailangan at hindi inirerekomenda na tawagan kapag ang isang bagay ay wala sa saklaw. Dahil hindi alam nang maaga kung kailan (o kung) ang finalize() na paraan ay isasagawa . Sa pangkalahatan, ang pag-finalize ay hindi ang pinakamahusay na paraan upang gamitin maliban kung may partikular na pangangailangan para dito. Simula sa Java 9 ito ay hindi na ginagamit.

Kailan tinatawag ang paraan ng pagwawakas?

Ang finalize() na paraan ay tinatawag upang magsagawa ng paglilinis bago ang koleksyon ng basura.

Ano ang pagkakaiba sa pagitan ng final, finally at finalize?

Ang pangunahing pagkakaiba sa pagitan ng final, finally at finalize ay ang final ay isang access modifier, sa wakas ay isang block sa exception handling at ang finalize ay isang paraan ng isang object class.

Posible bang i-override ang mga huling pamamaraan?

Hindi, ang mga pamamaraang idineklara na pinal ay hindi maaaring i-override o itago.

Maaari ba nating gamitin ang try without catch?

Oo, posibleng magkaroon ng try block na walang catch block sa pamamagitan ng paggamit ng final block . Tulad ng alam natin, ang panghuling bloke ay palaging isasagawa kahit na ang anumang pagbubukod maliban sa System ay nangyayari sa try block.

Ano ang mga huling pamamaraan?

Ang mga panghuling pamamaraan ay hindi maaaring ma-override o itago ng mga subclass. Ginagamit ang mga ito upang maiwasan ang hindi inaasahang pag-uugali ng isang subclass na nagbabago ng isang pamamaraan na maaaring kritikal sa pag-andar o pagkakapare-pareho ng klase.

Maaari bang maging pangwakas ang isang constructor?

HINDI maaaring ideklarang pinal ang mga konstruktor. Ang iyong compiler ay palaging maglalagay ng error tulad ng "hindi pinapayagan ang panghuling modifier." Ang pangwakas kapag inilapat sa mga pamamaraan ay nangangahulugan na ang pamamaraan ay hindi maaaring ma-override sa isang subclass. Ang mga konstruktor ay HINDI regular na pamamaraan.

Para saan ang huling keyword na ginamit?

Ang pangwakas na keyword ay ginagamit upang lumikha ng isang bloke ng code kasunod ng isang bloke ng pagsubok. Ang pangwakas na bloke ay palaging isinasagawa kahit na may pagbubukod. Ang paggamit ng finally block ay nagbibigay-daan sa iyong magpatakbo ng anumang unwind type na mga pahayag na gusto mong isagawa, anuman ang nangyayari sa protektadong code.

Ano ang silbi ng wakas?

Ang panghuling bloke sa Java ay isang bloke na ginagamit upang magsagawa ng mga bahagi ng code tulad ng pagsasara ng koneksyon at iba pa. Ang pangwakas na bloke sa Java ay palaging isinasagawa kung ang pagbubukod ay pinangangasiwaan o hindi. Samakatuwid, naglalaman ito ng lahat ng kinakailangang pahayag na kailangang i-print kung may eksepsiyon man o hindi.

Bakit protektado ang paraan ng Pag-finalize?

Bakit protektado ang finalize() method access modifier ? Bakit hindi pwedeng maging public? Hindi ito pampubliko dahil hindi ito dapat tawagin ng sinuman maliban sa JVM. Gayunpaman, dapat itong protektahan upang ma-override ito ng mga subclass na kailangang tukuyin ang pag-uugali para dito.

Palaging tinatawag ba ang paraan ng pag-finalize sa Java?

Ang paraan ng pag-finalize ay tinatawag kapag ang isang bagay ay malapit nang makolekta ng basura. Ito ay maaaring mangyari anumang oras pagkatapos itong maging karapat-dapat para sa pangongolekta ng basura. Tandaan na ito ay ganap na posible na ang bagay ay hindi kailanman nakolektang basura (at samakatuwid ang pag-finalize ay hindi kailanman tinatawag).

Ano ang pagkakaiba ng throw at throws?

Ang throw keyword ay ginagamit upang sadyang magtapon ng exception. Ang throws na keyword ay ginagamit upang magdeklara ng isa o higit pang mga pagbubukod, na pinaghihiwalay ng mga kuwit. Kapag gumagamit ng throw, isang exception lang ang ibinabato.

Ano ang pagkakaiba sa pagitan ng try catch at panghuli ng mga keyword?

Ito ay dalawang magkaibang konsepto: ang catch block ay isasagawa lamang kung ang isang exception ay nangyari sa try block. Ang pangwakas na block ay palaging isinasagawa pagkatapos ng try(-catch) block, hindi alintana kung ang isang exception ay itinapon o hindi.

Maaari ba nating gamitin sa wakas nang walang pagsubok sa Java?

Ang panghuling bloke ay dapat na nauugnay sa isang bloke ng pagsubok, hindi mo magagamit sa wakas nang walang isang bloke ng pagsubok. Dapat mong ilagay sa block na ito ang mga pahayag na dapat palaging isagawa.

Maaari ba nating mamana ang panghuling pamamaraan?

Ang huling paraan ba ay minana? Oo, ang huling paraan ay minana, ngunit hindi mo ito mapapawalang-bisa.

Aling paraan ang hindi maaaring i-override?

Hindi namin ma-override ang mga static na pamamaraan dahil ang pag-override ng pamamaraan ay batay sa dynamic na pag-link sa runtime at ang mga static na pamamaraan ay nakatali gamit ang static na pag-link sa oras ng pag-compile. Kaya, hindi posible ang pag-override sa mga static na pamamaraan.

Ano ang mangyayari kung ang panghuling paraan ay na-override?

Ang isang panghuling paraan na idineklara sa isang parent na klase ay hindi maaaring ma-override ng isang child class. Kung susubukan naming i-override ang huling paraan, ang compiler ay magtapon ng exception sa oras ng compile.

Gumagana ba ang panghuling keyword at ang paraan ng pag-finalize?

Walang mga pagkakatulad sa kanilang mga pag-andar, maliban sa magkatulad na mga pangalan. Ang huling keyword ay maaaring gamitin sa isang klase, pamamaraan o variable sa Java. Ang isang panghuling klase ay hindi mapalawak sa Java, ang isang panghuling pamamaraan ay hindi maaaring ma-override, at ang isang panghuling variable ay hindi maaaring mabago.

Ano ang sobrang keyword sa Java?

Ang super keyword sa Java ay isang reference variable na ginagamit upang sumangguni sa agarang object ng parent class. Sa tuwing mag-i-instantiate ka ng isang subclass, ang isang instance ng parent na klase ay nilikha nang magkatulad, na tinutukoy ng reference na variable na super. Ang super keyword ay maaaring gamitin upang direktang tumawag sa isang paraan ng isang parent na klase.

Ano ang pagkakaiba sa pagitan ng mga static at panghuling keyword?

Ang pangunahing pagkakaiba sa pagitan ng static at final na mga keyword ay ang static na keyword ay ginagamit upang tukuyin ang isang miyembro ng isang klase na maaaring magamit nang hiwalay sa anumang bagay ng klase na iyon. Ang Pangwakas na keyword ay ginagamit upang magdeklara ng isang pare-parehong variable, isang paraan na hindi maaaring ma-override, at isang klase na hindi maaaring mamana.