Métodos: apuntes de Programación (PROG)

Introducción a las Funciones

Conforme aumenta la extensión y la complejidad de un programa, es habitual tener que implementar, en distintas partes, la misma funcionalidad, cosa que implica copiar una y otra vez, donde sea necesario, el mismo fragmento de código. Esto genera dos problemas:

Duplicidad del código: Aumenta el tamaño del código y lo hace menos legible.
Dificultad en el mantenimiento: Cualquier modificación necesaria dentro del fragmento de código repetido tendría que realizarse en todos y cada uno de los lugares donde se encuentra.

Podríamos pensar en utilizar un bucle, pero si el código se repite en lugares separados del programa, esto no es posible.

Problema del código repetido

Imagina que tienes el mismo código copiado en 10 lugares diferentes de tu programa. Si encuentras un error o necesitas hacer un cambio, tendrías que modificarlo en los 10 lugares. ¡Es ineficiente y propenso a errores!

Funciones en programación — Fernando Herrera — youtube.com/watch?v=MiH3pbP4EFc

Conceptos Básicos de Funciones

La solución para cuando necesitamos la misma funcionalidad en distintos lugares de nuestro código no es más que etiquetar con un nombre un fragmento de código y sustituir en el programa dicho fragmento, en todos los lugares donde aparezca, por el nombre que le hemos asignado.

Ejemplo: Código Repetido

codigo-repetido.java
public static void main(String[] args) {
    // ... código
    
    // Fragmento repetido #1
    System.out.println("Voy a saludar tres veces:");
    for (int i = 0; i < 3; i++) {
        System.out.println("Hola.");
    }
    
    // ... más código
    
    // Fragmento repetido #2
    System.out.println("Voy a saludar tres veces:");
    for (int i = 0; i < 3; i++) {
        System.out.println("Hola.");
    }
    
    // ... otro código
    
    // Fragmento repetido #3
    System.out.println("Voy a saludar tres veces:");
    for (int i = 0; i < 3; i++) {
        System.out.println("Hola.");
    }
}

Solución: Usar una Función

Cada fragmento de código repetido puede sustituirse por el nombre que le hemos asignado, en nuestro casosaludarTresVeces():

con-funcion.java
public static void main(String[] args) {
    // ... código
    saludarTresVeces();  // Sustitución por una función
    
    // ... más código
    saludarTresVeces();  // Sustitución por una función
    
    // ... otro código
    saludarTresVeces();  // Sustitución por una función
    
    // ... resto del código
}

La función saludarTresVeces() tendrá que definirse, de forma que se especifique el conjunto de instrucciones que la forma:

definicion-funcion.java
public static void main(String[] args) {
    saludarTresVeces();
    // ... más código
}

// Definición de la función
static void saludarTresVeces() {
    System.out.println("Voy a saludar tres veces:");
    
    for (int i = 0; i < 3; i++) {
        System.out.println("Hola.");
    }
}

Ubicación de las funciones

La definición de una función puede hacerse antes o después delmain(). Por convención, suele colocarse después.

Concepto de Función

Esto representa el concepto de función: un conjunto de instrucciones agrupadas bajo un nombre y con un objetivo común, que se ejecuta al ser invocada.

Sintaxis General

sintaxis-funcion.java
static tipo nombreFuncion() {
    // Cuerpo de la función
    // Instrucciones que se ejecutarán
}

Por ahora, definiremos las funciones static y utilizaremos como tipo la función void, que indica que la función no devuelve nada.

Convención de Nombres (Camel Case)

Habitualmente, los nombres de funciones siguen el estilo Camel Case: los nombres comienzan en minúscula, distinguiendo en los nombres compuestos cada palabra mediante la mayúscula inicial.

ejemplos-nombres.java
// Ejemplos de nombres de funciones en Camel Case
suma()
saludarTresVeces()
calcularRaizCuadrada()
mostrarTodosDatosCliente()
validarContrasena()
obtenerFechaActual()

Terminología Importante

Llamada a la función

Es el nombre de la función, seguido de () paréntesis. Se convierte en una nueva instrucción que podemos utilizar para invocar la función.

llamada.java
saludarTresVeces();  // Esto es una llamada a la función

Prototipo de la función

Es la declaración de la función, donde se especifica su nombre, el tipo que devuelve y, entre paréntesis, los parámetros de entrada que utiliza.

prototipo.java
static void saludarTresVeces()  // Este es el prototipo

Cuerpo de la función

Es el bloque de código que ejecuta la función cada vez que se invoca y que aparece entre llaves después del prototipo.

cuerpo.java
static void saludarTresVeces() {
    // Este es el cuerpo de la función
    System.out.println("Voy a saludar tres veces:");
    for (int i = 0; i < 3; i++) {
        System.out.println("Hola.");
    }
}

Definición de una función

Está formada por el prototipo más el cuerpo de la función.

Ventajas de Usar Funciones

Con esto evitamos:

La duplicidad del código: Ya que el código se escribe una única vez, en la definición de la función.
La dificultad en el mantenimiento: Ahora, las modificaciones, en el caso de que sean necesarias, solo se realizan en un lugar: en la definición de la función.

Flujo de Ejecución

