IllegalArgumentException of NullPointerException vir 'n nul-parameter?[gesluit]

StackOverflow https://stackoverflow.com/questions/3881

Vra

Ek het 'n eenvoudige stel metode vir 'n eiendom en null is nie geskik vir hierdie spesifieke eiendom nie.Ek was nog altyd verskeur in hierdie situasie:moet ek gooi 'n IllegalArgumentException, of a NullPointerException?Uit die javadocs lyk albei gepas.Is daar 'n soort van 'n verstaanbare standaard?Of is dit net een van daardie dinge wat jy moet doen wat jy ook al verkies en albei is regtig korrek?

Was dit nuttig?

Oplossing

Dit lyk soos 'n IllegalArgumentException word gevra as jy nie wil nie null om 'n toegelate waarde te wees, en die NullPointerException sou gegooi word as jy probeer gebruik 'n veranderlike wat blyk te wees null.

Ander wenke

Jy behoort te gebruik IllegalArgumentException (IAE), nie NullPointerException (NPE) om die volgende redes:

Eerstens, die NPE JavaDoc lys eksplisiet die gevalle waar NPE toepaslik is.Let op dat almal van hulle gegooi word deur die looptyd wanneer null word onvanpas gebruik.Daarteenoor het die IAE JavaDoc kan nie meer duidelik wees nie:'Gooi om aan te dui dat 'n metode 'n onwettige of onvanpaste argument gegee is.' Ja, dit is jy!

Tweedens, wanneer jy 'n NPE in 'n stapelspoor sien, wat neem jy aan?Waarskynlik dat iemand van a null.As jy IAE sien, neem jy aan dat die oproeper van die metode bo-aan die stapel in 'n onwettige waarde geslaag het.Weereens, laasgenoemde aanname is waar, eersgenoemde is misleidend.

Derdens, aangesien IAE duidelik ontwerp is om parameters te valideer, moet jy dit as die verstekkeuse van uitsondering aanvaar, so hoekom sal jy eerder NPE kies?Beslis nie vir verskillende gedrag nie - verwag jy regtig dat oproepkode NPE's apart van IAE sal vang en as gevolg daarvan iets anders sal doen?Probeer jy om 'n meer spesifieke foutboodskap te kommunikeer?Maar jy kan dit in elk geval in die uitsonderingsboodskapteks doen, soos jy moet vir alle ander verkeerde parameters.

Vierdens, alle ander verkeerde parameterdata sal IAE wees, so hoekom nie konsekwent wees nie?Hoekom is dit onwettig null is so spesiaal dat dit 'n aparte uitsondering van alle ander soorte onwettige argumente verdien?

Ten slotte aanvaar ek die argument wat deur ander antwoorde gegee word dat dele van die Java API op hierdie manier NPE gebruik.Die Java API is egter teenstrydig met alles van uitsonderingstipes tot benamingskonvensies, so ek dink om net blindelings (jou gunsteling deel van) die Java API te kopieer is nie 'n goeie genoeg argument om hierdie ander oorwegings te troef nie.

Die standaard is om die te gooi NullPointerException.Die algemeen onfeilbare "Effektiewe Java" bespreek dit kortliks in Item 42 (eerste uitgawe), Item 60 (tweede uitgawe), of Item 72 (derde uitgawe) "Voorkeur die gebruik van standaard uitsonderings":

'Sekerlik, alle verkeerde metode -oproepe kom neer op 'n onwettige argument of onwettige toestand, maar ander uitsonderings word standaard gebruik vir sekere soorte onwettige argumente en state.As 'n oproeper nul in een of ander parameter waarvoor nulwaardes verbode is, bepaal dat nulpointerException eerder as onwettigAargumentException gegooi word. "

Ek was almal ten gunste van gooi IllegalArgumentException vir nul parameters, tot vandag toe, toe ek opgemerk het die java.util.Objects.requireNonNull metode in Java 7.Met daardie metode, in plaas van om te doen:

