Som vi vet er Java-språket et objektorientert programmeringsspråk. Med andre ord er det grunnleggende konseptet, altså grunnlaget for fundamentet, at alt er et objekt. Objekter beskrives ved hjelp av klasser. Klasser definerer på sin side tilstand og atferd. For eksempel kan en bankkonto ha tilstand i form av mengden penger på kontoen og ha atferd som øker og reduserer kontosaldoen. I Java implementeres atferd gjennom metoder. Å lære å definere metoder kommer helt i begynnelsen av Java-studiene. For eksempel i Oracles offisielle veiledning, under overskriften " Defining Methods ". Det er to viktige ting å være oppmerksom på her:
Hver metode har en signatur. Signaturen består av navnet på metoden og dens inngangsparametere.
En returtype må angis for metoder. Du erklærer en metodes returtype i metodeerklæringen.
Returtypen er ikke en del av metodesignaturen. Igjen er dette en konsekvens av at Java er et sterkt maskinskrevet språk og kompilatoren ønsker å vite hvilke typer som brukes og hvor, på forhånd og så mye som mulig. Igjen, dette er for å redde oss fra feil. I utgangspunktet er alt for en god sak. Og det virker for meg som om dette nok en gang innpoder oss en kultur for å håndtere data. Så typen returverdi er spesifisert for metoder. Og returnøkkelordet i Java brukes til å faktisk gjøre returen.
Hva gjør retur i Java
Returnøkkelordet er en kontrollflytsetning, som beskrevet i Oracle- opplæringen her . Du kan også lese om hvordan du returnerer verdier i delen " Returnere en verdi fra en metode " i den offisielle opplæringen. Kompilatoren holder nøye oversikt over om den kan sikre at en metodes returverdi samsvarer med metodens spesifiserte returtype. La oss bruke Tutorialspoints Online IDE for å vurdere et eksempel. La oss se på ureksemplet:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
Som vi kan se, utføres hovedmetoden her, som er programmets inngangspunkt. Kodelinjer kjøres fra topp til bunn. Vår hovedmetode kan ikke returnere en verdi. Hvis vi prøver å returnere en verdi der, får vi en feilmelding: "Feil: Hovedmetoden må returnere en verdi av typen void" . Følgelig sendes metoden ganske enkelt ut til skjermen. La oss nå flytte strengen bokstavelig til en egen metode for å generere meldingen:
public class HelloWorld {
public static void main(String[] args) {
System.out.println(getHelloMessage());
}
public static String getHelloMessage() {
return "Hello World";
}
}
Som vi kan se brukte vi nøkkelordet return for å indikere returverdien, som vi deretter sendte til println -metoden. Erklæringen for getHelloMessage- metoden indikerer at metoden vil returnere en streng . Dette lar kompilatoren sjekke at metodens handlinger stemmer overens med hvordan den er deklarert. Naturligvis kan returtypen spesifisert i en metodeerklæring være bredere enn typen av verdien som faktisk returneres i koden, dvs. det viktigste er at en typekonvertering er mulig. Ellers vil vi få en feilmelding ved kompilering: "Feil: inkompatible typer" . Forresten har du sikkert et spørsmål: Hvorfor er returbetraktet som en kontrollflyterklæring? Fordi det kan forstyrre den normale ovenfra-og-ned-flyten til et program. Eksempel:
public class HelloWorld {
public static void main(String[] args) {
if (args.length == 0) {
return;
}
for (String arg : args) {
System.out.println(arg);
}
}
}
Som du kan se fra eksempelet, avbryter vi hovedmetoden i Java-programmet hvis den kalles uten argumenter. Det er viktig å huske at hvis du har kode etter en returoppgave , vil den ikke være tilgjengelig. Vår smarte kompilator vil legge merke til det og hindre deg i å kjøre et slikt program. For eksempel kompilerer ikke denne koden:
public static void main(String[] args) {
System.out.println("1");
return;
// we use output method after return statement, which is incorrect
System.out.println("2");
}
Det er en skitten hack for å komme rundt dette. For eksempel for feilsøkingsformål, eller av en annen grunn. Koden ovenfor kan fikses ved å pakke retursetningen inn i en if- blokk:
if (2==2) {
return;
}
Returerklæring under feilhåndtering
Det er noe annet som er veldig vanskelig - vi kan bruke retur i forbindelse med feilhåndtering. Jeg vil si med en gang at å bruke en retursetning i en catch- blokk er veldig, veldig dårlig, så du bør unngå det. Men vi trenger et eksempel, ikke sant? Her er det:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Value: " + getIntValue());
}
public static int getIntValue() {
int value = 1;
try {
System.out.println("Something terrible happens");
throw new Exception();
} catch (Exception e) {
System.out.println("Cached value: " + value);
return value;
} finally {
value++;
System.out.println("New value: " + value);
}
}
}
Ved første øyekast ser det ut til at 2 bør returneres, siden til slutt alltid utføres. Men nei, returverdien vil være 1, og endringen til variabelen i finally -blokken vil bli ignorert. Anta dessuten at verdien inneholder et objekt og vi sier verdi = null i den endelige blokken. Da ville objektet, ikke null, bli returnert i catch- blokken. Men en returerklæring ville fungere riktig i den endelige blokken. Selvfølgelig vil ikke kollegene dine takke deg for små overraskelser som involverer returerklæringer.
void.class
Og endelig. Det er denne merkelige konstruksjonen du kan skrive: void.class . Hmm. Hvorfor og hva betyr det? Det er virkelig forskjellige rammer og vanskelige tilfeller som involverer Java Reflection API hvor dette kan være veldig nyttig. Du kan for eksempel sjekke hvilken type en metode returnerer:
import java.lang.reflect.Method;
public class HelloWorld {
public void getVoidValue() {
}
public static void main(String[] args) {
for (Method method : HelloWorld.class.getDeclaredMethods()) {
System.out.println(method.getReturnType() == void.class);
}
}
}
Dette kan være nyttig i testrammer der du må erstatte selve koden i metoder. Men for å gjøre dette, må du forstå hvordan en metode oppfører seg (dvs. hvilken type den returnerer). Det er også en annen måte å implementere hovedmetoden i koden ovenfor:
public static void main(String[] args) {
for (Method method : HelloWorld.class.getDeclaredMethods()) {
System.out.println(method.getReturnType() == Void.TYPE);
}
}
GO TO FULL VERSION