Iterativa VS Cursiva

import java.math.BigInteger;
import java.util.Scanner;
import java.lang.StackOverflowError;

/*
 * Autor: Stoyanov Angel Krasimirov
 */

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

        double a = askNumber(sc, "Introduce la base");
        int n = askNumber(sc);



        try {
            System.out.printf("El resultado es: %d", potenciaIterativa(a, n));
        } catch (StackOverflowError e) {
            System.out.println("Se ha producido un desbordamiento de pila.");
        }
    }

    /**
     * Pregunta al usuario un número con la pregunta indicada y lo devuelve.
     * @param sc
     * @param message
     * @return Devuelve un double.
     */
    private static double askNumber(Scanner sc, String message) {
        System.out.printf("%s: ", message);

        try {
            return Double.parseDouble(sc.nextLine().replace(',', '.'));

        } catch (NumberFormatException e) {
            System.out.println("El número no es válido.");
            return askNumber(sc, message);
        }
    }

    /**
     * Pregunta al usuario un número y lo devuelve.
     * @param sc
     * @return Devuelve un int.
     */
    private static int askNumber(Scanner sc) {
        System.out.printf("Introduce la potencia: ");

        try {
            int number = Integer.parseInt(sc.nextLine());

            if (number < 0) {
                System.out.println("El número no puede ser negativo.");
                return askNumber(sc);
            }
            return number;
        } catch (NumberFormatException e) {
            System.out.println("El número no es válido.");
            return askNumber(sc);
        }
    }

    /**
     * Calcula la potencia de un número de forma iterativa.
     * @param a
     * @param n
     * @return Devuelve un BigInteger de precisión arbitraria.
     */
    private static BigInteger potenciaIterativa (double a, int n) {
        BigInteger result = BigInteger.valueOf((long) a);

        System.out.println();

        for (int i = 1; i < n; i++) {
            result = result.multiply(BigInteger.valueOf((long) a));

            if (i%1000 == 0) {
                double progress = i/ (double) n*100;
                System.out.printf("\r%s\r[%s%s] - %.2f", " ".repeat(150) , "#".repeat((int) progress), "-".repeat(100- (int) progress), progress);
            }
        }
        System.out.println();

        return result;
    }

    /**
     * Calcula la potencia de un número de forma recursiva.
     * @param a
     * @param n
     * @return Devuelve un BigInteger de precisión arbitraria.
     */
    private static BigInteger potenciaRecursiva (double a, int n) {
        if (n == 0) {
            return BigInteger.valueOf(1);
        }
        return BigInteger.valueOf((long) a).multiply(potenciaRecursiva(a, n-1));
    }
}