Saltar al contenido principal

Método main

En Java, el método main es el punto de entrada de cualquier aplicación que se ejecuta en la máquina virtual de Java. Este método es especial porque es el que la máquina virtual de Java busca para iniciar la ejecución del programa.

Aquí tienes la estructura básica del método main en Java:

public static void main(String[] args) {
    // Código que se ejecutará al iniciar el programa
}

Veamos cada una de las partes en detalle:

  • La palabra clave public significa que el método es accesible desde cualquier otra clase. La JVM necesita acceso a este método para poder iniciar el programa, por lo que debe ser public.
  • static indica que el método main pertenece a la clase, en lugar de a una instancia de la clase. Esto es importante porque permite que la JVM ejecute el método sin tener que crear una instancia de la clase que lo contiene. En otras palabras, puedes ejecutar el método main sin crear un objeto de la clase.
  • void significa que el método no devuelve ningún valor. El método main solo ejecuta el código dentro de él y no necesita devolver ningún resultado.
  • main es simplemente el nombre del método. Es el nombre que la JVM busca como punto de entrada en el programa.
  • String[] args es un parámetro del método, un vector de cadenas (String). Este parámetro permite que se pasen argumentos desde la línea de comandos cuando se ejecuta el programa. Por ejemplo, si ejecutas java MiPrograma hola mundo, args contendrá dos elementos: ["hola", "mundo"]. Aunque no es obligatorio utilizar este parámetro, es muy útil para recibir entradas externas al programa.

Aquí tienes un ejemplo simple de un programa en Java con un método main:

public class App {
    public static void main(String[] args) {
        System.out.println("¡Hola, mundo!");
    }
}

¿Dónde definir el método main?​

Puedes tener varios métodos main en diferentes clases dentro del mismo proyecto, pero solo una de las clases puede utilizarse como el punto de entrada principal en cada ejecución.

Generalmente se crea una clase de nombre App o Main que se utiliza únicamente para iniciar el programa y desde ahí ejecutar las instrucciones necesarias.

Simplificación del método main​

A partir de Java 25, como parte de la característica Unnamed Classes and Instance Main Methods, se ha introducido una simplificación del método main para que, en casos sencillos, no haya que escribir tanto texto obligatorio.

La mejora permite dos cosas importantes:

  1. Uso de main como método de instancia, es decir, no necesariamente static.
  2. Archivos fuente "simples" sin declarar explícitamente una clase (un source file simple).

Gracias a ello, para programas muy simples (por ejemplo un típico Hola mundo) ya no hace falta escribir:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hola mundo!");
    }
}

Se puede reducir a algo como:

void main() {
    System.out.println("Hola mundo!");
}

O incluso, en un archivo "compacto" usando println directamente:

void main() {
    println("Hola mundo!");
}

¿Cómo funciona por debeajo?​

Para que esto sea posible, se han definido reglas nuevas (como parte del JEP 512) para el protocolo de lanzamiento (launch protocol) y el tratamiento de soure files simples.

Aquí los puntos clave:

  • Si el archivo fuente no declara una clase, el compilador lo trata como una clase implícita que engloba los métodos y campos escritos en el archivo.
  • Esta "clase implícita" es final, sin nombre (no se puede referenciar desde afuera), no puede extender otras clases (más allá de Object), etc.
  • Para decidir qué main invocar, el launcher (la parte del sistema Java que inicia la aplicación) sigue una jerarquía de métodos posibles (se invoca el primero que encuentre en ese orden):
    • static void main(String[] args) (visibilidad no privada)
    • static void main() (sin parámetros)
    • void main(String[] args) (método de instancia)
    • void main() (método de instancia, sin parámetros)
  • Si el main elegido es un método de instancia, el launcher instanciará automáticamente la clase implicada (con su constructor por defecto) para luego invocar el main de instancia.
  • En archivos simples (sin clase explícita), también se pueden importar automáticamente ciertos métodos de consola (por ejemplo println, readln) para hacer aún más terso el código.

Reglas, limitaciones y estado actual​

  • Estas mejoras están disponibles como características en preview en Java 21, 22, 23 y 24, y fueron pasadas a stable en la versión 25.
  • Si se quiere usar estas características, hay que compilar/ejecutar con los flags correspondientes (--enable-preview, --source, etc.)
  • Estas simplificaciones están pensadas principalmente para programas pequeños, educativos, scripts o prototipos, no para aplicaciones grandes donde ya necesitas estructuración, clases, modularidad, etc.
  • Aunque la nueva flexibilidad existe, el antiguo estilo (public static void main(String[] args)) sigue siendo válido y totalmente soportado, para compatibilidad con código existente.
  • Algunas reglas de visibilidad: el main no puede ser private, debe tener visibilidad no privada (p. ej. public, protected o “por defecto”).
  • En casos con múltiples clases, o cuando quieres interoperar con otras clases, módulos, etc., muchos de los mecanismos tradicionales siguen siendo necesarios. La simplificación es más para los primeros pasos.

Motivación de esta novedad​

Los diseñadores de Java querían:

  • Bajar la barrera de entrada para nuevos programadores, reduciendo el “ceremonial” que les confunde inicialmente (clasificación de clases, public, static, String[] args, etc.).
  • Permitir que los ejemplos básicos (Hola mundo!, actividades educativas, scripts simples) sean más concisos y parecerse más a otros lenguajes que no requieren tanto boilerplate.
  • Hacer un on-ramp (una vía de entrada suave) para que los programadores comiencen con lo esencial y luego vayan adoptando estructuras más complejas cuando lo necesiten.