if (param == null) {
    throw new IllegalArgumentException("param cannot be null.");
}

jy kan doen:

Objects.requireNonNull(param);

en dit sal 'n gooi NullPointerException as die parameter wat jy slaag dit is null.

Gegewe dat daardie metode is reg bang in die middel van java.util Ek neem sy bestaan ​​as 'n redelike sterk aanduiding dat gooi NullPointerException is "die Java manier om dinge te doen".

Ek dink ek is in elk geval besluit.

Let daarop dat die argumente oor harde ontfouting vals is, want jy kan natuurlik 'n boodskap aan NullPointerException sê wat nul is en hoekom dit nie nul moet wees nie.Net soos met IllegalArgumentException.

Een bykomende voordeel van NullPointerException is dat, in hoogs prestasie-kritiese kode, jy kan afsien van 'n eksplisiete tjek vir nul (en a NullPointerException met 'n vriendelike foutboodskap), en maak net staat op die NullPointerException jy sal outomaties kry wanneer jy 'n metode op die nul-parameter oproep.Met dien verstande dat jy vinnig 'n metode aanroep (d.w.s.vinnig misluk), dan het jy in wese dieselfde effek, net nie heeltemal so gebruikersvriendelik vir die ontwikkelaar nie.Meeste kere is dit waarskynlik beter om eksplisiet na te gaan en met 'n nuttige boodskap te gooi om aan te dui watter parameter nul was, maar dit is lekker om die opsie te hê om dit te verander as prestasie dit bepaal sonder om die gepubliseerde kontrak van die metode/konstruktor te verbreek.

Ek is geneig om die ontwerp van JDK-biblioteke te volg, veral versamelings en sameloop (Joshua Bloch, Doug Lea, daardie ouens weet hoe om soliede API's te ontwerp).In elk geval, baie API's in die JDK gooi pro-aktief NullPointerException.

Byvoorbeeld, die Javadoc vir Map.containsKey verklaar:

@Trows NullPointerException As die sleutel nul is en hierdie kaart nie nul -sleutels (opsioneel) toelaat nie.

Dit is heeltemal geldig om jou eie NPE te gooi.Die konvensie is om die parameternaam wat nul was in die boodskap van die uitsondering in te sluit.

Die patroon lui:

public void someMethod(Object mustNotBeNull) {  
    if (mustNotBeNull == null) {  
        throw new NullPointerException("mustNotBeNull must not be null");  
    }  
}

Wat jy ook al doen, moenie toelaat dat 'n slegte waarde ingestel word nie en gooi later 'n uitsondering wanneer ander kode dit probeer gebruik.Dit maak ontfouting 'n nagmerrie.Jy moet altyd die "fail-fast"-beginsel volg.

Jason Cohen se argument gestem omdat dit goed aangebied is.Laat ek dit stap vir stap uitmekaar haal.;-)

  • Die NPE JavaDoc sê uitdruklik, "ander onwettige gebruike van die nul-voorwerp".As dit net beperk was tot situasies waar die looptyd 'n nul teëkom wanneer dit nie moet nie, kan al sulke gevalle baie meer bondig gedefinieer word.

  • Kan dit nie help as jy die verkeerde ding aanneem nie, maar met die veronderstelling dat inkapseling behoorlik toegepas word, moet jy regtig nie omgee of agterkom of 'n nul nie onvanpas afgewys is vs.of 'n metode 'n onvanpaste nulwaarde opgespoor het en 'n uitsondering afgevuur het.

  • Ek sou kies NPE oor IAE om verskeie redes

    • Dit is meer spesifiek oor die aard van die onwettige operasie
    • Logika wat verkeerdelik nulle toelaat, is geneig om baie anders te wees as logika wat verkeerdelik onwettige waardes toelaat.Byvoorbeeld, as ek data bekragtig wat deur 'n gebruiker ingevoer is, as ek waarde kry wat onaanvaarbaar is, is die bron van daardie fout by die eindgebruiker van die toepassing.As ek 'n nul kry, is dit 'n programmeerderfout.
    • Ongeldige waardes kan dinge veroorsaak soos stapeloorloop, foute uit die geheue, ontleed-uitsonderings, ens.Inderdaad, die meeste foute verskyn gewoonlik op 'n sekere punt as 'n ongeldige waarde in een of ander metode-oproep.Om hierdie rede sien ek IAE as eintlik die ALGEMEEN van alle uitsonderings onder RuntimeException.

  • Eintlik kan ander ongeldige argumente tot allerhande ander uitsonderings lei. UnknownHostException, FileNotFoundException, 'n verskeidenheid sintaksfoutuitsonderings, IndexOutOfBoundsException, verifikasie mislukkings, ens., ens.

