What is the process of defining a method in terms of itself that is a method that calls itself 1 point polymorphism abstraction encapsulation recursion?

In this tutorial, you will learn about Java recursive function, its advantages and disadvantages.

Inhaltsverzeichnis Show

How Recursion works?
Example: Factorial of a Number Using Recursion
Working of Factorial Program
Advantages and Disadvantages of Recursion
What is the process of defining a method in terms of itself that is a method that calls itself called?
What is the process of defining a method in terms?
What is the process of defining a method in a subclass having same name and type signature?
What is the process of defining two or more methods within same class that have same name but different parameters declaration?

In Java, a method that calls itself is known as a recursive method. And, this process is known as recursion.

A physical world example would be to place two parallel mirrors facing each other. Any object in between them would be reflected recursively.

How Recursion works?

Working of Java Recursion

In the above example, we have called the recurse() method from inside the main method. (normal method call). And, inside the recurse() method, we are again calling the same recurse method. This is a recursive call.

In order to stop the recursive call, we need to provide some conditions inside the method. Otherwise, the method will be called infinitely.

Hence, we use the if...else statement (or similar approach) to terminate the recursive call inside the method.

Example: Factorial of a Number Using Recursion

class Factorial {

    static int factorial( int n ) {
        if (n != 0)  // termination condition
            return n * factorial(n-1); // recursive call
        else
            return 1;
    }

    public static void main(String[] args) {
        int number = 4, result;
        result = factorial(number);
        System.out.println(number + " factorial = " + result);
    }
}

Output:

4 factorial = 24

In the above example, we have a method named factorial(). The factorial() is called from the main() method. with the number variable passed as an argument.

Here, notice the statement,

return n * factorial(n-1);

The factorial() method is calling itself. Initially, the value of n is 4 inside factorial(). During the next recursive call, 3 is passed to the factorial() method. This process continues until n is equal to 0.

When n is equal to 0, the if statement returns false hence 1 is returned. Finally, the accumulated result is passed to the main() method.

Working of Factorial Program

The image below will give you a better idea of how the factorial program is executed using recursion.

Factorial Program using Recursion

Advantages and Disadvantages of Recursion

When a recursive call is made, new storage locations for variables are allocated on the stack. As, each recursive call returns, the old variables and parameters are removed from the stack. Hence, recursion generally uses more memory and is generally slow.

On the other hand, a recursive solution is much simpler and takes less time to write, debug and maintain.

Recommended Reading: What are the advantages and disadvantages of recursion?

Java MCQs on overloading methods & argument passing in Java Programming Language.

1. What is the process of defining two or more methods within same class that have same name but different parameters declaration?
a) method overloading
b) method overriding
c) method hiding
d) none of the mentioned

Answer: a
Clarification: Two or more methods can have same name as long as their parameters declaration is different, the methods are said to be overloaded and process is called method overloading. Method overloading is a way by which Java implements polymorphism.

2. Which of these can be overloaded?
a) Methods
b) Constructors
c) All of the mentioned
d) None of the mentioned

Answer: c
Clarification: None.

3. Which of these is correct about passing an argument by call-by-value process?
a) Copy of argument is made into the formal parameter of the subroutine
b) Reference to original argument is passed to formal parameter of the subroutine
c) Copy of argument is made into the formal parameter of the subroutine and changes made on parameters of subroutine have effect on original argument
d) Reference to original argument is passed to formal parameter of the subroutine and changes made on parameters of subroutine have effect on original argument

Answer: a
Clarification: When we pass an argument by call-by-value a copy of argument is made into the formal parameter of the subroutine and changes made on parameters of subroutine have no effect on original argument, they remain the same.

4. What is the process of defining a method in terms of itself, that is a method that calls itself?
a) Polymorphism
b) Abstraction
c) Encapsulation
d) Recursion

Answer: d
Clarification: None.

5. What will be the output of the following Java code?

```
class San
```
```
{
```
```
 public void m1 (int i,float f)
```
```
 {
```

  System.out.println(" int float method");

```
 }
```
```
 
```
```
 public void m1(float f,int i);
```
```
  {
```

  System.out.println("float int method");

```
  }
```
```
 
```
```
  public static void main(String[]args)
```
```
  {
```
```
    San s=new San();
```
```
        s.m1(20,20);
```
```
  }
```
```
}
```

a) int float method
b) float int method
c) compile time error
d) run time error

