De fleste Java-udviklere har sandsynligvis fyldt NullPointerException. De fleste af os har lært værdien af at gøre visse ting for at reducere vores "muligheder" for at møde NullPointerException. Der er faktisk en Wiki-side dedikeret til at forhindre eller reducere NullPointerExceptions.
Flere mennesker har argumenteret for yderligere sprogstøtte til forbedret og lettere håndtering af potentiel null. Disse inkluderer Java SE 7-forslag, Optimeret Null Check og Kinga Dobolyis afhandling Changing Java's Semantics for Handling Null Pointer Undtagelser.
Blandt de mange ting, vi allerede kan gøre ret let for at reducere vores møder med NullPointerException, er en særlig let ting at gøre at anvende String.valueOf (Object), når det er relevant. Det String.valueOf (Object) metode, som det fremgår af Javadoc-genereret dokumentation, returnerer "null", hvis objektet, der er sendt nul og returnerer resultaterne på den indsendte Objekt's toString () -opkald, hvis det er sendt ind Objekt er ikke nul. Med andre ord, String.valueOf (String) kontrollerer nul for dig.
Brugen af String.valueOf (Object) er særlig nyttig ved implementering toString metoder på tilpassede klasser. Fordi de fleste toString implementeringer giver klassens data medlemmer i strengformat, String.valueOf (Object) er en naturlig pasform. Alle Java-objekter baseret på klasser, der udvider Object, giver en toString () implementering, selvom det simpelthen er deres forældres (eller endda Objekt's) gennemførelse af toString (). Men hvis en medlemsklasse implementerer toString men selve medlemmet er nul snarere end en forekomst af klassen, så er toString () gør ikke noget godt (og fører faktisk til en NullPointerException når kaldet).
Dette demonstreres med følgende eksempelkode.
StringHandlingExample.java
pakke dustin. eksempler; importere java.io.IOException; importere java.io.OutputStream; importere java.util.logging.Logger; / ** * Eksempelklasse, der viser brugen af strengrepræsentationer, der er tilgængelige via * implicit String, toString () og String.valueOf (). * / public class StringHandlingExample {private static final String NEW_LINE = System.getProperty ("line.separator"); / ** Brug af java.util.logging. * / privat statisk logger LOGGER = Logger.getLogger (StringHandlingExample.class.getName ()); / ** * Hovedfunktion til at køre tests / demonstrationer. * * @param argumenter Kommandolinjeargumenter; ingen forventede. * / public static void main (final String [] argumenter) {printHeader ("Stringrepræsentation af direkte strenge", System.out); endelig Personnavn personnavn = nyt Personnavn ("Flintstone", null); System.out.println ("Persons navn [DIRECT]:" + personnavn); System.out.println ("Persons navn [TOSTRING]:" + personnavn.toString ()); System.out.println ("Persons navn [STRING.VALUEOF]:" + String.valueOf (personnavn)); printBlankLine (System.out); printHeader ("Stringrepræsentation af ikke-nul kompleks objekt", System.out); endelig Person personOne = ny person (personnavn); System.out.println ("Person One [DIRECT]:" + personOne); System.out.println ("Person One [TOSTRING]:" + personOne.toString ()); System.out.println ("Person One [STRING.VALUEOF]:" + String.valueOf (personOne)); printBlankLine (System.out); printHeader ("Stringrepræsentation af nul kompleks objekt", System.out); endelig Person personTo = ny person (null); System.out.println ("Person Two [DIRECT]:" + personTo); System.out.println ("Person Two [TOSTRING]:" + personTwo.toString ()); System.out.println ("Person Two [STRING.VALUEOF]:" + String.valueOf (personTwo)); printBlankLine (System.out); } offentlig statisk ugyldig printHeader (endelig strengmeddelelse, endelig OutputStream out) {endelig streng headerSeparator = "================================= ======================================== "; prøv {out.write ((headerSeparator + NEW_LINE + besked + NEW_LINE) .getBytes ()); out.write ((headerSeparator + NEW_LINE) .getBytes ()); } fange (IOException ioEx) {System.out.println (headerSeparator); System.out.println (besked); System.out.println (headerSeparator); LOGGER.warning ("Kunne ikke skrive headeroplysninger til den leverede OutputStream."); }} offentlig statisk ugyldig printBlankLine (endelig OutputStream ud) {prøv {out.write (NEW_LINE.getBytes ()); } fange (IOException ioEx) {System.out.println (NEW_LINE); LOGGER.warning ("Kunne ikke skrive tom linje til forudsat OutputStream."); }} / ** * Klasse, som du skal ringe tilString. * / privat statisk klasse Personnavn {privat streng efternavn; privat streng fornavn; public PersonName (final String newLastName, final String newFirstName) {lastName = newLastName; firstName = newFirstName; } / ** * Angiv strengrepræsentation af mig. * * @retur Min strengrepræsentation. * / @Override public String toString () {return firstName + "" + lastName; }} privat statisk klasse person {privat personnavn navn; offentlig person (endelig personnavn nyt navn) {navn = nyt navn; } / ** * Angiv strengrepræsentation af mig. * * @retur Min strengrepræsentation. * / public String toString () {// Brug ikke - fører til kompileringstidsfejl (inkompatible typer) // returnavn; // Brug ikke - kan føre til kørselsfejl (NullPointerException) // return name.toString (); // Det er alt sammen godt afkast String.valueOf (navn); }}} Ovenstående kode kan bruges til at demonstrere bygning af en toString metode på et komplekst objekt, og hvordan det opfører sig, når det kaldes af en ejerklasse. Metoden af mest interesse er nederst i koden vist ovenfor. To returværdier kommenteres på grund af problemer forbundet med dem. Det sidste eksempel ved hjælp af String.valueOf (Object) kommenteres IKKE, fordi det fungerer bedst, hver gang det køres, uanset om det er komplekset Personnavn objektet er nul. De næste tre billeder viser output for hver af disse præsentationer af personobjektenes strengrepræsentationer.
Strengværdi fra komplekst objekt - Compile-time Error
Strengværdi fra komplekst objekt til String () - Potentiel kørselstid NullPointerException
Strengværdi fra komplekst objekt String.valueOf () - Nulls håndteret yndefuldt
Ved brug af String.valueOf (Object) i toString () implementeringer kan være særligt gavnlige, fordi vi ofte bruger toString () metode til debugging og den sidste ting, vi har brug for i sådanne tilfælde, er en anden undtagelse, når vi prøver at se den aktuelle tilstand af vores data. Selvfølgelig kan man også implementere toString () metoder med ens egne kontroller for null eller, endnu bedre, man kan bruge noget som ToStringBuilder. Dog er tilgængeligheden af String.valueOf (Object) er bestemt noget, der er værd at huske på, og det er noget, jeg bruger mig ret ofte. Mange af os har fundet færre kodelinjer for generelt at være mere klare og String.valueOf (Object) kan være meget mere klart end eksplicit at kontrollere et objekt for nul, inden det påberåbes dets toString () implementering.
Endelig giver klassen String mange overbelastede valueOf-metoder. Ud over den version, der var fokus for dette blogindlæg (accepterer et objekt), accepterer de andre overbelastede versioner af valueOf primitive datatyper og arrays af primitive datatyper.
Konklusion
Uanset hvad fremtiden bringer med hensyn til forbedret nulhåndtering i Java, er der mange taktikker, vi kan tage i dag for at reducere de uønskede (nogle gange vil vi faktisk have dem kastet!) Forekomster af NullPointerException. En af disse er at bruge String.valueOf (Object) når det er relevant.
Yderligere ressourcer
- String.valueOf eller Integer.toString ()?
- Eksplicit versus Implicit Call of toString
- Værdien af en streng med String.valueOf () -metoden
- Konverter nummer til streng
Denne historie, "Værdien af String.valueOf" blev oprindeligt udgivet af JavaWorld.
