Java Language
Compilador de Java - 'javac'

Observaciones

El comando 'javac' - empezando

Ejemplo simple

Suponiendo que el "HelloWorld.java" contiene la siguiente fuente de Java:

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

(Para obtener una explicación del código anterior, consulte Cómo comenzar con el lenguaje Java ).

Podemos compilar el archivo anterior usando este comando:

$ javac HelloWorld.java 

Esto produce un archivo llamado "HelloWorld.class", que luego podemos ejecutar de la siguiente manera:

$ java HelloWorld
Hello world!

Los puntos clave a tener en cuenta en este ejemplo son:

1. El nombre de archivo de origen "HelloWorld.java" debe coincidir con el nombre de la clase en el archivo de origen ... que es HelloWorld . Si no coinciden, obtendrá un error de compilación.
2. El nombre de archivo de bytecode "HelloWorld.class" corresponde al nombre de clase. Si tuviera que cambiar el nombre de "HelloWorld.class", obtendría un error cuando intentara ejecutarlo.
3. Al ejecutar una aplicación Java utilizando java , debe proporcionar el nombre de clase NO el nombre de archivo de bytecode.

Ejemplo con paquetes

El código Java más práctico utiliza paquetes para organizar el espacio de nombres para las clases y reducir el riesgo de colisión accidental de nombres de clases.

Si quisiéramos declarar la clase HelloWorld en un paquete, llame a com.example , el "HelloWorld.java" contendría la siguiente fuente Java:

package com.example;

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

Este archivo de código fuente necesita almacenarse en un árbol de directorios cuya estructura corresponde a la denominación del paquete.

.    # the current directory (for this example)
|
 ----com
     |
      ----example
          |
           ----HelloWorld.java

Podemos compilar el archivo anterior usando este comando:

$ javac com/example/HelloWorld.java 

Esto produce un archivo llamado "com / example / HelloWorld.class"; es decir, después de la compilación, la estructura del archivo debería verse así:

.    # the current directory (for this example)
|
 ----com
     |
      ----example
          |
           ----HelloWorld.java
           ----HelloWorld.class

Luego podemos ejecutar la aplicación de la siguiente manera:

$ java com.example.HelloWorld
Hello world!

Los puntos adicionales a tener en cuenta en este ejemplo son:

1. La estructura del directorio debe coincidir con la estructura del nombre del paquete.
2. Cuando ejecuta la clase, se debe proporcionar el nombre completo de la clase; es decir, "com.example.HelloWorld" no "HelloWorld".
3. No es necesario compilar y ejecutar código Java desde el directorio actual. Solo lo estamos haciendo aquí para ilustrar.

Compilando múltiples archivos a la vez con 'javac'.

Si su aplicación consta de varios archivos de código fuente (y la mayoría lo hace), puede compilarlos uno por uno. Alternativamente, puede compilar varios archivos al mismo tiempo enumerando las rutas de acceso:

$ javac Foo.java Bar.java

o usando la funcionalidad de comodín de nombre de archivo de su shell de comandos ....

