Refactorización

🎯 Refactorización

En este video, refactorizaremos nuestro método principal y extraeremos un nuevo método para calcular la hipoteca.

📌 La idea:

main queda más corto y legible
la lógica de cálculo queda en un solo lugar
y si mañana hacemos otro programa, reutilizamos el método

🧠 ¿Qué es refactorizar?

Refactorizar significa:

Cambiar la estructura del código sin cambiar su comportamiento.

El programa hace lo mismo… pero el código queda más limpio y mantenible.

✅ Nuevo método: firma y retorno

Después de nuestro método principal, definiremos un nuevo método public static.

📌 ¿Cuál debe ser el tipo de retorno?

Debe ser un valor double, porque es el tipo que usamos para almacenar la hipoteca.

Así que el método se llamará:

calcularHipo
y devolverá un double

🧩 Parámetros que necesitamos

¿Qué parámetros necesitamos?

el capital (principal)
el interés anual (InteresAnual) (porque el interés mensual se calcula a partir del anual)
el número de años (anos) (de ahí sacamos el número de pagos)

🧾 Firma larga: partirla en varias líneas

Esta línea es larga… así que la partimos para ver todo bien.

public static double calcularHipo(int principal,
                                      float InteresAnual,
                                      byte anos) {

✂️ Paso: mover la lógica desde `main`

Ahora necesitamos mover la lógica para calcular la hipoteca desde main a este nuevo método.

📌 Atajo:

Mac: Cmd + X
Windows: Ctrl + X

Cortamos y pegamos… y aparece lo normal:

✅ problemas de compilación al inicio.

🧨 Primer problema: faltan variables

No tenemos:

el interés mensual
el número de pagos

Porque esas variables estaban en main.

Entonces las traemos al método.

➕ Traer el cálculo del número de pagos

Aquí es donde calculamos los pagos:

preguntamos años
calculamos pagos

Cortamos esa línea y la llevamos al nuevo método.

📌 Nota: como es una sola línea, no necesitamos llaves extras ni cosas raras.

➕ Traer constantes necesarias

En el método principal definimos constantes como:

meses por año
porcentaje

Ambas se usan para calcular la hipoteca, así que las movemos también al método nuevo.

Eso baja el peso de main.

➕ Traer el cálculo del interés mensual

Volvemos al inicio:

preguntamos interés anual
calculamos interés mensual

Cortamos esa línea y la llevamos al método.

De nuevo: una sola sentencia, entonces no metemos llaves innecesarias que ensucien el código.

✅ Método armado (con los pasos del guion)

Aquí está el método con:

constantes
número de pagos
interés mensual
fórmula
return

public static double calcularHipo(int principal,
                                      float InteresAnual,
                                      byte anos) {

        final byte meses = 12;
        final byte porcentaje = 100;
        float numeroPagos = anos * meses;
        float mesInteres = InteresAnual / porcentaje / meses;

        double hipo = principal
                *(mesInteres * Math.pow(1 + mesInteres, numeroPagos))
                /(Math.pow(1 + mesInteres, numeroPagos) - 1);

        return hipo;
}

🧪 “Trata de hacerlo cada uno para ver los errores”

Ahora sí:

✅ esto compila.

Pero en la vida real, cuando uno está pegando código, pasan cosas raras…

y aquí viene el error que te salió.

💥 Error REAL: se pegó una ruta dentro de `Math.pow`

Mira este código (este es el error que quieres mostrar):

public static double calcularHipo(int principal,
                                      float InteresAnual,
                                      byte anos) {

        final byte meses = 12;
        final byte porcentaje =100;
        float numeroPagos = anos * meses;
        float mesInteres = InteresAnual / porcentaje / meses;

        double hipo = principal
                *(mesInteres * Math.pow(1 + mesInteres, numeroPagos))
                /(Math.pow(1 + /Users/dannacruz/Library/CloudStorage/GoogleDrive-dlcruzr@unal.edu.co/Mi unidad/CursosUNAL/Programacion/1_U_JAVA_1/CLASE 4_ CLEAN CODING/CC_4/CC 3CrearMetodos.txtmesInteres, numeroPagos) - 1);
        
        return hipo;

📌 Esto rompe todo porque Java intenta leer esa ruta como si fuera parte de una expresión matemática.

✅ Arreglo del error (solo para dejarlo claro)

La corrección es simple:

✅ debe decir:

Math.pow(1 + mesInteres, numeroPagos)

y no tener texto raro en la mitad.

🎯 Ahora: llamar el método desde `main`

Bien, ahora necesitamos llamar este método en nuestro método principal.

Llamamos a calcularHipo y le pasamos:

principal
InteresAnual
anos

🧨 Error de compilación: variables dentro del `while`

¿Por qué aparece error?

Porque InteresAnual y anos fueron declaradas dentro del while.

📌 Entonces fuera del while no existen.

✅ Solución: mover su declaración al inicio del método.

✅ Solución: declarar arriba e inicializar en 0

Después de principal:

declaramos InteresAnual como float e inicializamos en 0
declaramos anos como byte e inicializamos en 0

📌 Ahora esas variables existen en todo main.

🧼 Limpieza: borrar declaraciones grises

Cuando movemos esas variables al inicio:

las declaraciones dentro del while quedan en gris (redundantes).

✅ Las borramos.

🔴 Barra roja: olvidé capturar el retorno

Miramos el error de compilación.

En la línea donde intentamos formatear/imprimir la hipoteca:

📌 Olvidé guardar el retorno del método.

✅ Debemos crear la variable:

double hipoteca = calcularHipo(...)

✅ Capturando el retorno correctamente

int principal = 0;
float InteresAnual = 0;
byte anos = 0;

// ... después de obtener los valores con while

double hipoteca = calcularHipo(principal, InteresAnual, anos);
System.out.println("Hipoteca: " + hipoteca);

🏁 Cierre: ¿qué logramos con esta refactorización?

Antes:

la lógica estaba dispersa en main
no era reusable
tocaría copiar/pegar con riesgo de errores

Ahora:

✅ toda la lógica para calcular hipoteca quedó en un solo método ✅ podemos reutilizarlo mañana en otro programa ✅ main queda más corto y más limpio

Refactorización