Java Scope and Recursion use

Java Scope

In Java, variables are only accessible inside the region they are created. This is called scope.In Method Scope Variables declared directly inside a method.

Example

public class Tree{
public static void main(String[] args) {

// Code here CANNOT use numTree

int numTree = 100;

// Code here can use numTree
System.out.println(numTree );
}
}

output

100

Besides, Block Scope means a block of code refers to all of the code between curly braces {}. Variables declared inside blocks of code are only accessible by the code between the curly braces.

Example

public class Tree{
public static void main(String[] args) {

// Code here CANNOT use numTree

{ // This is a block

// Code here CANNOT use numTree

int numTree = 100;

// Code here CAN use numTree
System.out.println(numTree );

} // The block ends here

// Code here CANNOT use numTree

}
}
output

100

Java Recursion

In, java programming the technique of making a function call itself is Recursion. This technique provides a way to break complicated problems down into simple problems which are easier to solve.
Recursion may be a bit difficult to understand. The best way to figure out how it works is to experiment with it.

Recursion Example

Adding two numbers together is easy to do, but adding a range of numbers is more complicated. In the following example, recursion is used to add a range of numbers together by breaking it down into the simple task of adding two numbers:

Example

//Use recursion to add all of the numbers up to 10.

public class Tree {
public static void main(String[] args) {
int result = sum(5);
System.out.println(result);
}
public static int sum(int k) {
if (k > 0) {
return k + sum(k - 1);
} else {
return 0;
}
}
}

output

15

Example Explained

When the sum() function is called, it adds parameter k to the sum of all numbers smaller than k and returns the result. When k becomes 0, the function just returns 0. When running, the program follows these steps:

5 + sum(4)
5 + ( 4 + sum(3) )
5 + ( 4 + ( 3 + sum(2) ) )
…
5 + 4 + 3 + 2 + 1 + sum(0)
5 + 4 + 3 + 2 + 1 + 0
Since the function does not call itself when k is 0, the program stops there and returns the result.

Halting Condition

In java, like loops can run into the problem of infinite looping, recursive functions can run into the problem of infinite recursion. Infinite recursion is when the function never stops calling itself. Every recursive function should have a halting condition, which is the condition where the function stops calling itself. In the previous example, the halting condition is when the parameter k becomes 0.

It is helpful to see a variety of different examples to better understand the concept. In this example, the function adds a range of numbers between a start and an end. The halting condition for this recursive function is when end is not greater than start:

Example
Use recursion to add all of the numbers between 5 to 10.

public class Tree {
public static void main(String[] args) {
int result = sumTree(5, 10);
System.out.println(result);
}
public static int sumTree(int start, int end) {
if (end > start)
{
return end + sumTree(start, end - 1);
}
else
{
return end;
}
}
}

output

45

 Factorial of a Number Using Recursion

#Factorial of a Number Using Recursion in java
public class Factorial {

    public static void main(String[] args) {
        int num = 6;
        long factorial = multiplyNumbers(num);
        System.out.println("Factorial of " + num + " = " + factorial);
    }
    public static long multiplyNumbers(int num)
    {
        if (num >= 1)
            return num * multiplyNumbers(num - 1);
        else
            return 1;
    }
}

Output

Factorial of 6 = 720

Initially, the multiplyNumbers() is called from the main() function with 6 passed as an argument.

Since 6 is greater than or equal to 1, 6 is multiplied to the result of multiplyNumbers() where 5 (num -1) is passed. Since, it is called from the same function, it is a recursive call.

In each recursive call, the value of argument num is decreased by 1 until num reaches less than 1.

When the value of num is less than 1, there is no recursive call.

And each recursive calls returns giving us:

6 * 5 * 4 * 3 * 2 * 1 * 1 (for 0) = 720.