$ javac *.java
$ javac com/example/*.java
$ javac */**/*.java #Only works on Zsh or with globstar enabled on your shell

Esto compilará todos los archivos fuente de Java en el directorio actual, en el directorio "com / example", y recursivamente en directorios secundarios respectivamente. Una tercera alternativa es proporcionar una lista de nombres de archivos de origen (y opciones del compilador) como un archivo. Por ejemplo:

$ javac @sourcefiles

donde el archivo sourcefiles contiene:

Foo.java
Bar.java
com/example/HelloWorld.java

Nota: compilar código como este es apropiado para proyectos pequeños de una sola persona y para programas únicos. Más allá de eso, es recomendable seleccionar y utilizar una herramienta de compilación Java. Alternativamente, la mayoría de los programadores usan un IDE de Java (por ejemplo, NetBeans , eclipse , IntelliJ IDEA ) que ofrece un compilador integrado y la construcción incremental de "proyectos".

Opciones 'javac' usadas comúnmente

Aquí hay algunas opciones para el comando javac que probablemente sean útiles para usted.

• La opción -d establece un directorio de destino para escribir los archivos ".class".
• La opción -sourcepath establece una ruta de búsqueda de código fuente.
• La opción -cp o -classpath establece la ruta de búsqueda para encontrar clases externas compiladas previamente. Para obtener más información sobre el classpath y cómo especificarlo, consulte el tema de Classpath .
• La opción -version imprime la información de la versión del compilador.

Una lista más completa de las opciones del compilador se describirá en un ejemplo separado.

Referencias

La referencia definitiva para el comando javac es la página de manual de Oracle para javac .

Compilando para una versión diferente de Java

El lenguaje de programación Java (y su tiempo de ejecución) ha sufrido numerosos cambios desde su lanzamiento desde su lanzamiento público inicial. Estos cambios incluyen:

• Cambios en la sintaxis y semántica del lenguaje de programación Java.
• Cambios en las API proporcionadas por las bibliotecas de clases estándar de Java.
• Cambios en el conjunto de instrucciones Java (bytecode) y el formato de archivo de clase.

Con muy pocas excepciones (por ejemplo, la palabra clave enum , los cambios en algunas clases "internas", etc.), estos cambios son compatibles con versiones anteriores.

• Un programa Java que se compiló usando una versión anterior de la cadena de herramientas de Java se ejecutará en una versión más reciente de la plataforma Java sin recompilación.
• Un programa Java que se escribió en una versión anterior de Java se compilará con éxito con un nuevo compilador de Java.

Compilando Java antiguo con un compilador más nuevo

Si necesita (volver a compilar) el código Java más antiguo en una plataforma Java más nueva para ejecutarlo en la plataforma más nueva, por lo general, no necesita dar ninguna marca de compilación especial. En algunos casos (por ejemplo, si ha usado enum como identificador), puede usar la opción -source para deshabilitar la nueva sintaxis. Por ejemplo, dada la siguiente clase:

public class OldSyntax {
    private static int enum;  // invalid in Java 5 or later
}

se requiere lo siguiente para compilar la clase utilizando un compilador Java 5 (o posterior):

$ javac -source 1.4 OldSyntax.java

Compilando para una plataforma de ejecución anterior

Si necesita compilar Java para que se ejecute en plataformas Java más antiguas, el método más simple es instalar un JDK para la versión más antigua que necesita admitir y usar el compilador de JDK en sus compilaciones.

También puede compilar con un compilador de Java más nuevo, pero los hay complicados. En primer lugar, hay algunas condiciones previas importantes que deben cumplirse:

• El código que está compilando no debe usar construcciones del lenguaje Java que no estaban disponibles en la versión de Java que está seleccionando.
• El código no debe depender de clases Java estándar, campos, métodos, etc. que no estuvieran disponibles en las plataformas anteriores.
• Las bibliotecas de terceros de las que depende el código también deben construirse para la plataforma más antigua y estar disponibles en tiempo de compilación y tiempo de ejecución.

Dado que se cumplen las condiciones previas, puede volver a compilar el código para una plataforma anterior utilizando la opción -target . Por ejemplo,

$ javac -target 1.4 SomeClass.java

compilará la clase anterior para producir códigos de bytes que sean compatibles con Java 1.4 o posterior JVM. (De hecho, el -source opción implica una compatibles -target , por lo javac -source 1.4 ... tendría el mismo efecto. La relación entre -source y -target se describe en la documentación de Oracle.)

Una vez dicho esto, si usted utiliza simplemente -target o -source , usted seguirá siendo compilando contra las bibliotecas de clases estándar proporcionados por JDK del compilador. Si no tiene cuidado, puede terminar con clases con la versión correcta de bytecode, pero con dependencias en las API que no están disponibles. La solución es usar la opción -bootclasspath . Por ejemplo:

$ javac -target 1.4 --bootclasspath path/to/java1.4/rt.jar SomeClass.java

Se compilará contra un conjunto alternativo de bibliotecas de tiempo de ejecución. Si la clase que se está compilando tiene dependencias (accidentales) en las bibliotecas más nuevas, esto le dará errores de compilación.