Oor die algemeen voel ek dat NPE baie verguis word omdat dit tradisioneel geassosieer is met kode wat nie daarin slaag om die te volg nie faal vinnig beginsel.Dit, plus die JDK se versuim om NPE's met 'n boodskapstring te vul, het werklik 'n sterk negatiewe sentiment geskep wat nie goed gegrond is nie.Inderdaad, die verskil tussen NPE en IAE vanuit 'n runtime-perspektief is streng die naam.Vanuit daardie perspektief, hoe meer presies jy met die naam is, hoe meer duidelikheid gee jy aan die oproeper.

Dit is 'n "Heilige Oorlog"-styl vraag.Met ander woorde, albei alternatiewe is goed, maar mense sal hul voorkeure hê wat hulle tot die dood toe sal verdedig.

As dit 'n setter metode en null daarheen deurgegee word, dink ek dit sal meer sin maak om 'n te gooi IllegalArgumentException.A NullPointerException blyk meer sin te maak in die geval waar jy probeer om die null.

Dus, as jy dit gebruik en dit is null, NullPointer.As dit ingegee word en dit is null, IllegalArgument.

Apache Commons Lang het 'n NullArgumentException dit doen 'n aantal van die dinge wat hier bespreek word:dit brei IllegalArgumentException uit en sy enigste konstruktor neem die naam van die argument wat nie-nul moes gewees het.

Terwyl ek voel dat om iets soos 'n NullArgumentException of IllegalArgumentException te gooi, die buitengewone omstandighede meer akkuraat beskryf, het ek en my kollegas gekies om na Bloch se advies oor die onderwerp te luister.

Kon nie meer saamstem met wat gesê word nie.Misluk vroeg, misluk vinnig.Redelik goed Uitsondering mantra.

Die vraag oor watter uitsondering om te gooi is meestal 'n kwessie van persoonlike smaak.In my gedagtes lyk IllegalArgumentException meer spesifiek as om 'n NPE te gebruik, aangesien dit vir my sê dat die probleem was met 'n argument wat ek na die metode oorgedra het en nie met 'n waarde wat moontlik gegenereer is tydens die uitvoering van die metode nie.

My 2 sente

Die aanvaarde praktyk as om die te gebruik IllegalArgumentException (String message) om 'n parameter as ongeldig te verklaar en soveel detail as moontlik te gee ...Om te sê dat daar gevind is dat 'n parameter nul is terwyl uitsondering nie nul is nie, sou jy iets soos volg doen:

if( variable == null )
    throw new IllegalArgumentException("The object 'variable' cannot be null");

Jy het feitlik geen rede om die "NullPointerException" implisiet te gebruik nie.Die NullPointerException is 'n uitsondering wat deur die Java Virtual Machine gegooi word wanneer jy probeer om kode op nulverwysing uit te voer (soos toString()).

