CODEWITHSUNDEEP
javareturn
user1613360
user1613360

Reputation: 1314

Return statement best practices in java?

I want to know the difference between these two codes even though they produce the same output:

CODE 1:

class ret {
    public static int add(int x) {
        if(x!=0)
            return x+add(x-1);
        return x;
    }

    public static void main(String args[]) {
        System.out.println(add(5));
    }
}

CODE 2:

class ret {
    public static int add(int x) {
        if(x!=0)
            return x+add(x-1);
        return 0;
    }

    public static void main(String args[]) {
        System.out.println(add(5));
    }
}

They both output 15 but how come the second code also output's 15 instead of zero?My understanding is that the last call would be add(0) for code 2 and it would return zero.I also want to know is it okay to use multiple return statements or use a single return statement and replace the rest with local variables.I remember reading that single entry single exit model is a good practice.

Upvotes: 0

Views: 4751

Answers (2)

Andy Brown
Andy Brown

Reputation: 19171

This is a recursive method, so when x != 0, you will return the result of "x added to calling the method again with (x-1)". The final call will always return x == 0 or constant = 0, so you will return 15 from both versions.

Single return vs. multiple return is a matter of debate. The former should be preferred as a rule. Generally it will be obvious where multiple return statements are acceptable as it will be simpler to understand the method with them than with the alternative code constructs required to engineer a single exit point. Also note you could rewrite add as:

public static int add(int x) {
    return x == 0 ? 0 : (x + add(x-1));
}

Version 1:

add(5)
  call add(4)
    call add(3)
      call add(2)
        call add(1)
          call add(0)
          return (x = 0)
        return (x = 1) + (add(x-1) = 0) = 1
      return (x = 2) + (add(x-1) = 1) = 3
    return (x = 3) + (add(x-1) = 3) = 6
  return (x = 4) + (add(x-1) = 6) = 10
return (x = 5) + (add(x-1) = 10) = 15

Version 2:

add(5)
  call add(4)
    call add(3)
      call add(2)
        call add(1)
          call add(0)
          return (constant = 0) // the only difference
        return (x = 1) + (add(x-1) = 0) = 1
      return (x = 2) + (add(x-1) = 1) = 3
    return (x = 3) + (add(x-1) = 3) = 6
  return (x = 4) + (add(x-1) = 6) = 10
return (x = 5) + (add(x-1) = 10) = 15

Upvotes: 4

Laf
Laf

Reputation: 8235

The use of multiple return statement versus using a single exit point cannot be answered with an easy one-line answer. I guess the best answer you can get is "it depends on your company's standards".

Single exit point is a very good standard, even though I don't personally endorse it. You end up having methods that always have a single return statement at the end, so you never get in a position where you are looking for those many possible return statement while editing someone else's code. I believe that developers that used to code in C tend to follow this standard (see this question).

I, for one, perfer using multiple return statements when it can help simplify the code. One case where I like to use it is to prevent cascading braces in my code. For instance, in the following example:

private int doSomething (int param) {
    int returnCode;

    if (param >= 0) {
        int someValue = param * CONSTANT_VALUE;

        if (isWithinExpectedRange (someValue)) {
            if (updateSomething (someValue)) {
                returnCode = 0;
            } else {
                returnCode = -3;
            }
        } else {
            returnCode = -2;
        }
    } else {
        returnCode = -1;
    }

    return returnCode;
}

I find this type of coding to be very confusing when reading it. I tend to change this type of code to:

private int doSomething (int param) {
    if (param < 0) {
        return -1;
    }

    int someValue = param * CONSTANT_VALUE;

    if (!isWithinExpectedRange (someValue)) {
        return -2;
    }

    if (!updateSomething (someValue)) {
        return -3;
    }

    return 0;
}

The second example looks cleaner, and clearer, to me. Even more when the actual code has some extra coding in the else blocks.

Again, this is personal tastes. Some company might enforce a single exit point, some might not, and some developers prefer single exit point. The bottom line is, if there's a guideline available for you to follow in your environment, then do so. If not, then you can chose your own preference base partly on these arguments.

Upvotes: 0

Related Questions