Answer: c
Clarification: While resolving overloaded method, compiler automatically promotes if exact match is not found. But in this case, which one to promote is an ambiguity.

6. What will be the output of the following Java code?

```
    class overload 
```
```
    {
```
```
        int x;
```
```
 	int y;
```
```
        void add(int a) 
```
```
        {
```
```
            x =  a + 1;
```
```
        }
```
```
        void add(int a, int b)
```
```
        {
```
```
            x =  a + 2;
```
```
        }        
```
```
    }    
```
```
    class Overload_methods 
```
```
    {
```

        public static void main(String args[])

```
        {
```

            overload obj = new overload();

```
            int a = 0;
```
```
            obj.add(6);
```

            System.out.println(obj.x);

```
        }
```
```
   }
```

a) 5
b) 6
c) 7
d) 8

Answer: c
Clarification: None.
output:

$ javac Overload_methods.java
$ java Overload_methods
7

7. What will be the output of the following Java code?

```
    class overload 
```
```
    {
```
```
        int x;
```
```
 	int y;
```
```
        void add(int a)
```
```
        {
```
```
            x =  a + 1;
```
```
        }
```
```
        void add(int a , int b)
```
```
        {
```
```
            x =  a + 2;
```
```
        }        
```
```
    }    
```
```
    class Overload_methods 
```
```
    {
```

        public static void main(String args[])

```
        {
```

            overload obj = new overload();

```
            int a = 0;
```
```
            obj.add(6, 7);
```

            System.out.println(obj.x);

```
        }
```
```
    }
```

a) 6
b) 7
c) 8
d) 9

Answer: c
Clarification: None.
output:

$ javac Overload_methods.java
$ java Overload_methods
8

8. What will be the output of the following Java code?

```
   class overload 
```
```
   {
```
```
        int x;
```
```
 	double y;
```
```
        void add(int a , int b) 
```
```
        {
```
```
            x = a + b;
```
```
        }
```
```
        void add(double c , double d)
```
```
        {
```
```
            y = c + d;
```
```
        }
```
```
        overload() 
```
```
        {
```
```
            this.x = 0;
```
```
            this.y = 0;
```
```
        }        
```
```
    }    
```
```
    class Overload_methods 
```
```
    {
```

        public static void main(String args[])

```
        {
```

            overload obj = new overload();

```
            int a = 2;
```
```
            double b = 3.2;
```
```
            obj.add(a, a);
```
```
            obj.add(b, b);
```

            System.out.println(obj.x + " " + obj.y);

```
        }
```
```
   }
```

a) 6 6
b) 6.4 6.4
c) 6.4 6
d) 4 6.4

Answer: d
Clarification: For obj.add(a,a); ,the function in line number 4 gets executed and value of x is 4. For the next function call, the function in line number 7 gets executed and value of y is 6.4
output:

$ javac Overload_methods.java
$ java Overload_methods 
4 6.4

9. What will be the output of the following Java code?

```
    class test 
```
```
    {
```
```
        int a;
```
```
        int b;
```
```
        void meth(int i , int j) 
```
```
        {
```
```
            i *= 2;
```
```
            j /= 2;
```
```
        }          
```
```
    }    
```
```
    class Output 
```
```
    {
```

        public static void main(String args[])

```
        {
```
```
            test obj = new test();
```
```
	    int a = 10;
```
```
            int b = 20;             
```
```
            obj.meth(a , b);
```

            System.out.println(a + " " + b);

```
        } 
```
```
    }
```

a) 10 20
b) 20 10
c) 20 40
d) 40 20

Answer: a
Clarification: Variables a & b are passed by value, copy of their values are made on formal parameters of function meth() that is i & j. Therefore changes done on i & j are not reflected back on original arguments. a & b remain 10 & 20 respectively.
output:

$ javac Output.java
$ java Output
10 20

10. What will be the output of the following Java code?

a) 10 20
b) 20 10
c) 20 40
d) 40 20

Answer: b
Clarification: Class objects are always passed by reference, therefore changes done are reflected back on original arguments. obj.meth(obj) sends object obj as parameter whose variables a & b are multiplied and divided by 2 respectively by meth() function of class test. a & b becomes 20 & 10 respectively.
output:

What is the process of defining a method in terms of itself that is a method that calls itself called?

Recursion is the process of defining something in terms of itself. Recursion is sometimes called circular definition. A function that calls itself is said to be recursive. Example.