Java return Examples

Use the return keyword in methods. Return multiple values, return expressions and fix errors.

Return. A stone is thrown into the air. It comes back down to the ocean and makes a splash. It returns. In Java too methods return.

In a return statement, we evaluate expressions—and as part of this evaluation, other methods may run. Types must match, or an error occurs. Code after a return may become unreachable.

Expression. We can return a single value. But often we want a more complex return statement—we use an expression after the return keyword. Here an expression that multiplies two values.

ComputeSize: This method receives two arguments, both of type int. In the return expression, the two numbers are multiplied.

And: The evaluated result is returned to the calling location. The expression itself is not returned, just its result.

Java program that returns expression public class Program { static int computeSize(int height, int width) { // Return an expression based on two arguments (variables). return height * width; } public static void main(String[] args) { // Assign to the result of computeSize. int result = computeSize(10, 3); System.out.println(result); } } Output 30

Return method result. In a return statement, we can invoke another method. In this example, we return the result of cube() when getVolume() returns.

And: The cube method itself returns the result of Math.pow, a built-in mathematics method.

Java program that calls method in return statement public class Program { static int cube(int value) { // Return number to the power of 3. return (int) Math.pow(value, 3); } static int getVolume(int size) { // Return cubed number. return cube(size); } public static void main(String[] args) { // Assign to the return value of getVolume. int volume = getVolume(2); System.out.println(volume); } } Output 8

Return, void method. In a void method, an implicit (hidden) return is always at the end of the method. But we can specify a return statement (with no argument) to have an early exit.

Here: If the "password" argument has a length greater than or equal to 5, we return early. Otherwise we print a warning message.

Java program that uses return statement, void method public class Program { static void displayPassword(String password) { // Write the password to the console. System.out.println("Password: " + password); // Return if our password is long enough. if (password.length() >= 5) { return; } System.out.println("Password too short!"); // An implicit return is here. } public static void main(String[] args) { displayPassword("furball"); displayPassword("cat"); } } Output Password: furball Password: cat Password too short!

Boolean. We can use an expression to compose a boolean return value. This is a powerful technique—we combine several branches of logic into a single statement.Boolean

And: The result of isValid is a boolean. Both logical conditions must be satisfied for isValid to return true.

Java program that returns boolean from method public class Program { static boolean isValid(String name, boolean exists) { // Return a boolean based on the two arguments. return name.length() >= 3 && exists; } public static void main(String[] args) { // Test the results of the isValid method. System.out.println(isValid("green", true)); System.out.println(isValid("", true)); System.out.println(isValid("orchard", false)); } } Output true false false

Compilation error. A method that is supposed to return a value (like an int) must return that value. Otherwise a helpful compilation error occurs.
Java program that causes compilation error public class Program { static int getResult(String id) { // This method does not compile. // ... It must return an int. if (id.length() <= 4) { System.out.println("Short"); } } public static void main(String[] args) { int result = getResult("cat"); System.out.println(result); } } Output Exception in thread "main" java.lang.Error: Unresolved compilation problem: This method must return a result of type int at Program.getResult( at Program.main(

Multiple return values. This is a common programming problem. To return two values, we can use a class argument—then we set values within that class.Class

Result: This has the same effect as returning two arguments. The syntax is more verbose. The object can be reused between method calls.

Tip: It is often a better design decision to have related methods on a class. Then those methods simply modify fields of the class.

Java program that returns multiple values class Data { public String name; public int size; } public class Program { static void getTwoValues(Data data) { // This method returns two values. // ... It sets values in a class. = "Java"; data.size = 100; } public static void main(String[] args) { // Create our data object and call getTwoValues. Data data = new Data(); getTwoValues(data); System.out.println(; System.out.println(data.size); } } Output Java 100

Unreachable code. This is a fatal error in Java. If code cannot be reached, we get a java.lang.Error. To fix this program, we must remove the "return" or the final, unreachable statement.
Java program that has unreachable code public class Program { public static void main(String[] args) { System.out.println("Hello"); return; System.out.println("World"); } } Output Exception in thread "main" java.lang.Error: Unresolved compilation problem: Unreachable code at Program.main(

Type mismatch error. We cannot assign a variable to void method. This returns in a "type mismatch" error. Void means "no value." To fix, remove the variable assignment.
Java program that causes type mismatch error public class Program { static void test() { System.out.println(123); } public static void main(String[] args) { // This does not compile. // ... We cannot assign to a void method. int result = test(); } } Output Exception in thread "main" java.lang.Error: Unresolved compilation problem: Type mismatch: cannot convert from void to int at Program.main(

Performance. In my tests, I found that the JVM does a good job of inlining methods. So if we return a statement that evaluates into another method call, this causes no apparent slowdown.

Also: I found that expressions with temporary local variables were optimized well, to match single-expression return values.

A review. The return keyword signals an end to a method. It accepts an argument of a type that matches the method's signature. In a void method, we use a no-argument return.

To help improve quality, the Java compiler alerts us when a return renders code unreachable. It also requires that types match correctly. This helps ensure programs work as intended.
Dot Net Perls
© 2007-2020 Sam Allen. Every person is special and unique. Send bug reports to