El método main en Java es el punto de entrada fundamental para ejecutar cualquier aplicación. Cuando lanzamos un programa Java, el sistema busca este método, que debe estar declarado como public static void main(String[] args), para saber qué código debe ejecutarse inicialmente. Por ejemplo, si dentro de este método colocamos un simple System.out.println("Hola buenos días"), al ejecutar la clase, veremos ese mensaje en la consola.
Para ejecutar un programa Java desde la línea de comandos, utilizamos el comando java seguido del nombre de la clase que contiene el método main. En versiones recientes de Java, si escribimos java prueba.java, el sistema compilará automáticamente el archivo y luego lo ejecutará. Este comportamiento es consistente en diferentes sistemas operativos como Windows, Linux o macOS, ya que el comando java invoca la máquina virtual de Java que está instalada y configurada en el sistema.
Cuando ejecutamos java sin argumentos, la máquina virtual nos indicará que necesitamos especificar qué queremos hacer, ya que por sí sola no realiza ninguna acción. Por eso, es necesario pasarle el nombre de la clase que queremos ejecutar o algún argumento especial, como -version, que muestra la versión instalada de Java.
El parámetro String[] args del método main es un array que recoge todos los argumentos que le pasamos al programa desde la línea de comandos, después del nombre de la clase. Por ejemplo, si ejecutamos java prueba hola mundo, el array args contendrá los elementos "hola" y "mundo". Para visualizar estos argumentos de forma clara, podemos usar el método Arrays.toString(args), que convierte el array en una cadena legible con los elementos separados por comas.
Veamos un ejemplo práctico para entender cómo procesar estos argumentos. Supongamos que queremos crear un programa que reciba tres argumentos: dos números y un operador (+ o -) para realizar una suma o una resta. Lo primero que debemos hacer es validar que el número de argumentos sea exactamente tres. Si no es así, mostramos un mensaje de error y terminamos la ejecución.
Luego, verificamos que el segundo argumento sea un operador válido, es decir, que sea un + o un -. Si no es ninguno de estos, también mostramos un mensaje de error y detenemos el programa. Finalmente, convertimos los dos números que recibimos como cadenas a enteros usando Integer.parseInt y realizamos la operación correspondiente según el operador.
El código para este ejemplo podría ser el siguiente:
import java.util.Arrays;
public class Args {
public static void main(String[] args) {
if (args.length != 3) {
System.out.println("Error: Debes proporcionar exactamente tres argumentos.");
return;
}
String operador = args[1];
if (!operador.equals("+") && !operador.equals("-")) {
System.out.println("Error: El operador debe ser '+' o '-'.");
return;
}
try {
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[2]);
if (operador.equals("+")) {
System.out.println(a + " + " + b + " = " + (a + b));
} else {
System.out.println(a + " - " + b + " = " + (a - b));
}
} catch (NumberFormatException e) {
System.out.println("Error: Los dos primeros argumentos deben ser números enteros.");
}
}
}
Con este programa, si ejecutamos java Args 3 + 5, la salida será 3 + 5 = 8. Si en cambio ejecutamos java Args 3 - 5, veremos 3 - 5 = -2. Si no cumplimos con el formato esperado, el programa nos indicará el error correspondiente.
Este sistema de argumentos es muy flexible y nos permite controlar el comportamiento de nuestras aplicaciones sin necesidad de modificar el código ni recompilar. Podemos diseñar nuestros propios formatos y convenciones para interpretar estos parámetros y así hacer programas más dinámicos y adaptables a diferentes situaciones. En definitiva, String[] args es una herramienta esencial para pasar información desde fuera a nuestras aplicaciones Java.