Eintlik is die vraag om IllegalArgumentException of NullPointerException te gooi na my beskeie siening slegs 'n "heilige oorlog" vir 'n minderheid met 'n onvolledige begrip van uitsonderingshantering in Java.Oor die algemeen is die reëls eenvoudig en soos volg:

  • argumentbeperkingsoortredings moet so vinnig as moontlik aangedui word (-> vinnig misluk), om onwettige toestande te vermy wat baie moeiliker is om te ontfout
  • in die geval van 'n ongeldige nulwyser vir watter rede ook al, gooi NullPointerException
  • in die geval van 'n onwettige skikking/versameling-indeks, gooi ArrayIndexOutOfBounds
  • in die geval van 'n negatiewe skikking / versameling grootte, gooi NegativeArraySizeException
  • in die geval van 'n onwettige argument wat nie deur bogenoemde gedek word nie, en waarvoor jy nie 'n ander meer spesifieke uitsonderingstipe het nie, gooi IllegalArgumentException as 'n vullismandjie
  • aan die ander kant, in die geval van 'n beperking oortreding BINNE 'N VELD wat om een ​​of ander geldige rede nie deur vinnige mislukking vermy kon word nie, vang en gooi terug as Onwettige Staat Uitsondering of 'n meer spesifieke gekontroleerde uitsondering.Moet nooit die oorspronklike NullPointerException, ArrayIndexOutOfBounds, ens in hierdie geval laat verbygaan nie!

Daar is ten minste drie baie goeie redes teen die geval van kartering van alle soorte argumentbeperkingsoortredings na IllegalArgumentException, met die derde wat waarskynlik so ernstig is dat dit die praktyk slegte styl aandui:

(1) 'n Programmeerder kan nie veilig aanvaar dat alle gevalle van argumentbeperkingsoortredings tot Onwettige ArgumentUitsondering lei nie, want die groot meerderheid standaardklasse gebruik hierdie uitsondering eerder as 'n vullismandjie as daar nie 'n meer spesifieke soort uitsondering beskikbaar is nie.Om alle gevalle van argument-beperkingsoortredings na IllegalArgumentException in jou API te probeer karteer, lei net tot programmeerder frustrasie deur jou klasse te gebruik, aangesien die standaardbiblioteke meestal verskillende reëls volg wat joune oortree, en die meeste van jou API-gebruikers sal dit ook gebruik!

(2) Kartering van die uitsonderings lei eintlik tot 'n ander soort anomalie, wat deur enkeloorerwing veroorsaak word:Alle Java-uitsonderings is klasse, en ondersteun dus slegs enkeloorerwing.Daarom is daar geen manier om 'n uitsondering te skep wat werklik 'n NullPointerException en 'n IllegalArgumentException is nie, aangesien subklasse slegs van die een of die ander kan erf.Om 'n IllegalArgumentException te gooi in die geval van 'n nul-argument maak dit dus moeiliker vir API-gebruikers om tussen probleme te onderskei wanneer 'n program die probleem programmaties probeer regstel, byvoorbeeld deur verstekwaardes in 'n oproepherhaling in te voer!

(3) Kartering skep eintlik die gevaar van foutmaskering:Om argumentbeperkingsoortredings in IllegalArgumentException te karteer, sal jy 'n buitenste probeervanger moet kodeer binne elke metode wat enige beperkende argumente het.Om RuntimeException bloot in hierdie catch-blok te vang, is egter nie ter sprake nie, want dit loop die risiko om gedokumenteerde RuntimeExceptions wat deur vrye metodes wat binne jou gebruik word, in IllegalArgumentException gegooi word, in IllegalArgumentException te karteer, selfs al word dit nie veroorsaak deur argumentbeperkingsoortredings nie.So jy moet baie spesifiek wees, maar selfs daardie poging beskerm jou nie teen die geval dat jy per ongeluk 'n ongedokumenteerde looptyd-uitsondering van 'n ander API (d.i.'n fout) in 'n IllegalArgumentException van jou API.Selfs die noukeurigste kartering loop dus die risiko om programmeringsfoute van ander biblioteekvervaardigers te masker as argumentbeperkingsoortredings van jou metode se gebruikers, wat eenvoudig hillareous gedrag is!