El comportamiento de una llamada a una función consiste en:

Las instrucciones del programa principal se ejecutan hasta que encuentra la llamada a la función.
La ejecución salta a la definición de la función.
Se ejecuta el cuerpo de la función.
Cuando la ejecución del cuerpo termina, retornamos al punto del programa desde donde se invocó la función.
El programa continúa su ejecución.

Funciones vs Métodos

Los métodos que hemos utilizado de algunas clases de la API (como nextInt() deScanner) en realidad son funciones. Una función y un método son conceptualmente idénticos, la única diferencia está en el nombre, que varía dependiendo del paradigma de programación usado:

Programación estructurada: Se llaman funciones
Programación orientada a objetos: Se denominan métodos

ejemplo-completo.java
public class EjemploFunciones {
    
    public static void main(String[] args) {
        System.out.println("Inicio del programa");
        
        saludarTresVeces();  // Primera llamada
        
        System.out.println("\nOtra parte del código");
        
        saludarTresVeces();  // Segunda llamada
        
        System.out.println("\nFin del programa");
    }
    
    // Definición de la función
    static void saludarTresVeces() {
        System.out.println("Voy a saludar tres veces:");
        for (int i = 0; i < 3; i++) {
            System.out.println("Hola.");
        }
    }
}

// Salida:
// Inicio del programa
// Voy a saludar tres veces:
// Hola.
// Hola.
// Hola.
//
// Otra parte del código
// Voy a saludar tres veces:
// Hola.
// Hola.
// Hola.
//
// Fin del programa

Curso de Java #14 - Funciones en Java — Roelcode — youtube.com/watch?v=dmYcxugkafI

Ámbito de las Variables

En el cuerpo de una función podemos declarar variables, que se conocen como variables locales. El ámbitode estas, es decir, donde pueden utilizarse, es la propia función donde se declaran, no pudiéndose utilizar fuera de ella.

ambito-variables.java
public static void main(String[] args) {
    int x = 10;  // Variable local del main
    
    miFuncion();
    
    // System.out.println(y);  // ERROR: 'y' no existe aquí
}

static void miFuncion() {
    int y = 20;  // Variable local de miFuncion
    
    System.out.println(y);  // OK: 'y' existe aquí
    
    // System.out.println(x);  // ERROR: 'x' no existe aquí
}

Ámbito de variables

Cada función tiene su propio espacio de variables locales. Las variables declaradas dentro de una función solo existen dentro de esa función y no pueden ser accedidas desde otras funciones o desde el main.

Variables de Bloque

Nada impide que dentro del cuerpo de una función se utilicen sentencias (if,if-else, bucles, etc.) con sus respectivos bloques de instrucciones, donde a su vez, se pueden volver a declarar nuevas variables que se conocen como variables de bloque, siempre y cuando su nombre no coincida con una variable declarada antes, fuera del bloque, ya que esto producirá un error.

variables-bloque.java
static void ejemploAmbito() {
    int x = 10;  // Variable local de la función
    
    if (x > 5) {
        int y = 20;  // Variable de bloque (solo existe dentro del if)
        System.out.println("x = " + x);  // OK: x está disponible
        System.out.println("y = " + y);  // OK: y está disponible aquí
    }
    
    System.out.println("x = " + x);  // OK: x sigue disponible
    // System.out.println("y = " + y);  // ERROR: y no existe fuera del if
    
    for (int i = 0; i < 3; i++) {
        int z = i * 2;  // Variable de bloque del for
        System.out.println(z);
    }
    
    // System.out.println(i);  // ERROR: i no existe fuera del for
    // System.out.println(z);  // ERROR: z no existe fuera del for
}

ejemplo-completo-ambito.java
public class EjemploAmbito {
    
    public static void main(String[] args) {
        int a = 5;
        System.out.println("En main, a = " + a);
        
        funcion1();
        funcion2();
        
        // Las variables de funcion1 y funcion2 no existen aquí
    }
    
    static void funcion1() {
        int b = 10;  // Variable local de funcion1
        System.out.println("En funcion1, b = " + b);
        
        if (b > 5) {
            int c = 15;  // Variable de bloque
            System.out.println("Dentro del if, c = " + c);
        }
        
        // c no existe aquí
    }
    
    static void funcion2() {
        int d = 20;  // Variable local de funcion2
        System.out.println("En funcion2, d = " + d);
        
        // b, c, y a no existen aquí
    }
}

Tipo de Variable	Ámbito	Ejemplo
Local (función)	Toda la función donde se declara	int x = 10;
Bloque (if, for, etc.)	Solo dentro del bloque	if(...) { int y; }

Paso de Información a una Función

En ocasiones, una función necesita conocer información externa para poder llevar a cabo su tarea. Veamos un ejemplo: la funciónsaludarTresVeces() es conveniente cuando queremos saludar exactamente tres veces. Si deseamos saludar un número distinto de veces, estaríamos obligados a implementar las funciones: unSaludo(),dosSaludos(),cuatroSaludos(), etc.

Es mucho más práctico implementar la función variosSaludos() a la que se le pasa el número de veces que deseamos saludar. De esta manera, si ejecutamosvariosSaludos(7), saludará siete veces y si ejecutamosvariosSaludos(2), lo hará en dos ocasiones.

