Recursividade

Alguém com muita paciência pode me explicar como funciona recursividade?
Já vi em vários livros e tutorias e estou com um grande dificuldade para assimilar o assunto bem tenho um exemplo a qual eu peguei do livro
que mostra a serie de Fibonacci entendi certas partes do código e gostaria que vcs me explicasse melhor o que está ocorrendo…
vo deixar o código logo abaixo para ficar mais fácil o entedimento

public class FibonacciCalculator
{
   // declaração recursiva do método fibonacci 
   public long fibonacci( long number )                           
   {                                                              
      if ( ( number == 0 ) || ( number == 1 ) ) // casos básicos
         return number;                                           
      else // passo da recursão                                      
         return fibonacci( number - 1 ) + fibonacci( number - 2 );
   } // fim do método fibonacci

   public void displayFibonacci()
   {
      for ( int counter = 0; counter <= 3; counter++ )
         System.out.printf( "Fibonacci of %d is: %d\n", counter,
            fibonacci( counter ));
   } // fim do método displayFibonacci
} // fim da classe FibonacciCalculator
r 

classe main

public class FibonacciTest
{     
   public static void main( String args[] )
   {
      FibonacciCalculator fibonacciCalculator = new FibonacciCalculator();
      fibonacciCalculator.displayFibonacci();
   } // fim de main
} // fim da classe FibonacciTest

Bem pelo o que eu entendi recursividade e um método que chama ele mesmo dentro do seu corpo mas diminuindo valores certo…?
isso que eu venho observado em todos os exemplos que eu vejo,
exemplo neste método fibonacci a qual coloquei como modelo,
o que eu não entendo e a chamada de recursividade vo colocar como eu acho que o método fibonacci trabalha
fibonacci de (3)
[quote]
fibonacci(3)
retorna fibonacci(2) fibonacci (1)
fibonacci(2) retorna 1 fibonacci (1) retorna 0

              como sempre fibonacci de 0 e 1 retorna seus respectivos                     
                valores vão retornar 0 e 1;

[/quote]

A formula para calcular Fibonaci e a seguinte
fibonacci(0)=0
fibonacci(1)=1
fibonacci(n)= fibonacci(n-1)+fibonacci(n-2)

como vcs podem ver dentro do próprio método sempre o que o Fibonacci for de 0 e um retorna ele mesmo, mas se for de 3 ele divide a número certo…? mas como ocorre essa chamada…?? se for Fibonacci de 10 como é feito…? nesta parte do código que estou com grandes dúvidas

else // passo da recursão                                      
         return fibonacci( number - 1 ) + fibonacci( number - 2 );

como o método vai ficar repetindo por qual razão…? será que é enquanto não chegar ao fibonacci de 0 e 1 ele vai repetindo é isso…? como séria feito em um Fibonacci de 10…?

Ele vai chamar a si mesmo, mas os parâmetros que ele vai passar na chamada depende do problema.

Todo método recursivo precisa ter uma condição de parada. Ele chama a si mesmo até atingir essa condição.
No caso de Fibonacci, a condição de parada é quando o parâmetro for 1 ou 0.

Exemplo:

[code]
f(4) = f(3) + f(2)
f(3) = (f2) + f(1)
f(2) = (f1) + f(0)
f(1) = 1
f(0) = 0

             f(4)
    f(3)            f(2)

f(2) f(1) f(1) f(0)
f(1)f(0) 1 1 0
1 0[/code]
Se observar bem, vai ver que é um meio bem ineficiente de fazer o cálculo.
Dá pra notar que o f(2) foi calculado 2 vezes, o f(1) 3 vezes e o f(0) 2 vezes.

valew cara muito obrigado