Met die standaardpraktyk aan die ander kant, bly die reëls eenvoudig, en uitsonderingsoorsake bly ontmasker en spesifiek.Vir die metode-oproeper is die reëls ook maklik:- As u 'n gedokumenteerde runtime -uitsondering van enige aard teëkom omdat u 'n onwettige waarde geslaag het, moet u die oproep met 'n standaard herhaal (vir hierdie spesifieke uitsonderings is nodig), of korrigeer u kode - as u aan die ander kant 'n uitsondering van die tydsduur het word nie gedokumenteer om te gebeur vir 'n gegewe stel argumente nie, lê 'n foutverslag by die vervaardigers van die metode om te verseker dat óf hul kode óf hul dokumentasie reggestel is.

Oor die algemeen moet 'n ontwikkelaar nooit gooi 'n NullPointerException.Hierdie uitsondering word gegooi deur die looptyd wanneer kode probeer om 'n veranderlike wat se waarde nul is, te herverwys.Daarom, as jou metode nul uitdruklik wil verbied, in teenstelling met die feit dat 'n nulwaarde 'n NullPointerException verhoog, moet jy 'n IllegalArgumentException gooi.

Gooi 'n uitsondering wat eksklusief is null argumente (of NullPointerException of 'n pasgemaakte tipe) maak outomaties null toets meer betroubaar.Hierdie outomatiese toetsing kan gedoen word met refleksie en 'n stel verstekwaardes, soos in Koejawelse NullPointerTester.Byvoorbeeld, NullPointerTester sal probeer om die volgende metode te noem...

Foo(String string, List<?> list) {
  checkArgument(string.length() > 0);
  // missing null check for list!
  this.string = string;
  this.list = list;
}

...met twee lyste argumente: "", null en null, ImmutableList.of().Dit sal toets dat elkeen van hierdie oproepe die verwagte gee NullPointerException.Vir hierdie implementering, slaag a null lys doen nie produseer NullPointerException.Dit produseer egter toevallig 'n IllegalArgumentException want NullPointerTester gebruik toevallig 'n verstekstring van "".As NullPointerTester slegs verwag NullPointerException vir null waardes, vang dit die fout.As dit verwag IllegalArgumentException, dit mis dit.

As 'n subjektiewe vraag moet dit gesluit wees, maar aangesien dit nog oop is:

Dit is deel van die interne beleid wat by my vorige werkplek gebruik is en dit het baie goed gewerk.Dit is alles uit die geheue so ek kan nie die presiese bewoording onthou nie.Dit is opmerklik dat hulle nie gekontroleerde uitsonderings gebruik het nie, maar dit is buite die bestek van die vraag.Die ongemerkte uitsonderings wat hulle wel gebruik het, het in 3 hoofkategorieë geval.

NullPointerException:Moenie doelbewus gooi nie.NPE's moet slegs deur die VM gegooi word wanneer 'n nulverwysing afgewys word.Alle moontlike pogings moet aangewend word om te verseker dat dit nooit gegooi word nie.@Nullable en @NotNull moet saam met kode-analise-nutsmiddels gebruik word om hierdie foute te vind.

Onwettige Argument Uitsondering:Gewerp wanneer 'n argument na 'n funksie nie ooreenstem met die publieke dokumentasie nie, sodat die fout geïdentifiseer en beskryf kan word in terme van die argumente wat ingedien is.Die OP se situasie sal in hierdie kategorie val.

Onwettige Staat Uitsondering:Word gegooi wanneer 'n funksie geroep word en sy argumente is óf onverwags wanneer hulle geslaag word óf onversoenbaar met die toestand van die voorwerp waarvan die metode 'n lid is.

Daar was byvoorbeeld twee interne weergawes van die IndexOutOfBoundsException wat gebruik word in dinge wat 'n lengte gehad het.Een 'n subklas van IllegalStateException, gebruik as die indeks groter as die lengte was.Die ander 'n subklas van IllegalArgumentException, wat gebruik word as die indeks negatief was.Dit was omdat jy meer items by die voorwerp kon voeg en die argument sou geldig wees, terwyl 'n negatiewe getal nooit geldig is nie.

Soos ek gesê het, werk hierdie stelsel baie goed, en dit het iemand gekos om te verduidelik hoekom die onderskeid daar is:“Afhangende van die tipe fout is dit vir jou redelik eenvoudig om uit te vind wat om te doen.Selfs as jy nie eintlik kan uitvind wat verkeerd geloop het nie, kan jy uitvind waar om daardie fout op te spoor en bykomende ontfoutingsinligting te skep."

NullPointerException:Hanteer die Nul-saak of plaas 'n bewering sodat die NPE nie gegooi word nie.As jy in 'n bewering is net een van die ander twee tipes.Indien moontlik, gaan voort met ontfouting asof die bewering in die eerste plek daar was.

Onwettige Argument Uitsondering:jy het iets fout by jou oproep werf.As die waardes wat ingegee word van 'n ander funksie is, vind uit hoekom jy 'n verkeerde waarde ontvang.As jy een van jou argumente deurgee, versprei die fout, kontroleer die oproepstapel totdat jy die funksie vind wat nie teruggee wat jy verwag nie.

Onwettige Staat Uitsondering:Jy het nie jou funksies in die regte volgorde geroep nie.As jy een van jou argumente gebruik, gaan dit na en gooi 'n IllegalArgumentException wat die kwessie beskryf.Jy kan dan die wange teen die stapel versprei totdat jy die probleem vind.

In elk geval, sy punt was dat jy net die IllegalArgumentAssertions op die stapel kan kopieer.Daar is geen manier vir jou om die IllegalStateExceptions of NullPointerExceptions op die stapel te versprei nie, want hulle het iets met jou funksie te doen gehad.

Ek wou Null-argumente uit ander onwettige argumente uitsonder, so ek het 'n uitsondering afgelei van IAE genaamd NullArgumentException.Sonder om eers die uitsonderingsboodskap te lees, weet ek dat 'n nulargument in 'n metode oorgedra is en deur die boodskap te lees, vind ek uit watter argument nul was.Ek vang steeds die NullArgumentException met 'n IAE-hanteerder, maar in my logs is dit waar ek die verskil vinnig kan sien.

die tweespalt...Oorvleuel hulle nie?Slegs nie-oorvleuelende dele van 'n geheel kan 'n digotomie maak.Soos ek dit sien:

throw new IllegalArgumentException(new NullPointerException(NULL_ARGUMENT_IN_METHOD_BAD_BOY_BAD));

Sommige versamelings aanvaar dit null word verwerp met behulp van NullPointerException eerder as IllegalArgumentException.Byvoorbeeld, as jy 'n stel vergelyk wat bevat null na 'n stel wat verwerp null, sal die eerste stel oproep containsAll op die ander en vang sy NullPointerException -- maar nie IllegalArgumentException.(Ek kyk na die implementering van AbstractSet.equals.)

Jy kan redelikerwys redeneer dat die gebruik van ongemerkte uitsonderings op hierdie manier 'n antipatroon is, dat die vergelyking van versamelings wat bevat null aan versamelings wat nie kan bevat nie null is 'n waarskynlike fout wat regtig behoort produseer 'n uitsondering, of daardie plaas null in 'n versameling enigsins 'n slegte idee is.Nietemin, tensy jy bereid is om dit te sê equals moet 'n uitsondering gooi in so 'n geval, jy bly vas om dit te onthou NullPointerException word in sekere omstandighede vereis, maar nie in ander nie.("IAE voor NPE behalwe na 'c'...")

NullPointerException gegooi wanneer probeer om toegang te verkry tot 'n voorwerp met 'n verwysingsveranderlike waarvan die huidige waarde nul is

