Mga trick at tip. Paano maiwasan ang NullPointerException sa mga aplikasyon ng Java

Ngayon ay ipapakita ko sa iyo ang mga simpleng pamamaraan kung paano maiwasan ang NullPointerException sa iyong mga application. Ang mga ito ay madaling sundin, ngunit makabuluhang mapabuti ang pagiging maaasahan at kalidad ng iyong code. Bukod dito, sa aking karanasan, ang unang tip ay magkakaroon ng kapansin-pansing epekto sa kalidad ng iyong code. Kung alam mo ang anumang iba pang mga trick sa Java programming, huwag mag-atubiling ibahagi ang mga ito sa mga komento.

Tawagan ang equals() at equalsIgnoreCase() na mga pamamaraan sa isang kilalang string literal sa halip na isang hindi kilalang bagay

Palaging tumawag ng paraan equals()sa isang kilalang string na alam mong hindi null. Ang pamamaraan equals()ay simetriko, iyon ay, pagtawag a.equals(b)at b.equals(a)magbibigay ng parehong resulta (kung aat bhindi null), at sa kadahilanang ito maraming mga programmer ang hindi binibigyang pansin kung aling mga bagay ang tinatawag na equals(), y ao y b. Isa sa mga side effect nito ay isang NullPointerException kung ang pamamaraan ay tinatawag sa null.

Object unknownObject = null;

//плохой способ - может вызвать NullPointerException
if(unknownObject.equals("knownObject")){
   System.err.println("This may result in NullPointerException if unknownObject is null");
}

//правильный способ - исключение NullPointerException не возникнет, даже если unknownObject null
if("knownObject".equals(unknownObject)){
    System.err.println("better coding avoided NullPointerException");
}

Ito ang pinakasimpleng tip sa pag-iwas sa NullPointerException, ngunit ito lamang ang gumagawa ng malaking pagpapabuti dahil ang pamamaraan equals()ay matatagpuan sa lahat ng dako.

Piliin ang valueOf() sa toString() sa mga kaso kung saan pareho ang resulta

Dahil ang pagtawag toString()sa isang reference na may halaga nullay naghagis ng NullPointerException, mas mainam na gumamit ng pagtawag valueOf()kapag makakakuha tayo ng parehong resulta, dahil ang pagtawag valueOf()mula sa nullreturns null. Ito ay totoo lalo na para sa mga klase ng wrapper gaya ng Integer, Float, Doubleo BigDecimal.

BigDecimal bd = getPrice();
System.out.println(String.valueOf(bd)); //не выбрасывает NPE
System.out.println(bd.toString()); //выбрасывает "Exception in thread "main" java.lang.NullPointerException"

Gamitin ang mga tip na ito kapag hindi ka sigurado kung ang isang bagay ay maaaring umiral nullo hindi.

Gumamit nullng mga paraan at mga aklatan na ligtas

Maraming mga open source na aklatan na kumukuha ng mabigat na pasanin ng pagsubok para sa null. Ang isa sa mga pinaka-karaniwan ay StringUtilsmula sa Apache Commons. Paggamit ng mga pamamaraan tulad ng StringUtils.isBlank(), isNumeric(), isWhiteSpace()atbp. hindi mo kailangang mag-alala tungkol sa paghahagis ng NullPointerException.

//Методы StringUtils являются null-безопасными, они не вызовут NullPointerException
System.out.println(StringUtils.isEmpty(null));
System.out.println(StringUtils.isBlank(null));
System.out.println(StringUtils.isNumeric(null));
System.out.println(StringUtils.isAllUpperCase(null));

Output: true true false false At gayon pa man, bago gamitin, huwag kalimutang basahin ang dokumentasyon nullng mga ligtas na pamamaraan at klase. Ito ay isa pa sa pinakamahusay na mga trick ng Java na humahantong sa malalaking pagpapabuti nang hindi nangangailangan ng maraming pagsisikap.

Subukang huwag bumalik nullmula sa isang pamamaraan, mas mahusay na ibalik ang isang walang laman na koleksyon

Ito ay isa pang magandang tip sa Java programming na inilalarawan ni Joshua Bloch sa kanyang aklat na Java: Effective Programming. Kapag nagbabalik ng mga walang laman na koleksyon o array, siguraduhin na ang pagtawag sa mga base method ay gusto size()o length()hindi nagtatapon ng NullPointerException. CollectionsPartikular na idineklara ng klase ang maginhawang pagpapatupad ng mga walang laman na listahan, set at diksyunaryo: Collections.EMPTY_LIST, Collections.EMPTY_SETat Collections.EMPTY_MAP. Halimbawa:

public List getOrders(Customer customer){
   List result = Collections.EMPTY_LIST;
   return result;
}

Katulad nito, maaari mo Collections.EMPTY_SETitong gamitin Collections.EMPTY_MAPsa halip na ibalik null.

Gumamit ng @NotNull at @Nullable na mga anotasyon

