En java que tan Importante es la recursividad
Bueno yo de nuevo, en la u cuando programo, el profe nos dice que hay momentos en que es necesaria utilizar recursividad de métodos
Bueno ahora es el caso, pero me gusta hacer programas que ahorre memoria ram y procesador para que sean mas efectivos... ustedes como programadores que prefieren, y comparen estos dos pedazos de código cual elijen y por que:
public void invisibleCamposInNecesarios(int numero) {
switch (this.contarCaracteres() + numero) {
case 3:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
;
break;
case 4:
/*llama este metodo asi mismo y se envia como parametro
-1 para que al mometo de generar el numero aletori valla a al caso
anterior y en caso necesario se haga esto mismo:
Ej numeroAleatorio = 4 - 1 llega al caso3 y y vuelve las
letras visibles y luego se regresa
y vuelta esta letra visible*/
this.invisibleCamposInNecesarios(-1);
this.letraCuatro.setVisible(true);
break;
case 5:
this.invisibleCamposInNecesarios(-1);
this.letraCinco.setVisible(true);
break;
case 6:
this.invisibleCamposInNecesarios(-1);
this.letraSeis.setVisible(true);
break;
case 7:
this.invisibleCamposInNecesarios(-1);
this.letraSiete.setVisible(true);
break;
case 8:
this.invisibleCamposInNecesarios(-1);
this.letraOcho.setVisible(true);
break;
case 9:
this.invisibleCamposInNecesarios(-1);
this.letraNueve.setVisible(true);
break;
case 10:
this.invisibleCamposInNecesarios(-1);
this.letraDiez.setVisible(true);
break;
}
}
y
public void invisibleCamposInNecesarios(int numero) {
switch (this.contarCaracteres() + numero) {
case 3:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
break;
case 4:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
this.letraCuatro.setVisible(true);
break;
case 5:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
this.letraCuatro.setVisible(true);
this.letraCinco.setVisible(true);
break;
case 6:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
this.letraCuatro.setVisible(true);
this.letraCinco.setVisible(true);
this.letraSeis.setVisible(true);
break;
case 7:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
this.letraCuatro.setVisible(true);
this.letraCinco.setVisible(true);
this.letraSeis.setVisible(true);
this.letraSiete.setVisible(true);
break;
case 8:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
this.letraCuatro.setVisible(true);
this.letraCinco.setVisible(true);
this.letraSeis.setVisible(true);
this.letraSiete.setVisible(true);
this.letraOcho.setVisible(true);
break;
case 9:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
this.letraCuatro.setVisible(true);
this.letraCinco.setVisible(true);
this.letraSeis.setVisible(true);
this.letraSiete.setVisible(true);
this.letraOcho.setVisible(true);
this.letraNueve.setVisible(true);
break;
case 10:
this.letraUno.setVisible(true);
this.letraDos.setVisible(true);
this.letraTres.setVisible(true);
this.letraCuatro.setVisible(true);
this.letraCinco.setVisible(true);
this.letraSeis.setVisible(true);
this.letraSiete.setVisible(true);
this.letraOcho.setVisible(true);
this.letraNueve.setVisible(true);
this.letraDiez.setVisible(true);
break;
}
}
en el ultimo se gasta 80 lineas de código pero ahorra ram pero el primero, gata menos lineas como 40, pero creo que consume algo mas ram
El gasto no es notable, pero es bueno escribir un código amigable con la ram
- Inicie sesión o regístrese para enviar comentarios
RAM
Con lo del consumo de RAM supongo que te refieres al stack. En este caso concreto no son tantas llamadas como si tuvieras un método con una colección de N elementos y que corres el riesgo de una StackOverflowException.
Personalmente creo que los dos métodos están mal pensados. Aunque hagan lo que tienen que hacer, tienen muchísimo más código de lo que necesitan. La implementación iterativa sería mi elección, pero yo pondría todos esos "letraUno" a "letraDiez" en un arreglo y en vez de tener un switch de 10 casos, haría un ciclo de 0 al número, afectando la visibilidad de cada elemento del arreglo. Eso sería amigable con la RAM pero sobretodo amigable con el programador que tenga que mantener luego ese código, incluso si ese programador eres tú mismo.
Lo probare
Si esa solución se ve fácil y eficaz, soy estudiante de 3 semestre de sistemas, y me encanta programar, en mi caso voy muy avanzado Creo yo, entonces me gusta preguntar en foros, pues mis amigos apenas y saben lo básico, yo siempre investigo como hacer escribir un buen código,
que sea corto y amigable con la memoria, pero como entenderán apenas estoy en el tercer semestre y tengo mucho que aprender, pero la practica hace al maestro,
La verdad, que me acuerde no
La verdad, que me acuerde no he utilizado recursividad. Entenderla es un buen ejercicio para el cerebro.
Si hay casos algo
Si hay casos algo complejos,
Como la que utilizamos en en el In-orden, Pos-orden y Pre-orden con los arboles.......
Concurrencia no siempre es prioridad.
Recuerdo que hace tiempo que leí el famoso libro blanco de Sun me llamo la atención que el autor mencionaba que recomendaba evitar el uso de switch.
Me parece que en un foreach pudiste haber ahorrado como 60 líneas.
Si la prioridad es la concurrencia en tu caso deberías revisar alternativas que tal vez se adecuen a tu necesidad, como puede ser Node.js que bien puedes integrar con Java y es excelente.
En caso contrario solo cuida, como bien dice @ezamudio que el mantenimiento no se convierta en el martirio de alguien.
Esto casi no lo sufres en la universidad, pero en los trabajos es muy común que al primer equipo de desarrollo le zumben los oídos por un muy buen tiempo.