IllegalArgumentException gegooi wanneer 'n metode 'n argument ontvang wat anders geformateer is as wat die metode verwag

Volgens jou scenario, IllegalArgumentException is die beste keuse, want null is nie 'n geldige waarde vir jou eiendom nie.

Ideaal gesproke moet runtime-uitsonderings nie gegooi word nie.'n Gemerkte uitsondering (besigheidsuitsondering) moet vir jou scenario geskep word.Want as een van hierdie uitsonderings gegooi en aangeteken word, mislei dit die ontwikkelaar terwyl hy deur die logs gaan.In plaas daarvan skep besigheidsuitsonderings nie daardie paniek nie en word dit gewoonlik geïgnoreer tydens die oplos van logs.

Die definisies van die skakels na die twee uitsonderings hierbo is onwettigArgumentException:Gooi om aan te dui dat 'n metode geslaag is 'n onwettige of onvanpaste argument.NullPointerException:Gooi wanneer 'n toepassing probeer om nul te gebruik in 'n geval waar 'n voorwerp vereis word.

Die groot verskil hier is dat die IllegalArgumentException veronderstel is om gebruik te word wanneer gekontroleer word dat 'n argument vir 'n metode geldig is.NullPointerException is veronderstel om gebruik te word wanneer 'n voorwerp "gebruik" word wanneer dit nul is.

Ek hoop dit help om die twee in perspektief te plaas.

As dit 'n "setter" is, of iewers wat ek 'n lid kry om later te gebruik, is ek geneig om IllegalArgumentException te gebruik.

As dit iets is wat ek nou (afwysing) in die metode gaan gebruik, gooi ek 'n NullPointerException proaktief.Ek hou beter hiervan as om die looptyd dit te laat doen, want ek kan 'n nuttige boodskap verskaf (dit lyk of die looptyd dit ook kan doen, maar dit is 'n rant vir 'n ander dag).

As ek 'n metode ignoreer, gebruik ek alles wat die oorheerste metode gebruik.

Jy moet 'n IllegalArgumentException gooi, want dit sal dit duidelik maak vir die programmeerder dat hy iets ongeldig gedoen het.Ontwikkelaars is so gewoond daaraan om te sien dat NPE deur die VM gegooi word, dat enige programmeerder nie dadelik sy fout sal besef nie, en sal lukraak begin rondkyk, of erger nog, jou kode blameer dat dit 'fout' is.

In hierdie geval dra IllegalArgumentException duidelike inligting oor aan die gebruiker wat jou API gebruik dat die "nie nul moet wees nie".Soos ander forumgebruikers uitgewys het, kan jy NPE gebruik as jy wil solank jy die regte inligting aan die gebruiker oordra wat jou API gebruik.

GaryF en tweakt het "Effective Java" (waarby ek sweer) verwysings laat val wat aanbeveel dat NPE gebruik word.En kyk na hoe ander goeie API's gebou word, is die beste manier om te sien hoe om jou API te bou.

Nog 'n goeie voorbeeld is om na die Spring API's te kyk.Byvoorbeeld, org.springframework.beans.BeanUtils.instantiateClass(Constructor ctor, Object[] args) het 'n Assert.notNull(ctor, "Constructor must not be null")-lyn.org.springframework.util.Assert.notNull(Object object, String message) metode kontroleer om te sien of die argument (voorwerp) wat ingegee is nul is en as dit is, gooi dit 'n nuwe IllegalArgumentException(boodskap) wat dan in die org vasgevang word. springframework.beans.BeanUtils.instantiateClass(...) metode.

As jy kies om 'n NPE te gooi en jy gebruik die argument in jou metode, kan dit oorbodig en duur wees om uitdruklik na 'n nul te kyk.Ek dink die VM doen dit reeds vir jou.

Gelisensieer onder: CC-BY-SA met toeskrywing
Nie verbonde aan StackOverflow
scroll top