funcion-parametros.java
static void variosSaludos(int veces) {
    for (int i = 0; i < veces; i++) {
        System.out.println("Hola.");
    }
}

La variable veces es un parámetro de entrada de la funciónvariosSaludos(). Un parámetro de entrada de una función no es más que una variable local a la que se le asigna valores en cada llamada.

Valores en la Llamada

En la llamada a una función se pueden pasar valores que provienen de literales, expresiones o variables.

valores-llamada.java
// Llamada con un literal
variosSaludos(2);

// Llamada con una variable
int n = 3;
variosSaludos(n);

// Llamada con una expresión
variosSaludos(2 * n);  // 2 * 3 = 6 saludos

// Llamada con una operación
int a = 5;
int b = 2;
variosSaludos(a + b);  // 5 + 2 = 7 saludos

Parámetros de Entrada

Una función puede definirse para recibir tantos datos como necesite. Por ejemplo, una función que realiza la suma puede definirse para que se le pasen dos valores que sumar; y a otra que indica si una fecha es correcta se le pasarán tres valores: el año, el mes y el día de la fecha.

funcion-suma.java
// Para una función que calcula y muestra la suma de dos números
int a = 3;
suma(a, 2);  // Muestra la suma de a (que vale 3) más 2

Sintaxis con Múltiples Parámetros

sintaxis-parametros.java
static tipo nombreFuncion(tipo1 parametro1, tipo2 parametro2, ...) {
    // Cuerpo de la función
    // Los parámetros son variables locales inicializadas
}

El primer parámetro de entrada lo hemos llamado parametro1 y se le puede asignar un valor del tipo tipo1, y lo mismo ocurre con el resto de parámetros. El número de parámetros definidos en la función determina el número de valores que hay que utilizar en cada llamada.

ejemplos-multiples-parametros.java
// Ejemplo 1: Función suma con dos parámetros
static void suma(int num1, int num2) {
    int resultado = num1 + num2;
    System.out.println("La suma es: " + resultado);
}

// Llamadas
suma(5, 3);      // La suma es: 8
suma(10, 20);    // La suma es: 30

// Ejemplo 2: Función para verificar hora
static void compruebaHora(int hora, int minutos, int segundos) {
    if (hora >= 0 && hora < 24 && 
        minutos >= 0 && minutos < 60 && 
        segundos >= 0 && segundos < 60) {
        System.out.println("Hora correcta: " + hora + ":" + minutos + ":" + segundos);
    } else {
        System.out.println("Hora incorrecta");
    }
}

// Llamadas
int a = 20;
int b = 3;
compruebaHora(a, 4, 2 * b + 1);  // 20:4:7

// Ejemplo 3: Función con diferentes tipos
static void mostrarDatosPersona(String nombre, int edad, double altura) {
    System.out.println("Nombre: " + nombre);
    System.out.println("Edad: " + edad + " años");
    System.out.println("Altura: " + altura + " metros");
}

// Llamada
mostrarDatosPersona("Ana", 25, 1.65);

Paso de Parámetros por Valor

En Java los parámetros toman su valor como una copia del valor de la expresión o variable utilizada en la llamada; este mecanismo de paso de parámetros se denomina paso de parámetros por valor o por copia.

En la figura se aprecia cómo se realiza la copia de los valores de las variables utilizadas en la llamada a las variables empleadas como parámetros.

Importante: Los cambios no afectan al original

Hay que destacar que cualquier cambio en un parámetro de entrada que se efectúe dentro del cuerpo de la función no repercute en la variable o expresión utilizada en la llamada, ya que lo que se modifica es una copia y no el dato original.

paso-por-valor.java
public static void main(String[] args) {
    int a = 1, b = 2, c = 3;
    
    System.out.println("Antes de llamar: a=" + a + ", b=" + b + ", c=" + c);
    
    compruebaHora(a, b, c);  // Llamada
    
    System.out.println("Después de llamar: a=" + a + ", b=" + b + ", c=" + c);
    // a, b y c mantienen sus valores originales
}

// Definición de la función
static void compruebaHora(int hora, int minutos, int segundos) {
    System.out.println("Dentro de la función: hora=" + hora);
    
    // Modificamos el parámetro
    hora = 23;  // Solo modifica la COPIA, no el original
    
    System.out.println("Después de modificar: hora=" + hora);
    
    // Verificación de la hora
    if (hora >= 0 && hora < 24 && 
        minutos >= 0 && minutos < 60 && 
        segundos >= 0 && segundos < 60) {
        System.out.println("Hora válida");
    }
}

// Salida:
// Antes de llamar: a=1, b=2, c=3
// Dentro de la función: hora=1
// Después de modificar: hora=23
// Hora válida
// Después de llamar: a=1, b=2, c=3
// ¡La variable 'a' sigue valiendo 1!

ejemplo-visual-paso-valor.java
public static void main(String[] args) {
    int x = 10;
    System.out.println("Antes: x = " + x);
    
    modificarValor(x);
    
    System.out.println("Después: x = " + x);  // x sigue siendo 10
}

