Zoals we weten, is de Java-taal een objectgeoriënteerde programmeertaal. Met andere woorden, het fundamentele concept, dwz het fundament van het fundament, is dat alles een object is. Objecten worden beschreven met behulp van klassen. Klassen definiëren op hun beurt toestand en gedrag. Een bankrekening kan bijvoorbeeld een status hebben in de vorm van het geldbedrag op de rekening en gedrag vertonen dat het rekeningsaldo verhoogt of verlaagt. In Java worden gedragingen geïmplementeerd door middel van methoden. Het leren definiëren van methoden staat helemaal aan het begin van je Java-studies. Bijvoorbeeld in de officiële tutorial van Oracle, onder het kopje " Defining Methods ". Er zijn twee belangrijke dingen om hier rekening mee te houden:
Elke methode heeft een handtekening. De handtekening bestaat uit de naam van de methode en de invoerparameters.
Voor methoden moet een retourtype worden opgegeven. U declareert het retourtype van een methode in de methodedeclaratie.
Het retourtype maakt geen deel uit van de methodehandtekening. Ook dit is een gevolg van het feit dat Java een sterk getypeerde taal is en de compiler zoveel mogelijk vooraf wil weten welke typen gebruikt worden en waar. Nogmaals, dit is om ons te behoeden voor fouten. In principe is het allemaal voor een goed doel. En het lijkt mij dat dit ons opnieuw een cultuur van omgaan met gegevens bijbrengt. Het type retourwaarde wordt dus gespecificeerd voor methoden. En het return- sleutelwoord in Java wordt gebruikt om daadwerkelijk terug te keren.
Wat doet return in Java
Het return sleutelwoord is een control flow statement, zoals beschreven in de Oracle tutorial hier . U kunt ook lezen over het retourneren van waarden in het gedeelte " Een waarde retourneren van een methode " van de officiële zelfstudie. De compiler houdt zorgvuldig bij of het ervoor kan zorgen dat de retourwaarde van een methode overeenkomt met het opgegeven retourtype van de methode. Laten we de Online IDE van Tutorialspoint gebruiken om een voorbeeld te bekijken. Laten we eens kijken naar het oervoorbeeld:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
Zoals we kunnen zien, wordt hier de hoofdmethode uitgevoerd, wat het startpunt van het programma is. Coderegels worden van boven naar beneden uitgevoerd. Onze hoofdmethode kan geen waarde retourneren. Als we daar een waarde proberen terug te geven, krijgen we een foutmelding: "Error: Main method must return a value of type void" . Dienovereenkomstig wordt de methode eenvoudig uitgevoerd naar het scherm. Laten we nu de letterlijke tekenreeks verplaatsen naar een aparte methode voor het genereren van het bericht:
public class HelloWorld {
public static void main(String[] args) {
System.out.println(getHelloMessage());
}
public static String getHelloMessage() {
return "Hello World";
}
}
Zoals we kunnen zien, hebben we het sleutelwoord return gebruikt om de retourwaarde aan te geven, die we vervolgens hebben doorgegeven aan de methode println . De declaratie van de methode getHelloMessage geeft aan dat de methode een String retourneert . Hierdoor kan de compiler controleren of de acties van de methode consistent zijn met hoe deze is gedeclareerd. Natuurlijk kan het retourtype gespecificeerd in een methodedeclaratie breder zijn dan het type waarde dat daadwerkelijk wordt geretourneerd in de code, dwz het belangrijkste is dat een typeconversie mogelijk is. Anders krijgen we tijdens het compileren een foutmelding: "Error: incompatible types" . Trouwens, je hebt waarschijnlijk een vraag: waarom is retournerenbeschouwd als een controlestroomverklaring? Omdat het de normale top-down stroom van een programma kan verstoren. Voorbeeld:
public class HelloWorld {
public static void main(String[] args) {
if (args.length == 0) {
return;
}
for (String arg : args) {
System.out.println(arg);
}
}
}
Zoals u in het voorbeeld kunt zien, onderbreken we de hoofdmethode in het Java-programma als deze zonder argumenten wordt aangeroepen. Het is belangrijk om te onthouden dat als u code heeft na een retourverklaring , deze niet toegankelijk is. Onze slimme compiler zal het opmerken en voorkomen dat u zo'n programma uitvoert. Deze code compileert bijvoorbeeld niet:
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");
}
Er is één vuile hack om dit te omzeilen. Bijvoorbeeld voor foutopsporingsdoeleinden of om een andere reden. De bovenstaande code kan worden opgelost door de return- instructie in een if- blok te plaatsen:
if (2==2) {
return;
}
Retourverklaring tijdens foutafhandeling
Er is nog iets heel lastigs: we kunnen return gebruiken in combinatie met foutafhandeling. Ik wil meteen zeggen dat het gebruik van een return -instructie in een catch- blok een heel, heel slechte vorm is, dus je moet het vermijden. Maar we hebben een voorbeeld nodig, toch? Hier is het:
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);
}
}
}
Op het eerste gezicht lijkt het erop dat 2 moet worden geretourneerd, omdat tenslotte altijd wordt uitgevoerd. Maar nee, de geretourneerde waarde is 1 en de wijziging van de variabele in het finaal blok wordt genegeerd. Stel bovendien dat waarde een object bevat en we zeggen waarde = null in het final- blok. Dan zou dat object, niet null, worden geretourneerd in het catch- blok. Maar een return -instructie zou correct werken in het Final- blok. Het is duidelijk dat uw collega's u niet dankbaar zullen zijn voor kleine verrassingen met aangiften.
leegte.klasse
En tenslotte. Er is een vreemde constructie die je kunt schrijven: void.class . Hm. Waarom en wat betekent het? Er zijn echt verschillende frameworks en lastige gevallen waarbij de Java Reflection API betrokken is , waar dit erg handig kan zijn. U kunt bijvoorbeeld controleren welk type een methode retourneert:
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);
}
}
}
Dit kan handig zijn in testframeworks waar u de eigenlijke code in methoden moet vervangen. Maar om dit te doen, moet u begrijpen hoe een methode zich gedraagt (dwz welk type deze retourneert). Er is ook een tweede manier om de hoofdmethode in de bovenstaande code te implementeren:
public static void main(String[] args) {
for (Method method : HelloWorld.class.getDeclaredMethods()) {
System.out.println(method.getReturnType() == Void.TYPE);
}
}
GO TO FULL VERSION