Dominando los Métodos en Java: Creación, Invocación y Abstracción

Un método en Java es un conjunto de sentencias agrupadas para realizar una operación. Cuando llamas a System.out.println(), por ejemplo, el sistema ejecuta varias sentencias internamente para mostrar un mensaje en consola.

En esta guía aprenderás a crear tus propios métodos con o sin valor de retorno, invocarlos con o sin parámetros, y aplicar la abstracción de métodos en el diseño de programas.

Creación de un Método

La sintaxis básica de un método es:

modificador tipoRetorno nombreMétodo (ListaParámetros) {
    // cuerpo del método
}

Componentes:

• modificador: Define el tipo de acceso (public, private, protected, static, etc.). Es opcional.
• tipoRetorno: Tipo de dato que devuelve el método (void si no devuelve nada).
• nombreMétodo: Identificador del método. Junto con la lista de parámetros forma la firma del método.
• ListaParámetros: Tipo, orden y número de parámetros. Opcional; un método puede tener cero parámetros.
• cuerpo del método: Sentencias que definen qué hace el método.

Ejemplo: Método que retorna el mínimo de dos enteros

/** Retorna el mínimo entre dos números */
public static int minFunction(int n1, int n2) {
    int min;
    if (n1 > n2)
        min = n2;
    else
        min = n1;
    return min;
}

Invocación de Métodos

Para usar un método, debe ser llamado. Hay dos formas:

• Método que retorna un valor: int resultado = suma(6, 9);
• Método void (no retorna valor): System.out.println("Hola"); — se usa como una sentencia terminada en punto y coma.

Cuando un programa invoca un método, el control pasa al método llamado. Este devuelve el control al invocador cuando:

1. Se ejecuta una sentencia return.
2. Se alcanza la llave de cierre del método.

Ejemplo Completo: Definición y Llamada

public class ExampleMinNumber {
    public static void main(String[] args) {
        int a = 11;
        int b = 6;
        int c = minFunction(a, b);
        System.out.println("Valor Mínimo = " + c);
    }

    /** Retorna el mínimo de dos números */
    public static int minFunction(int n1, int n2) {
        int min;
        if (n1 > n2) min = n2;
        else min = n1;
        return min;
    }
}

Salida: Valor Mínimo = 6

La Palabra Clave void

Permite crear métodos que no retornan valor. Una llamada a un método void debe ser una sentencia completa:

public class ExampleVoid {
    public static void main(String[] args) {
        methodRankPoints(255.7); // llamada a método void
    }

    public static void methodRankPoints(double points) {
        if (points >= 202.5) {
            System.out.println("Rank:A1");
        } else if (points >= 122.4) {
            System.out.println("Rank:A2");
        } else {
            System.out.println("Rank:A3");
        }
    }
}

Salida: Rank:A1

Paso de Parámetros por Valor

En Java, los argumentos se pasan siempre por valor. Al invocar un método, se copia el valor del argumento en el parámetro. Los cambios dentro del método no afectan la variable original.

Ejemplo: Intercambio (swap) por valor

public class SwappingExample {
    public static void main(String[] args) {
        int a = 30;
        int b = 45;
        System.out.println("Antes de intercambiar: a = " + a + ", b = " + b);

        swapFunction(a, b);

        System.out.println("Después de intercambiar (fuera): a = " + a + ", b = " + b);
    }

    public static void swapFunction(int a, int b) {
        System.out.println("Dentro - Antes: a = " + a + ", b = " + b);
        int c = a;
        a = b;
        b = c;
        System.out.println("Dentro - Después: a = " + a + ", b = " + b);
    }
}

Salida:

Antes de intercambiar: a = 30, b = 45
Dentro - Antes: a = 30, b = 45
Dentro - Después: a = 45, b = 30
Después de intercambiar (fuera): a = 30, b = 45

Los valores originales no cambian porque se trabaja con copias.

Sobrecarga de Métodos (Overloading)

Una clase puede tener varios métodos con el mismo nombre pero diferentes parámetros (tipo, número u orden). Esto mejora la legibilidad.

Ejemplo: Sobrecarga para int y double

public class ExampleOverloading {
    public static void main(String[] args) {
        int a = 11, b = 6;
        double c = 7.3, d = 9.4;

        int result1 = minFunction(a, b);      // versión int
        double result2 = minFunction(c, d);   // versión double

        System.out.println("Mínimo (int) = " + result1);
        System.out.println("Mínimo (double) = " + result2);
    }

    public static int minFunction(int n1, int n2) {
        return (n1 > n2) ? n2 : n1;
    }

    public static double minFunction(double n1, double n2) {
        return (n1 > n2) ? n2 : n1;
    }
}

Salida:

Mínimo (int) = 6
Mínimo (double) = 7.3

Argumentos de Línea de Comandos

Permiten pasar información al programa al ejecutarlo. Se almacenan en el array String[] args del método main.

Ejemplo

public class CommandLine {
    public static void main(String args[]) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
    }
}

Ejecución: java CommandLine esto es una prueba 200 -100

Salida:

args[0]: esto
args[1]: es
args[2]: una
args[3]: prueba
args[4]: 200
args[5]: -100

La Palabra Clave this

this es una referencia al objeto actual. Solo se usa en métodos de instancia o constructores.

Usos Principales

1. Diferenciar variables de instancia de parámetros locales cuando tienen el mismo nombre:

   class Student {
       int age;
       Student(int age) {
           this.age = age; // this.age = variable de instancia; age = parámetro
       }
   }
   

2. Invocar un constructor desde otro (invocación explícita de constructor):

   class Student {
       int age;
       Student() {
           this(20); // llama al constructor parametrizado
       }
       Student(int age) {
           this.age = age;
       }
   }
   

Ejemplo Completo

public class This_Example {
    int num = 10; // variable de instancia

    This_Example() {
        System.out.println("Ejemplo de palabra clave this");
    }

    This_Example(int num) {
        this(); // invoca constructor por defecto
        this.num = num; // asigna parámetro a variable de instancia
    }

    public void greet() {
        System.out.println("¡Bienvenido!");
    }

    public void print() {
        int num = 20; // variable local
        System.out.println("Variable local num: " + num);
        System.out.println("Variable de instancia num: " + this.num);
        this.greet(); // invoca método de la misma clase
    }

    public static void main(String[] args) {
        This_Example obj1 = new This_Example();
        obj1.print();

        This_Example obj2 = new This_Example(30);
        obj2.print();
    }
}

Argumentos Variables (Var-args) — JDK 1.5+

Permiten pasar un número variable de argumentos del mismo tipo. Se declaran con tipo... nombre (elipsis). Solo puede haber un parámetro var-args y debe ser el último.

Ejemplo

public class VarargsDemo {
    public static void main(String args[]) {
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3}); // también acepta array
    }

    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("Ningún argumento pasado");
            return;
        }
        double max = numbers[0];
        for (int i = 1; i < numbers.length; i++)
            if (numbers[i] > max) max = numbers[i];
        System.out.println("El valor máximo es " + max);
    }
}

Salida:

El valor máximo es 56.5
El valor máximo es 3.0

El Método finalize()

Se invoca justo antes de que el recolector de basura destruya un objeto. Permite liberar recursos (cerrar archivos, conexiones, etc.).

protected void finalize() {
    // código de finalización
}

Advertencia: No se garantiza cuándo (ni si) se ejecutará. Si el programa termina antes de la recolección, finalize() no se llama. En Java moderno, se prefiere try-with-resources o AutoCloseable.