1-) Um método pode chamar ele mesmo. Chamamos isso de recursão. Você
pode resolver a série de fibonacci usando um método que chama ele mesmo. O
objetivo é você criar uma classe, que possa ser usada da seguinte maneira:
Fibonacci fibo = new Fibonacci();
int i = fibo.calculaFibonacci(5);
System.out.println(i);
Aqui ira imprimir 8, já que este é o sexto número da série.
Este método calculaFibonacci não pode ter nenhum laço, só pode chamar
ele mesmo como método. Pense nele como uma função, que usa a própria função
para calcular o resultado.
Só não entendi como o metodo chama ele mesmo, poderia explicar essa parte e como seria esse codigo ? agradeço desde já.
Segue um exemplo de método recursivo para cálculo de fatorial:
int calcularFatorial(int n) {
if (n == 0) {
return 1;
}
return n * calcularFatorial(n - 1); //Estou chamando o método calcularFatorial() novamente.
}
Vamos supor que eu passe 3 como parâmetro:
intfatorial=calcularFatorial(3);//Calcula 3!
Aqui vai uma simulação de o que ocorre com o método:
int calcularFatorial(int n) { // n = 3
if (n == 0) { // 3 não é == a zero.
return 1;
} //Então vem pra cá.
return n * calcularFatorial(n - 1); //Aqui é o mesmo que -> return 3 * calcularFatorial(3 - 1);
}
Resumindo, o método calcularFatorial vai ser chamado até que o n seja igual a zero.
No fim das contas vai ser como se tivesse feito: (3 * (2 * (1 * (1)))) -> imagine que cada parênteses é uma chamada do método calcularFatorial().
Aí teria que desenvolver uma lógica para aplicar a sequência de Fibonacci.
Se a explicação estiver muito confusa avisa aí.
Falou…
V
Valeio_Bezerra
entendi, agora nesse questão do fatorial faltou um loop
rdsilio
Bom dia,
Não faltou loop, o fato de o método ser executado recursivamente funciona como um loop neste caso.
V
Valeio_Bezerra
aaah entendi, que burrice a minha HAUHAHUA.
V
Valeio_Bezerra
Analisando direito, não entendi não.
poderiam me explicar essa parte:
returnn*calcularFatorial(n-1);//Aqui é o mesmo que -> return 3 * calcularFatorial(3 - 1);
rdsilio
Valeio Bezerra:
Analisando direito, não entendi não.
poderiam me explicar essa parte:
return n * calcularFatorial(n - 1); //Aqui é o mesmo que -> return 3 * calcularFatorial(3 - 1);
return n * calcularFatorial(n - 1); //Aqui é o mesmo que -> return 3 * calcularFatorial(3 - 1);
Indo por partes:
return indica o retorno do método, que no caso é o conteúdo de “n” multiplicado pelo retorno de calcularFatorial(n - 1);
No exemplo: 3! = 3 * 2 * 1 = 6.
Quando eu chamo calcularFatorial(3):
calcularFatorial(3);
//Quando eu passo 3 por parâmetro, estou dizendo que n = 3.
// Portanto este método chama calcularFatorial(2), que por sua vez chama calcularFatorial(1), que por sua vez chama calcularFatorial(0). Isto ocorre por causa do return n * calcularFatorial(n - 1).
//Quando 0 é passado por parâmetro, a condição do if (n == 0) será verdadeira, portanto retornará 1. Encerrando as chamadas.
//A partir daí, este retorno será multiplicado por n e o resultado é retornado para o método anterior e assim por diante.
[EDIT]Valeu rdsilio, num tinha visto, mas ficou até mais claro. hehe
