Cómo ejecutar Java: compilar con javac y ejecutar con java

Compilar y luego ejecutar

Ahora que tienes un JDK instalado, ejecutar Java es un ciclo de dos pasos. A diferencia de un lenguaje de scripting, donde apuntas un intérprete a un archivo y listo, Java primero compila tu código fuente legible en bytecode y, después, un paso aparte ejecuta ese bytecode en la JVM.

Esos dos pasos se corresponden con dos herramientas de línea de comandos que vienen con el JDK:

• javac - el compilador. Lee Main.java y escribe Main.class (bytecode).
• java - el lanzador. Arranca la JVM y ejecuta el bytecode de Main.class.

Puedes ejecutar cualquier ejemplo autónomo aquí mismo en la página: el editor de abajo hace los dos pasos por ti. Pero vale la pena entender qué ocurre en tu propia máquina, porque ahí es donde viven los proyectos reales.

public class Main {
    public static void main(String[] args) {
        System.out.println("Compiled, then run.");
    }
}

Los dos comandos en tu máquina

Supongamos que tienes este código guardado como Main.java:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello from the terminal");
    }
}

Abre una terminal en la carpeta que contiene el archivo y ejecuta el compilador:

javac Main.java

Si el código compila sin problemas, javac no imprime nada y crea un archivo nuevo, Main.class, junto a tu código fuente. Ese archivo .class es el bytecode: no es texto legible y no está ligado a tu sistema operativo.

Ahora lánzalo con el comando java:

java Main

Hello from the terminal

El error más común entre principiantes está aquí: para lanzar el programa ejecutas java, no javac, y pasas el nombre de la clase sin extensión. Es java Main, nunca java Main.class ni java Main.java.

El nombre del archivo debe coincidir con la clase pública

Java impone una regla que sorprende a los recién llegados: una clase public debe vivir en un archivo con exactamente el mismo nombre, más .java. Una public class Main debe estar en Main.java. Equivócate con las mayúsculas y javac se negará a compilar.

// This is in a file called Greeting.java
public class Greeting {   // ERROR: class Greeting should be in Greeting.java... wait, it is
    public static void main(String[] args) {
        System.out.println("Hi");
    }
}

El desajuste que de verdad pilla a la gente es más sutil: nombrar el archivo greeting.java (en minúsculas) mientras la clase es Greeting, o guardar Main.java pero escribir public class Hello. El compilador informa algo como:

Main.java:1: error: class Hello is public, should be declared in a file named Hello.java

La solución es siempre la misma: haz que el nombre del archivo y el de la clase pública sean idénticos, carácter por carácter.

El atajo: ejecutar un solo archivo directamente

Desde JDK 11, puedes saltarte el paso explícito de compilación para un único archivo fuente. El comando java lo compilará en memoria y lo ejecutará de una sola vez, sin escribir ningún archivo .class en disco:

java Main.java

Esto es perfecto para experimentos rápidos y scripts pequeños. Fíjate en la diferencia de lo que pasas:

• java Main - ejecuta un Main.class ya compilado.
• java Main.java - compila y ejecuta el archivo fuente de una sola vez.

El modo de un solo archivo solo funciona cuando todo tu programa cabe en un único archivo. En cuanto repartas el código entre varias clases en varios archivos, vuelves a compilar primero con javac. Para aprender los fundamentos, el modo de un solo archivo mantiene el ciclo corto.

Pasar argumentos a tu programa

¿Recuerdas el String[] args de main? Esos son los argumentos de línea de comandos. Cualquier cosa que escribas después del nombre de la clase en el comando java acaba en ese array:

public class Main {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("No arguments given.");
        } else {
            System.out.println("First argument: " + args[0]);
            System.out.println("Total arguments: " + args.length);
        }
    }
}

En tu propia máquina le pasarías argumentos así:

java Main hello world

First argument: hello
Total arguments: 2

El editor de arriba no puede recibir argumentos de terminal, así que ejecuta la rama de «sin argumentos», pero el mismo código gestiona ambos casos. Así es como los programas Java leen la entrada pasada en el momento del arranque, mucho antes de que llegues a los archivos o a la entrada del usuario.

Leer los mensajes de error del compilador

Cuando javac rechaza tu código, te dice el archivo, la línea y qué salió mal. Aprender a leer estos mensajes es la mitad del camino para desatascarte. Aquí tienes uno clásico: un punto y coma que falta:

public class Main {
    public static void main(String[] args) {
        System.out.println("Oops")   // no semicolon
    }
}

Main.java:3: error: ';' expected
        System.out.println("Oops")
                                  ^
1 error

El acento circunflejo (^) señala dónde esperaba algo el compilador. Main.java:3 es el archivo y el número de línea. Resiste la tentación de adivinar: lee la línea, corrige la única cosa que menciona y vuelve a compilar. Los errores de compilación significan que aún no se ejecutó nada; los errores en tiempo de ejecución (que tienen otro aspecto) significan que tu programa arrancó y luego falló.

Un programa de comprobación

Ejecuta esto en el editor, o guárdalo como Main.java y haz javac Main.java y luego java Main en tu propia máquina. Si ves las tres líneas, tu cadena de herramientas funciona de principio a fin:

public class Main {
    public static void main(String[] args) {
        System.out.println("1. Java is running");

        int sum = 2 + 2;
        System.out.println("2. Two plus two is " + sum);

        String[] languages = {"Java", "Python", "JavaScript"};
        System.out.println("3. There are " + languages.length + " languages listed");
    }
}

Aquí aparecen tres cosas que conocerás pronto en detalle: una variable int, la concatenación de cadenas con + y un array con su .length. Por ahora basta con que el programa compile e imprima.

Siguiente: Sintaxis de Java

Has ejecutado unos cuantos programas, pero hemos pasado por encima de la puntuación: las llaves, los puntos y comas, public static void main y por qué cada línea se ve como se ve. La siguiente página desglosa la sintaxis de Java pieza por pieza para que la estructura deje de parecer relleno y empiece a tener sentido.