static void modificarValor(int numero) {
    System.out.println("Dentro función (antes): numero = " + numero);
    
    numero = 99;  // Solo modifica la copia
    
    System.out.println("Dentro función (después): numero = " + numero);
}

// Salida:
// Antes: x = 10
// Dentro función (antes): numero = 10
// Dentro función (después): numero = 99
// Después: x = 10  ← El original NO cambió

FUNCIONES con PARÁMETROS en Java | Curso Java # 17 — UskoKruM2010 — youtube.com/watch?v=mkvcPFh_UmM

Valor Devuelto por una Función

Hemos visto que es posible pasar información hacia la función a través de los parámetros de entrada. También es posible que el paso de información sea en sentido contrario, es decir, desde el cuerpo de la función hacia el código donde se hace la llamada.

Con esto conseguimos que la llamada a una función se convierta en un valor cualquiera. Este puede ser utilizado desde el lugar donde se invoca.

ejemplo-return.java
// Supongamos que tenemos una función suma() que devuelve un valor
int a = suma(2, 3);        // a = 5
int b = suma(7, 1) * 5;    // b = 8 * 5 = 40

// En la primera instrucción: suma(2, 3) se sustituye por 5
// En la segunda instrucción: suma(7, 1) se sustituye por 8

La Instrucción return

Hasta ahora hemos utilizado siempre void como tipo devuelto por una función, lo que indica que la función no devuelve nada, o dicho de otra forma: la llamada a la función no se sustituye por ningún valor.

Es posible utilizar cualquier tipo para especificar que la llamada a la función se sustituirá por un valor del tipo indicado. ¿Cómo damos ese valor a la llamada de la función? Para ello disponemos de la instrucción return que finaliza la ejecución de la función y devuelve el valor indicado.

Sintaxis General

sintaxis-return.java
static tipo nombreFuncion(parámetros) {
    // ... código
    return valor;  // El tipo de 'valor' debe coincidir con 'tipo'
}

Cuándo usar return

La instrucción return se utiliza en funciones con un tipo devuelto distinto a void. Debe existir una concordancia entre el tipo devuelto declarado en la función y el tipo del valor devuelto con return.

Ejemplo: Función Suma

funcion-suma-return.java
// Función que devuelve un int
static int suma(int x, int y) {
    int resultado;
    resultado = x + y;
    return resultado;  // Devuelve el valor de resultado
}

// Uso de la función
public static void main(String[] args) {
    int a = suma(5, 3);
    System.out.println("La suma es: " + a);  // 8
    
    // También se puede usar directamente
    System.out.println("Suma: " + suma(10, 20));  // 30
    
    // O en expresiones
    int b = suma(2, 3) * 2;
    System.out.println("Resultado: " + b);  // 10
}

Ejemplos con Diferentes Tipos de Retorno

ejemplos-return-tipos.java
// Función que devuelve un double
static double calcularPromedio(double num1, double num2, double num3) {
    double suma = num1 + num2 + num3;
    double promedio = suma / 3.0;
    return promedio;
}

// Función que devuelve un boolean
static boolean esPar(int numero) {
    if (numero % 2 == 0) {
        return true;
    } else {
        return false;
    }
    // Forma más concisa: return numero % 2 == 0;
}

// Función que devuelve un String
static String obtenerDiaSemana(int dia) {
    if (dia == 1) return "Lunes";
    if (dia == 2) return "Martes";
    if (dia == 3) return "Miércoles";
    if (dia == 4) return "Jueves";
    if (dia == 5) return "Viernes";
    if (dia == 6) return "Sábado";
    if (dia == 7) return "Domingo";
    return "Día inválido";
}