Sa paglalarawan ng iyong mga pamamaraan, maaari mong tukuyin nullang mga kumbensyon sa kaligtasan ng pamamaraan gamit ang mga anotasyon @NotNullat @Nullable upang isaad kung ang isang paraan ay maaaring bumalik nullo hindi. Maaaring gamitin ng mga modernong compiler at IDE ang mga anotasyong ito upang suriin ang iyong code at magbigay ng naaangkop na payo, halimbawa, tungkol sa nawawalang tseke para sa null, o kabaliktaran, tungkol sa posibilidad ng pag-alis ng hindi kinakailangang tseke na nagbabara sa code. Ang mga naturang anotasyon, halimbawa, ay sinusuportahan ng IntelliJ IDE at FindBugs, at kasama rin ang mga ito sa JSR 305. Ngunit kahit na hindi sinusuportahan ng iyong IDE ang mga naturang anotasyon, magiging mahusay na dokumentasyon ang mga ito sa kanilang sarili. Sa pagtingin @NotNullat @Nullablemagiging mas madali para sa programmer na maunawaan kung saan magdagdag ng tseke para sa nullat kung saan hindi. Ito, sa pamamagitan ng paraan, ay isang medyo bagong kasanayan sa mga programmer ng Java, at magtatagal ito ng oras para kumalat ito.

Iwasan ang hindi kinakailangang autoboxing at autounboxing sa iyong code

Hindi lamang ito humahantong sa paglikha ng mga hindi kinakailangang pansamantalang bagay, ngunit ang autoboxing ay maaari ding maghagis ng NullPointerException kung ang klase ng wrapper ay null. Halimbawa, ang sumusunod na code ay maglalagay ng NullPointerException kung ang entry ng tao ay hindi naglalaman ng numero ng telepono at babalik null.

Person ram = new Person("ram");
int phone = ram.getPhone();

Kapag gumagamit ng autoboxing o autounboxing, hindi lamang ang mga pagkakapantay-pantay, kundi pati na rin ang mga hindi pagkakapantay-pantay <> >ay maaaring magresulta sa isang NullPointerException.

Sundin ang mga convention at tukuyin ang mga makatwirang default.

Isa sa mga pinakamahusay na paraan upang maiwasan ang NullPointerException sa Java ay ang maayos na pagdedeklara at pagsunod sa mga coding convention. Karamihan sa mga NullPointerException ay nangyayari kapag sinubukan mong lumikha ng isang bagay nang hindi nagkakaroon ng lahat ng data at dependency na kinakailangan nito. Sa pamamagitan ng pagpigil sa paglikha ng mga hindi natapos na bagay sa pamamagitan ng magandang pagtanggi sa mga naturang kahilingan, ililigtas mo ang iyong sarili mula sa isang malaking bilang ng NullPointerExceptions sa hinaharap. Gayundin, kung papayagan mo ang paggawa ng bagay, dapat kang pumili ng isang makatwirang default na halaga. Halimbawa, ang isang bagay ng klase Employeeay hindi maaaring gawin nang walang pangalan at id, ngunit maaaring walang numero ng telepono. Sa kasong ito, ang mga bagay Employeena walang numero ay maaaring magbalik ng zero sa halip null. Bagama't ang gayong pag-uugali ng bagay ay dapat pag-isipan nang maaga - maaaring mas madaling suriin ito nullkaysa tumawag sa isang hindi umiiral na numero. Sa kasong ito, ang pagkakaroon ng mga karagdagang kundisyon sa kung aling mga field ay nullat alin ang hindi ay makakatulong sa paggawa ng tamang desisyon. Sa pangkalahatan, ang pagpili sa pagitan ng agarang pag-crash sa program o pagtatalaga nullnito ay isang mahalagang desisyon sa disenyo, at kapag nagawa mo na ang pagpili, dapat mo itong sundin nang palagian.

Magtakda ng mga paghihigpit sa antas ng DBMS

Kapag gumagamit ng database upang iimbak ang iyong mga bagay sa programa, gaya ng Mga Customer o Mga Order, matalinong tukuyin ang " nullness" ng iyong mga bagay sa antas ng DBMS, gamit ang naaangkop na mga paghihigpit sa talahanayan. Ang mga database ay madalas na naglalaman ng impormasyon mula sa maraming mapagkukunan, at ang pagpapakilala ng mga pagsusuri para sa mga nawawalang halaga ay magpapahusay sa integridad ng iyong data. Bilang karagdagan, ang pagkakaroon ng mga tseke para sa null sa antas ng DBMS ay magbabawas sa mga ito sa iyong Java code: sa pamamagitan ng paglo-load ng data mula sa database papunta sa mga bagay na Java, maaari mong tiyakin ang kanilang presensya at alisin ang hindi kinakailangang " != null" mula sa code ng programa.

Gamitin ang Null Object Pattern

Ang paglikha ng mga espesyal Nullna -object ay isa pang paraan upang maiwasan ang NullPointerExcpetion sa Java. Ipagpalagay natin na ang ilang pamamaraan sa ating aplikasyon ay nagbabalik ng isang bagay na kasunod na gumagana sa programa sa pamamagitan ng pagtawag sa mga pamamaraan nito. Halimbawa, ang pamamaraan Collection.iterator()ay nagbabalik ng isang bagay ng klase Iteratorna ginagamit upang umulit sa koleksyon. Pagkatapos kung ang orihinal na bagay ay walang anumang iterator, nullmaaari mong ibalik ang isang espesyal Nullna -object na mayroong isang paraan hasNext()na palaging nagbabalik false. Iyon lang, mahal na mambabasa, dito ko tatapusin ang aking mga tip para sa pagtanggal ng mga error sa NullPointerException sa mga Java program. Mapapahalagahan mo kung gaano kapaki-pakinabang ang mga simple at hindi mabigat na panuntunang ito. Bilang paalala, kung gusto mong magbahagi ng anumang iba pang trick ng NullPointerException sa mga programang Java, huwag mag-atubiling gawin ito sa mga komento. Partikular na isinalin para sa mga mag-aaral ng JavaRush. Orihinal