Can someone explain me how is this returning the correct boolean value for every integer?

I am trying to understand how it is returning the correct value after i set a number, but didnt grasp what it does .

public static boolean isEven(int n){
        if (n==1){
            return false;
        }else {
            return !isEven(n-1);
        }

    }

This is a recursive function. Recursion requires two things. A base case and progression toward the base case. In this instance the base case is n==1 and progression is made toward the base case by decrementing the input each time the function is called. Nothing is returned until the base case is reached. Whatever Integer is input as a parameter it will be reduced to 1 before returning anything. Once 1 is reached false will be returned. Then every recursive call will return in reverse order from when they were called. Since they will return !isEven(n) each call will alternate true and false, just like every integer alternates being true or false. So the final return value will always come out correct.

Example: n = 4

isEven(4)
   isEven(3) 
      isEven(2)
          isEven(1) -> returns false
      isEven(2) -> return true
   isEven(3) -> returns false
isEven(4) -> returns true

For more on the basics of recursion https://www.tutorialspoint.com/data_structures_algorithms/recursion_basics.htm

You can understand it from the following two examples:

1. Call isEven(3)

   isEven(3) => !isEven(2) => !isEven(1)
   							returns !false i.e. true
   			 returns !true i.e. false
   

2. Call isEven(4)

   isEven(4) => !isEven(3) => !isEven(2) => !isEven(1)
   										returns !false i.e. true
   						  returns !true i.e. false
   			 returns !false i.e. true
   

It works like a loop, which is changing the boolean as often as the number. So when the number is 5, it starts with false, because it isn't 1 and then it just changes 4 times:
false -> true -> false -> true -> false

For n = 5:

if (n == 1) {
    return false;
} else {
    return !isEven(n-1);
}

works the same as

return !(!(!(!(false))));

To undestand recursive procedures, check what the recursion says. In this case, assume the statement "isEven() gives the right result" is true, and take a look at what is going on.

• If n - 1 is even, isEven(n - 1) is true; and n is odd, so the result returned is right.
• If n - 1 is odd, isEven(n - 1) is false; n is even, so the result is right in this case too.
• If n == 1, n is odd, so the result is right (and is computed without recursion, base case).
• Each recursive call to isEven() is a call with a smaller n, so your recursive calls get you (one step) nearer to the base case. Thus you are sure to reach 1 eventually, the recursion doesn't go on forever.

This is essentially a proof by induction, thinly disguised.

Take a step back: Whenever you try to understand a functions that calls other functions, as a first cut you assume the other functions do their job right and (eventually) give the right answer, and work from there. After you have convinced yourself that the scrutinized function is right, you go for the functions called. At some point you reach trivial functions or take the operations provided by the language as correct by faith.

Same here: Assume the called function for the arguments given does it's job (doesn't matter it is the same function we are analyzing), and the results of the (in this case recursive) calls are combined correctly. Check there are base cases (no recursive calls), and that the calls get you "closer" to the base cases.