// Función que devuelve el mayor de dos números
static int maximo(int a, int b) {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

// Función que calcula el factorial
static long factorial(int n) {
    long resultado = 1;
    for (int i = 1; i <= n; i++) {
        resultado *= i;
    }
    return resultado;
}

// USO DE LAS FUNCIONES
public static void main(String[] args) {
    // Usar calcularPromedio
    double prom = calcularPromedio(8.5, 7.0, 9.5);
    System.out.println("Promedio: " + prom);  // 8.333...
    
    // Usar esPar
    if (esPar(10)) {
        System.out.println("10 es par");
    }
    
    // Usar obtenerDiaSemana
    String dia = obtenerDiaSemana(3);
    System.out.println("Día: " + dia);  // Miércoles
    
    // Usar maximo
    int mayor = maximo(15, 23);
    System.out.println("Mayor: " + mayor);  // 23
    
    // Usar factorial
    long fact = factorial(5);
    System.out.println("5! = " + fact);  // 120
}

Buenas prácticas con return

La última instrucción de una función con retorno debe ser return
Las instrucciones después de return nunca se ejecutarán
Es desaconsejable usar varios return en una misma función (aunque es válido)
Una función debe tener un único punto de entrada y salida

codigo-inalcanzable.java
static int ejemplo() {
    int x = 10;
    return x;
    
    // ERROR: Todo lo que está después de return es inalcanzable
    // System.out.println("Esto nunca se ejecuta");
    // x = 20;
}

// EVITAR: Múltiples returns (funciona pero no es ideal)
static int calcular(int x) {
    if (x < 0) {
        return -1;  // Return 1
    }
    if (x == 0) {
        return 0;   // Return 2
    }
    return x * 2;   // Return 3
}

// MEJOR: Un solo return
static int calcularMejor(int x) {
    int resultado;
    
    if (x < 0) {
        resultado = -1;
    } else if (x == 0) {
        resultado = 0;
    } else {
        resultado = x * 2;
    }
    
    return resultado;  // Un solo punto de salida
}

Tutoriales Java: 10 Funciones que devuelven valores (Return) — IkexIke — youtube.com/watch?v=JoWxkeuu6Wo

Sobrecarga de Funciones

Java permite que dos o más funciones compartan el mismo identificador (nombre) en un mismo programa. Esto es lo que se conoce como sobrecarga de funciones.

La forma de distinguir entre las distintas funciones sobrecargadas es mediante su lista de parámetros, que deben ser distintas, ya sea en número o en tipo.

Reglas de la sobrecarga

Las funciones sobrecargadas deben tener diferentes parámetros (número o tipo)
Las funciones sobrecargadas pueden devolver tipos distintos
El tipo de retorno NO sirve para distinguir una función sobrecargada de otra

Ejemplo: Funciones Suma Sobrecargadas

sobrecarga-suma.java
// Función sobrecargada #1: Suma simple de dos enteros
static int suma(int a, int b) {
    int suma;
    suma = a + b;
    return suma;
}

// Función sobrecargada #2: Suma ponderada de dos enteros
static double suma(int a, double pesoA, int b, double pesoB) {
    double suma;
    suma = a * pesoA / (pesoA + pesoB) + b * pesoB / (pesoA + pesoB);
    return suma;
}

// USO
public static void main(String[] args) {
    // Se ejecuta la primera versión (2 parámetros int)
    int resultado1 = suma(2, 3);
    System.out.println("Suma simple: " + resultado1);  // 5
    
    // Se ejecuta la segunda versión (4 parámetros: int, double, int, double)
    double resultado2 = suma(2, 0.25, 3, 0.75);
    System.out.println("Suma ponderada: " + resultado2);  // 2.75
}

Más Ejemplos de Sobrecarga

ejemplos-sobrecarga.java
// Ejemplo 1: Función imprimir sobrecargada
static void imprimir(int numero) {
    System.out.println("Número entero: " + numero);
}

static void imprimir(double numero) {
    System.out.println("Número decimal: " + numero);
}

static void imprimir(String texto) {
    System.out.println("Texto: " + texto);
}

static void imprimir(int num1, int num2) {
    System.out.println("Dos números: " + num1 + " y " + num2);
}

// Ejemplo 2: Función calcularArea sobrecargada
// Área de un círculo
static double calcularArea(double radio) {
    return Math.PI * radio * radio;
}

// Área de un rectángulo
static double calcularArea(double base, double altura) {
    return base * altura;
}

// Área de un triángulo (con tres parámetros)
static double calcularArea(double base, double altura, boolean esTriangulo) {
    if (esTriangulo) {
        return (base * altura) / 2.0;
    }
    return base * altura;
}

// Ejemplo 3: Función mayor sobrecargada
static int mayor(int a, int b) {
    return a > b ? a : b;
}

static int mayor(int a, int b, int c) {
    int max = a;
    if (b > max) max = b;
    if (c > max) max = c;
    return max;
}

static double mayor(double a, double b) {
    return a > b ? a : b;
}

// USO DE LAS FUNCIONES SOBRECARGADAS
public static void main(String[] args) {
    // Diferentes versiones de imprimir
    imprimir(10);              // "Número entero: 10"
    imprimir(3.14);            // "Número decimal: 3.14"
    imprimir("Hola");          // "Texto: Hola"
    imprimir(5, 8);            // "Dos números: 5 y 8"
    
    // Diferentes versiones de calcularArea
    double areaCirculo = calcularArea(5.0);           // π * 5²
    double areaRectangulo = calcularArea(4.0, 6.0);   // 4 * 6
    double areaTriangulo = calcularArea(4.0, 6.0, true);  // (4*6)/2
    
    System.out.println("Área círculo: " + areaCirculo);
    System.out.println("Área rectángulo: " + areaRectangulo);
    System.out.println("Área triángulo: " + areaTriangulo);
    
    // Diferentes versiones de mayor
    System.out.println("Mayor de 5 y 8: " + mayor(5, 8));
    System.out.println("Mayor de 3, 7 y 2: " + mayor(3, 7, 2));
    System.out.println("Mayor de 3.5 y 2.8: " + mayor(3.5, 2.8));
}

Sobrecarga en la API de Java

Es muy común encontrar en la API funciones (métodos) sobrecargadas, ya que permiten agrupar distintas funcionalidades, cuyo uso es similar, bajo el mismo identificador. Por ejemplo, la función que más hemos utilizado hasta ahora, System.out.println, se encuentra sobrecargada para poder mostrar en pantalla cualquier tipo de dato.

println-sobrecargado.java
// System.out.println está sobrecargado para aceptar diferentes tipos
System.out.println(10);           // println(int)
System.out.println(3.14);         // println(double)
System.out.println("Hola");       // println(String)
System.out.println(true);         // println(boolean)
System.out.println('A');          // println(char)

Válido para Sobrecarga	No Válido
Diferente número de parámetros	Solo diferente tipo de retorno
Diferente tipo de parámetros	Solo diferente nombre de parámetros
Diferente orden de tipos	Parámetros idénticos

SOBRESCRITURA y SOBRECARGA de MÉTODOS en JAVA | | Curso de POO | Explicación FÁCIL — TodoCode — youtube.com/watch?v=H9KE1HmFmTM

Recursividad

Una función puede ser invocada desde cualquier lugar: desde el programa principal, desde otra función e incluso desde dentro de su propio cuerpo de instrucciones. En este último caso, cuando una función se invoca a sí misma, diremos que es una función recursiva.

recursiva-basica.java
static int funcionRecursiva() {
    funcionRecursiva();  // Llamada recursiva a sí misma
    // ¡PROBLEMA! Esto crea un bucle infinito
}

Este es el esquema general de una función recursiva. Si observamos con atención, se plantea un problema: dentro de funcionRecursiva() se invoca afuncionRecursiva(), donde a su vez, se volverá a llamar afuncionRecursiva(), y así sucesivamente. Esto nos lleva a un ciclo infinito de llamadas a la función.

Caso Base

Para evitar el ciclo infinito, hemos de habilitar un mecanismo que detenga, en algún momento, la serie de llamadas recursivas: una sentencia if que, utilizando una condición, llamada "caso base", impida que se continúe con una nueva llamada recursiva.

Esquema General

esquema-recursivo.java
static int funcionRecursiva(datos) {
    int resultado;
    
    if (caso_base) {
        // Condición de parada
        resultado = valorBase;
    } else {
        // Llamada recursiva con datos reducidos
        resultado = funcionRecursiva(nuevosDatos);
    }
    
    return resultado;
}

Principios de la recursividad

Caso base: Condición que detiene las llamadas recursivas
Caso recursivo: La función se llama a sí misma con un problema más pequeño
Convergencia: Los datos deben tender hacia el caso base

Solo cuando la condición del caso base sea false, se hará una nueva llamada recursiva. Cuando el caso base sea true se romperá la cadena de llamadas.

La idea principal de la recursividad es solucionar un problema reduciendo su tamaño. Este proceso continúa hasta que tenga un tamaño tan pequeño que su solución sea trivial.

Ejemplo: Factorial

Vamos a ver un ejemplo, supongamos que tenemos que calcular el factorial de un número "n" que se representa por "n!".

definicion-factorial

1Definición matemática del factorial:
2n! = n × (n-1) × (n-2) × ... × 2 × 1
3
4Ejemplos:
55! = 5 × 4 × 3 × 2 × 1 = 120
64! = 4 × 3 × 2 × 1 = 24
73! = 3 × 2 × 1 = 6
82! = 2 × 1 = 2
91! = 1
100! = 1 (por definición)

La definición de factorial se puede escribir también del siguiente modo de forma recursiva:

factorial-recursivo

1Definición recursiva:
2n! = n × (n-1)!
3
4Ejemplos:
55! = 5 × 4!
64! = 4 × 3!
73! = 3 × 2!
82! = 2 × 1!
91! = 1 × 0!
100! = 1  ← CASO BASE

Se considera por definición que el factorial de cero vale uno. Para calcular el factorial de un número, estamos utilizando el factorial de un número más pequeño, con lo cual estamos reduciendo el problema.

Hemos de buscar un caso base, es decir, un valor para el que calcular el factorial sea algo trivial y no necesitemos volver a utilizar el método recursivo. El caso base del factorial es: 0! = 1.

Implementación

factorial-recursivo.java
static long factorial(int n) {
    long resultado;
    
    if (n == 0) {  // Caso base
        resultado = 1;
    } else {  // Caso recursivo
        resultado = n * factorial(n - 1);  // Llamada recursiva
    }
    
    return resultado;
}

// Forma más compacta
static long factorialCompacto(int n) {
    if (n == 0) {
        return 1;  // Caso base
    }
    return n * factorialCompacto(n - 1);  // Caso recursivo
}

Traza de Ejecución

traza-factorial

1Llamada: factorial(5)
2
3Paso 1: factorial(5)
4  ├─ n = 5, no es caso base
5  └─ return 5 * factorial(4)
6       │
7Paso 2: factorial(4)
8       ├─ n = 4, no es caso base
9       └─ return 4 * factorial(3)
10            │
11Paso 3: factorial(3)
12            ├─ n = 3, no es caso base
13            └─ return 3 * factorial(2)
14                 │
15Paso 4: factorial(2)
16                 ├─ n = 2, no es caso base
17                 └─ return 2 * factorial(1)
18                      │
19Paso 5: factorial(1)
20                      ├─ n = 1, no es caso base
21                      └─ return 1 * factorial(0)
22                           │
23Paso 6: factorial(0)
24                           ├─ n = 0, ¡CASO BASE!
25                           └─ return 1
26
27Ahora se resuelven las llamadas en orden inverso:
28
29factorial(0) = 1
30factorial(1) = 1 * 1 = 1
31factorial(2) = 2 * 1 = 2
32factorial(3) = 3 * 2 = 6
33factorial(4) = 4 * 6 = 24
34factorial(5) = 5 * 24 = 120
35
36Resultado final: 120

Más Ejemplos de Recursividad

ejemplos-recursividad.java
// Ejemplo 1: Suma de números del 1 al n
static int sumaHastaN(int n) {
    if (n == 1) {  // Caso base
        return 1;
    }
    return n + sumaHastaN(n - 1);  // Caso recursivo
}
// sumaHastaN(5) = 5 + 4 + 3 + 2 + 1 = 15

// Ejemplo 2: Potencia (a^n)
static int potencia(int base, int exponente) {
    if (exponente == 0) {  // Caso base: a^0 = 1
        return 1;
    }
    return base * potencia(base, exponente - 1);
}
// potencia(2, 3) = 2 * 2 * 2 = 8

// Ejemplo 3: Fibonacci
static int fibonacci(int n) {
    if (n == 0) {  // Caso base 1
        return 0;
    }
    if (n == 1) {  // Caso base 2
        return 1;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);  // Caso recursivo
}
// fibonacci(5) = 0, 1, 1, 2, 3, 5

// Ejemplo 4: Contar dígitos de un número
static int contarDigitos(int numero) {
    if (numero < 10) {  // Caso base: un solo dígito
        return 1;
    }
    return 1 + contarDigitos(numero / 10);
}
// contarDigitos(12345) = 5

// Ejemplo 5: Invertir un número
static int invertir(int numero, int invertido) {
    if (numero == 0) {  // Caso base
        return invertido;
    }
    int ultimoDigito = numero % 10;
    return invertir(numero / 10, invertido * 10 + ultimoDigito);
}
// invertir(12345, 0) = 54321

// Ejemplo 6: Máximo común divisor (MCD) - Algoritmo de Euclides
static int mcd(int a, int b) {
    if (b == 0) {  // Caso base
        return a;
    }
    return mcd(b, a % b);
}
// mcd(48, 18) = 6

// USO DE LAS FUNCIONES
public static void main(String[] args) {
    System.out.println("Suma 1 a 5: " + sumaHastaN(5));  // 15
    System.out.println("2^3: " + potencia(2, 3));  // 8
    System.out.println("Fibonacci(6): " + fibonacci(6));  // 8
    System.out.println("Dígitos de 12345: " + contarDigitos(12345));  // 5
    System.out.println("Invertir 12345: " + invertir(12345, 0));  // 54321
    System.out.println("MCD(48, 18): " + mcd(48, 18));  // 6
}

Consideraciones sobre recursividad

Ventajas: Código elegante y fácil de entender para problemas que se definen recursivamente
Desventajas: Consume más memoria (cada llamada se guarda en la pila) y puede ser más lento que soluciones iterativas
Riesgo: Si el caso base está mal definido o los datos no convergen, puede causar desbordamiento de pila (Stack Overflow)

Aspecto	Recursividad	Iteración
Legibilidad	Más clara para problemas recursivos	Puede ser más verbosa
Memoria	Usa más memoria (pila)	Más eficiente
Velocidad	Generalmente más lenta	Más rápida
Riesgo	Stack overflow si mal diseñada	Bucle infinito (más fácil detectar)

La MAGIA de la RECURSIVIDAD — BettaTech — youtube.com/watch?v=yX5kR63Dpdw

Ejercicios Prácticos

Ejemplo Guiado

Fácil

Calculadora con Funciones

Crea un programa que implemente una calculadora usando funciones: 1. Crea funciones separadas para: suma, resta, multiplicación, división y módulo 2. Cada función debe recibir dos números y devolver el resultado 3. La función división debe validar que el divisor no sea cero 4. Crea un menú en el main que permita elegir la operación 5. Muestra el resultado usando el valor devuelto por las funciones Requisitos: - Todas las funciones deben devolver un valor (no void) - Usar parámetros para recibir los números - Validar entradas cuando sea necesario Ejemplo de ejecución: === CALCULADORA === 1. Suma 2. Resta 3. Multiplicación 4. División 5. Módulo Elige: 1 Número 1: 10 Número 2: 5 Resultado: 15

Ejercicio Práctico

Medio

Validación de Contraseñas

Crea funciones para validar contraseñas según estos criterios: 1. `longitudValida(password)`: Verifica que tenga entre 8 y 20 caracteres 2. `tieneMayuscula(password)`: Verifica que tenga al menos una mayúscula 3. `tieneMinuscula(password)`: Verifica que tenga al menos una minúscula 4. `tieneDigito(password)`: Verifica que tenga al menos un número 5. `esPasswordSegura(password)`: Usa las funciones anteriores y devuelve true si cumple todos los criterios En el main: - Solicita una contraseña al usuario - Valida usando las funciones - Muestra qué criterios cumple y cuáles no - Indica si la contraseña es segura o no Pista: Usa `Character.isUpperCase()`, `Character.isLowerCase()`, `Character.isDigit()`

Ejercicio Práctico

Difícil

Números Perfectos

Un número perfecto es aquel que es igual a la suma de sus divisores propios (excluyendo el propio número). Ejemplo: 6 es perfecto porque 6 = 1 + 2 + 3 Crea estas funciones: 1. `sumaDivisores(n)`: Devuelve la suma de los divisores propios de n 2. `esPerfecto(n)`: Devuelve true si n es perfecto 3. `mostrarDivisores(n)`: Muestra por pantalla los divisores de n 4. `encontrarPerfectos(limite)`: Encuentra todos los números perfectos hasta el límite En el main: - Solicita un límite al usuario - Encuentra y muestra todos los números perfectos hasta ese límite - Para cada número perfecto, muestra sus divisores Nota: Los primeros números perfectos son: 6, 28, 496, 8128

Ejercicio Práctico

Difícil

Torre de Hanoi (Recursivo)

La Torre de Hanoi es un problema clásico de recursividad. Tienes 3 torres y n discos de diferentes tamaños. Los discos empiezan en la torre A y debes moverlos a la torre C, siguiendo estas reglas: 1. Solo puedes mover un disco a la vez 2. Un disco más grande nunca puede estar sobre uno más pequeño 3. Puedes usar la torre B como auxiliar Crea una función recursiva `hanoi(n, origen, destino, auxiliar)` que: - Recibe el número de discos y los nombres de las torres - Muestra los movimientos necesarios para resolver el puzzle Pista: El caso base es cuando n = 1 (mover directamente). Para n > 1: 1. Mover n-1 discos de origen a auxiliar (usando destino como auxiliar) 2. Mover el disco más grande de origen a destino 3. Mover n-1 discos de auxiliar a destino (usando origen como auxiliar) Ejemplo con 3 discos: Mover disco de A a C Mover disco de A a B Mover disco de C a B Mover disco de A a C Mover disco de B a A Mover disco de B a C Mover disco de A a C

Ejemplo Guiado

Medio

Sobrecarga: Calculadora de Áreas

Crea un programa con funciones sobrecargadas para calcular áreas: 1. `calcularArea(radio)` - Área de un círculo: π × r² 2. `calcularArea(lado)` - Área de un cuadrado: lado² - Debe recibir un parámetro adicional para distinguir (por ejemplo, un String "cuadrado") 3. `calcularArea(base, altura)` - Área de un rectángulo: base × altura 4. `calcularArea(base, altura, tipo)` - Área de un triángulo: (base × altura) / 2 - tipo puede ser "triangulo" En el main: - Muestra un menú con las opciones - Solicita los datos necesarios - Llama a la función apropiada - Muestra el resultado Requisitos: - Todas las funciones deben devolver un double - Usa sobrecarga (mismo nombre, diferentes parámetros) - El menú debe ser claro y fácil de usar

Practica con el IDE

Escribe tu solución directamente en el editor y pulsa Ejecutar: el programa se compila y se prueba con varios casos de prueba, algunos ocultos. Tu programa lee los datos de la entrada estándar con Scanner, así que funciona con cualquier valor.

☕JavaNúmeros primos con una funciónMedio

Completa la función esPrimo(int n) y úsala para mostrar, separados por espacios, todos los números primos desde 2 hasta el número leído.

⏳

Primos hasta 10

⏳

Primos hasta 20

⏳

Test oculto #3

0/3 tests pasados

☕JavaFactorial recursivoMedio

Implementa la función recursiva factorial(int n) que devuelva n! como long. El programa muestra 'n! = resultado'. Recuerda que 0! = 1.

⏳

5! = 120

⏳

0! = 1

⏳

Test oculto #3

0/3 tests pasados

Introducción a las Funciones

Problema del código repetido

Conceptos Básicos de Funciones

Ejemplo: Código Repetido

Solución: Usar una Función

Ubicación de las funciones

Concepto de Función

Sintaxis General

Convención de Nombres (Camel Case)

Terminología Importante

Llamada a la función

Prototipo de la función

Cuerpo de la función

Definición de una función

Ventajas de Usar Funciones

Flujo de Ejecución

Funciones vs Métodos

Ámbito de las Variables

Ámbito de variables

Variables de Bloque

Paso de Información a una Función

Valores en la Llamada

Parámetros de Entrada

Sintaxis con Múltiples Parámetros

Paso de Parámetros por Valor

Importante: Los cambios no afectan al original

Valor Devuelto por una Función

La Instrucción return

Sintaxis General

Cuándo usar return

Ejemplo: Función Suma

Ejemplos con Diferentes Tipos de Retorno

Buenas prácticas con return

Sobrecarga de Funciones

Reglas de la sobrecarga

Ejemplo: Funciones Suma Sobrecargadas

Más Ejemplos de Sobrecarga

Sobrecarga en la API de Java

Recursividad

Caso Base

Esquema General

Principios de la recursividad

Ejemplo: Factorial

Implementación

Traza de Ejecución

Más Ejemplos de Recursividad

Consideraciones sobre recursividad

Ejercicios Prácticos

Calculadora con Funciones

Validación de Contraseñas

Números Perfectos

Torre de Hanoi (Recursivo)

Sobrecarga: Calculadora de Áreas

Practica con el IDE

¿Has terminado este tema?