Refactorización

🛠️ Refactorización en Java

Ya aprendiste a crear nuevos métodos. Ahora vamos a hablar de refactorización.

📌 Refactorizar significa:

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

Es decir: el programa hace lo mismo… pero el código queda más limpio, más corto y más fácil de mantener.

🧮 El problema: `main` está gigante

Mira el código de nuestra calculadora de hipotecas.

El método main empieza en la línea 8 y termina en la 52:

📌 Son 44 líneas… demasiado.

✅ Idealmente:

5 a 10 líneas por método es excelente
más de 20 ya es pesado de leer

Entonces toca hacer lo que siempre hacemos con código limpio:

👉 fragmentarlo en métodos más pequeños.

🔍 ¿Qué buscamos al refactorizar?

Cuando vas a refactorizar, busca dos cosas:

1) ✅ Código que “conceptualmente va junto”

Aunque esté separado en el archivo, en la idea pertenece al mismo bloque lógico.

2) 🔁 Patrones repetidos

Partes del código que son casi iguales y solo cambian:

el texto (pregunta),
el rango,
el mensaje de error…

Eso se puede convertir en un método reusable.

1️⃣ Código que va junto: calcular la hipoteca

Mira esta parte:

📌 Para calcular la hipoteca necesitamos:

el capital
el interés mensual
el número de pagos

Pero:

el interés mensual lo calculamos a partir del anual
el número de pagos lo calculamos a partir de los años

✅ Estas líneas están separadas en main, pero conceptualmente son lo mismo: todo hace parte del cálculo final de hipoteca.

Entonces la refactorización natural es:

👉 reunir esa lógica y moverla a un método: calcularHipoteca(...)

🧠 Ejemplo de extracción: método `calcularHipoteca`

Aquí te muestro la idea (no es el código completo todavía, es el esqueleto limpio):

public class Main {

    public static double calcularHipoteca(double capital, double interesAnual, int anios) {
        double interesMensual = interesAnual / 12 / 100;
        int numeroPagos = anios * 12;

        double hipoteca = capital * (interesMensual * Math.pow(1 + interesMensual, numeroPagos))
                        / (Math.pow(1 + interesMensual, numeroPagos) - 1);

        return hipoteca;
    }
}

✅ Todo lo que “pertenece al cálculo” quedó junto. ✅ Y ahora ese método queda reusable para cualquier otro programa.

2️⃣ Patrón repetitivo: los `while` de validación

Ahora pensemos en lo repetitivo.

En la calculadora, para pedir datos al usuario hacemos algo así:

while (true)
mostramos una pregunta
leemos un valor
validamos
si está mal → mostramos error

📌 Eso se repite para:

capital
interés anual
años

✅ Cambia solo:

el texto de la pregunta
el mínimo y máximo permitidos
el mensaje de error

Esto es una oportunidad clarísima para refactorizar.

🔁 Extraer patrón: método `leerNumero(...)`

La idea sería crear un método que haga “la plantilla”:

import java.util.Scanner;

public class Main {

    public static double leerNumero(Scanner sc, String pregunta, double min, double max) {
        while (true) {
            System.out.print(pregunta);
            double valor = sc.nextDouble();

            if (valor >= min && valor <= max)
                return valor;

            System.out.println("Entrada inválida. Intenta de nuevo.");
        }
    }
}

✅ Ya no repites el patrón 3 veces. ✅ Solo cambias la pregunta y los rangos.

🧩 Resultado final: `main` cortico y limpio

Cuando refactorizamos bien, main debería quedar así: corto y legible.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        double capital = leerNumero(sc, "Capital: ", 1000, 1_000_000);
        double interes = leerNumero(sc, "Interés anual: ", 1, 30);
        int anios = (int) leerNumero(sc, "Años: ", 1, 30);

        double hipoteca = calcularHipoteca(capital, interes, anios);
        System.out.println("Hipoteca: " + hipoteca);

        sc.close();
    }
}

📌 Ahora main se lee como una receta:

pido datos
calculo
muestro

✅ Cierre: ¿por qué esto es potente?

Refactorizar sirve porque:

tu código se vuelve más fácil de leer
es más fácil de probar y corregir
puedes reutilizar métodos
y el proyecto crece sin volverse un monstruo

Refactorización