O processo no qual uma função chama-se direta ou indiretamente é chamado recursão e a função correspondente é chamado uma função recursiva. No programa recursivo, a solução para o caso base é fornecida e a solução do problema maior é expressa em termos de problemas menores. Aqui, invocação de construtor recursiva e erro de estouro de pilha em java. É conforme mostrado abaixo no exemplo a seguir:

Exemplo 

// Java Program to Illustrate Recursion
  
// Main class
public class GFG {
  
    static int count = 0;
  
    // Method 1
    // Recursive method
    static void function()
    {
        count = count + 1;
        if (count <= 5) {
  
            System.out.println("Call " + count);
            function();
        }
    }
  
    // Method 2
    // Main driver method
    public static void main(String[] args) { function(); }
}

Ligue 1
Ligue 2
Ligue 3
Ligue 4
Ligue 5

Invocação de construtor recursivo

Se um construtor chama a si mesmo, a mensagem de erro “invocação recursiva do construtor” ocorre. O programa a seguir não é permitido pelo compilador porque dentro do construtor tentamos chamar o mesmo construtor. O compilador o detecta instantaneamente e gera um erro.

Exemplo:

// Java program to Illustrate How Recursive
// Constructor Invocation Error is Occured
  
// Main class
class GFG {
  
    // Constructor of this class
    // Inside we are trying to call the same constructor
    GFG()
    {
        // This keyword refers to same instance itself
        this();
    }
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating an object of class inside main()
        GFG obj = new GFG();
    }
}

Saída:

Agora, vamos discutir o que exatamente nos referimos por erro de estouro de pilha e por que ele ocorre . O erro de estouro de pilha ocorre se não fornecermos a condição de terminação adequada para nossa função recursiva ou modelo, o que significa que ele se transformará em um loop infinito.

Implementação:

Aqui criamos um objeto GFG dentro do construtor que é inicializado chamando o construtor, que então cria outro objeto GFG que é novamente inicializado chamando o construtor e continua até que a pilha estourou. Isso pode ser justificado pela ilustração a seguir:

Exemplo:

// Java program to Illustrate Stack Overflow Error
  
// Main class
public class GFG {
  
    // Constructor of this class
    GFG()
    {
  
        // Creating an object of GFG class inside the
        // constructor which is initialized by calling the
        // constructor, which is initialized by
        // calling the constructor and it goes on
        GFG obj1 = new GFG();
    }
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating an object of this class
        GFG obj = new GFG();
    }
}

Saída: