Cómo instalar el JDK 15 (en Windows, macOS y Ubuntu) y empezar a programar en Java

El kit de desarrollo de Java (JDK), cuyo nombre oficial es «Java Platform Standard Edition» o «Java SE», es necesario para escribir y ejecutar programas Java.

Actualmente, el OpenJDK desarrollado por Oracle y la comunidad Java (@ https://openjdk.java.net/) proporciona una implementación de referencia oficial del JDK gratuita y de código abierto.

Este artículo se basa en el JDK de Oracle (@ https://www.oracle.com/java/) (debido a su legado), que es gratuito para uso personal y de desarrollo pero ya no lo es para uso comercial.

Versiones del JDK

Referencia: «Historia de las versiones de Java» @ https://en.wikipedia.org/wiki/Java_version_history.

  1. JDK Alpha y Beta (1995): Sun Microsystem anunció Java el 23 de septiembre de 1995.
  2. JDK 1.0 (enero de 1996): Originalmente se llamaba Oak (por el nombre del roble de la oficina de James Gosling). Se cambió el nombre a Java 1 en el JDK 1.0.2.
  3. JDK 1.1 (febrero de 1997): Introdujo el modelo de eventos AWT, la clase interna, JavaBean, JDBC y RMI.
  4. J2SE 1.2 (JDK 1.2) (diciembre de 1998): Rebautizado como «Java 2» y renombrado JDK a J2SE (Java 2 Standard Edition). También se lanza J2EE (Java 2 Enterprise Edition) y J2ME (Java 2 Micro Edition). Incluye JFC (Java Foundation Classes – Swing, Accessibility API, Java 2D, Pluggable Look & Feel, y Drag & Drop). También introdujo Collection Framework y el compilador JIT.
  5. J2SE 1.3 (JDK 1.3) (mayo de 2000): Introdujo Hotspot JVM.
  6. J2SE 1.4 (JDK 1.4) (febrero de 2002): Introdujo la sentencia assert, IO sin bloqueo (nio), API de registro, IO de imágenes, Java webstart, soporte de expresiones regulares (regex).
  7. J2SE 5.0 (JDK 5) (septiembre de 2004): Llamado oficialmente 5.0 en lugar de 1.5 (eliminando el 1.). Introdujo genéricos, autoboxing/unboxing, anotaciones, enum, varargs, bucle for-each, static import. Véase «JDK 5 New Features».
  8. Java SE 6 (JDK 6) (diciembre de 2006): Cambió el nombre de J2SE a Java SE (Java Platform Standard Edition). No hay nuevas características del lenguaje. Véase «JDK 6 New Features».
  9. Java SE 7 (JDK 7) (julio de 2011): Primera versión después de que Oracle comprara Sun Microsystem – también llamada OracleJDK. Introdujo Strings en la sentencia switch, literales enteros binarios, permitiendo guiones bajos en literales numéricos, inferencia de tipos mejorada para la creación de instancias genéricas (u operador diamante <>), captura de múltiples tipos de excepción y relanzamiento de excepciones con comprobación de tipos mejorada. Ver «JDK 7 New Features».
  10. Java SE 8 LTS (JDK 8) (marzo de 2014): Incluyó soporte para expresiones Lambda, métodos predeterminados y estáticos en interfaces, colección mejorada y tiempo de ejecución de JavaScript. También integró el subsistema de gráficos JavaFX. Véase «JDK 8 New Features».
  11. Java SE 9 (JDK 9) (21 de septiembre de 2017): Introdujo la modularización del JDK (module) bajo el proyecto Jigsaw, el Java Shell (jshell), y más. Véase «JDK 9 New Features».
  12. Java SE 10 (18.3) (JDK 10) (marzo de 2018): Introducido var para la variable local de inferencia de tipo (similar a JavaScript). Introducido el versionado de versiones basado en el tiempo con dos versiones cada año, en marzo y septiembre, denotadas como YY.M. Eliminada la herramienta de generación de encabezados nativos javah. Véase «JDK 10 New Features».
  13. Java SE 11 LTS (18.9) (JDK 11) (septiembre de 2018): Extendido var a la expresión lambda. Estandarizar el cliente HTTP en java.net.http. Soportar TLS 1.3. Limpiar el JDK y el paquete de instalación (eliminar los módulos JavaFX, JavaEE, CORBA, el motor Nashorn JavaScript obsoleto). OracleJDK ya no es gratuito para uso comercial, pero OpenJDK sigue siendo gratuito. Véase «JDK 11 New Features».
  14. Java SE 12 (19.3) (JDK 12) (marzo de 2019): Switch Expression (vista previa). Véase «JDK 12 New Features».
  15. Java SE 13 (19.9) (JDK 13) (septiembre de 2019): Switch Expression (vista previa), bloque de texto de varias líneas (vista previa). Véase «JDK 13 New Features».
  16. Java SE 14 (20.3) (JDK 14) (marzo de 2020): Registros (vista previa)
  17. Java SE 15 LTS (20.9) (JDK 15) (septiembre de 2020):
  18. «JDK» o «JRE»?

    JRE (Java Runtime), que incluye una máquina virtual Java y bibliotecas centrales, es necesario para ejecutar programas Java. JDK (Java Development Kit), que incluye JRE y las herramientas de desarrollo (como el compilador y el depurador), es necesario para escribir y ejecutar programas Java. En otras palabras, JRE es un subconjunto de JDK. Dado que se supone que va a escribir programas Java en lugar de simplemente ejecutar programas Java, debe instalar el JDK, que incluye el JRE.

    Cómo instalar el JDK en Windows

    Paso 0: Desinstalar la(s) versión(es) anterior(es) del JDK/JRE

    Le recomiendo que instale sólo el último JDK. Aunque puede instalar varias versiones de JDK/JRE simultáneamente, es un lío.

    Si ha instalado previamente versiones anteriores de JDK/JRE, desinstale TODAS ellas. Vaya a «Panel de control» ⇒ (opcional) «Programas» ⇒ «Programas y características» ⇒ Desinstale TODOS los programas que empiecen por «Java», como «Java SE Development Kit …», «Java SE Runtime …», «Java X Update …», y etc.

    Paso 1: Descargar JDK
    1. Vaya al sitio de descarga de JDK (o Java SE) @ https://www.oracle.com/java/technologies/javase-downloads.html.
    2. Debajo de «Oracle JDK», haga clic en «JDK Download».
    3. Descargue el «Windows x64 Installer» (por ejemplo, «jdk-15.0.{x}_windows-x64_bin.exe» – unos 159MB), donde {x} es un número de actualización que cambia rápidamente.
    Paso 2: Instalar JDK

    Ejecute el instalador descargado. Acepte los valores predeterminados y siga las instrucciones en pantalla para completar la instalación. Por defecto, el JDK se instala en el directorio «C:\Program Files\Java\jdk-15.0.{x}«, donde {x} denota el número de actualización.

    Inicie el «Explorador de archivos». Navegue hasta "C:\Program Files\Java" para inspeccionar los directorios. Toma nota de tu directorio instalado de JDK jdk-15.0.{x}, en concreto, del número de actualización {x} que necesitarás en el siguiente paso.

    Me referiré al directorio instalado del JDK como <JAVA_HOME>, en adelante, en este artículo (correspondiente a la variable de entorno %JAVA_HOME% en Windows o $JAVA_HOME en Unix/macOS).

    Paso 3: (OMITIR para JDK 15) Incluir el directorio «bin» de JDK en el PATH

    El Símbolo del sistema de Windows (CMD) busca programas ejecutables en el directorio actual y en los directorios listados en la variable de entorno PATH.

    Los programas de JDK (como el compilador de Java "javac.exe» y el runtime de Java "java.exe«) residen en el subdirectorio «bin» del directorio instalado de JDK. El «bin» del JDK debe añadirse en el PATH.

    Antes del JDK 15, es necesario añadir explícitamente el «bin» del JDK en el PATH. A partir del JDK 15, el proceso de instalación añade el directorio «C:\Program Files\Common Files\Oracle\Java\javapath» al PATH. El directorio «javapath» es un enlace a «javapath_target_xxxxxx«, que contiene una copia de los siguientes programas del JDK:

  • java.exe: Java Runtime
  • javac.exe: Compilador de Java
  • javaw.exe: Java Runtime for Windows Console-less
  • jshell.exe: Shell de línea de comandos de Java (desde JDK 10): un bucle de lectura-evaluación-impresión (REPL) que evalúa las declaraciones, sentencias y expresiones a medida que se introducen y muestra inmediatamente los resultados.
    • El enlace se utiliza para poder mantener varias copias (versiones) de JDK.

      Para editar la variable de entorno PATH en Windows 10:

  1. Lanza «Panel de control» ⇒ (Opcional) «Sistema y seguridad» ⇒ «Sistema» ⇒ Haz clic en «Configuración avanzada del sistema» en el panel izquierdo.
  2. Cambie a la pestaña «Avanzadas» ⇒ Haga clic en el botón «Variables de entorno».
  3. Debajo de «Variables de sistema» (el panel inferior), desplácese hacia abajo para seleccionar la variable «Ruta» ⇒ Haga clic en «Editar…».
  4. Para el nuevo Windows 10:
    Verá una TABLA que enumera todas las entradas PATH existentes (si no, vaya al siguiente paso). Haga clic en «Nuevo» ⇒ Haga clic en «Examinar» y navegue hasta el directorio «bin» de su JDK, es decir, «c:\Program Files\Java\jdk-15.0.{x}\bin«, donde {x} es el número de actualización de su instalación ⇒ Seleccione «Mover hacia arriba» para mover esta entrada hasta la PARTE SUPERIOR.
  5. Para Windows 10 más antiguo (¡Es hora de cambiar de ordenador!):
    (ATENCIÓN: ¡Lea este párrafo 3 veces antes de hacer este paso! No pulses «Aplicar» o «Aceptar» hasta que estés 101% seguro. No se puede deshacer!!)
    (Para estar seguro, copie el contenido del «Valor variable» en el Bloc de notas antes de cambiarlo!!)
    En el campo «Valor variable», APLIQUE «c:\Program Files\Java\jdk-15.0.{x}\bin» (donde {x} es el número de actualización de su instalación) DELANTE de todos los directorios existentes, seguido de un punto y coma (;) para separar el directorio bin del JDK del resto de los directorios existentes. NO ELIMINE ninguna de las entradas existentes; de lo contrario, es posible que algunas aplicaciones existentes no se ejecuten.
    Variable name : PATHVariable value : c:\Program Files\Java\jdk-15.0.{x}\bin;
  6. Debe reiniciar CMD para que la nueva configuración del entorno surta efecto.

    Paso 4: Verificar la instalación del JDK

    Lance un CMD a través de uno de los siguientes medios:

    1. Haga clic en el botón «Buscar» ⇒ Escriba «cmd» ⇒ Elija «Símbolo del sistema», o
    2. Haga clic con el botón derecho en el botón «Inicio» ⇒ ejecute… ⇒ introduzca «cmd», o
    3. Haga clic en el botón «Inicio» ⇒ Sistema Windows ⇒ Símbolo del sistema
    4. Ejecute los siguientes comandos para verificar su instalación de JDK:

      1. (Omitir para JDK 15) Emita el comando «path» para listar el contenido de la variable de entorno PATH. Comprueba que el «bin» de tu JDK está listado en el PATH
        pathPATH=c:\Program Files\Java\jdk-15.0.{x}\bin;other entries...
      2. Ejecuta los siguientes comandos para verificar que el JDK/JRE están correctamente instalados y mostrar su versión:

        // Display the JDK versionjavac -versionjavac 15.0.1// Display the JRE versionjava -versionjava version "15.0.1" 2020-10-20Java(TM) SE Runtime Environment (build 15.0.1+9-18)Java HotSpot(TM) 64-Bit Server VM (build 15.0.1+9, mixed mode, sharing)
      Paso 5: Escribe un programa Java Hello-World
      1. Crea un directorio para guardar tus trabajos, por ejemplo, «d:\myProject» o «c:\myProject«. NO guarde sus trabajos en «Escritorio» o «Documentos», ya que son difíciles de localizar. El nombre del directorio no debe contener espacios en blanco ni caracteres especiales. Utilice un nombre significativo pero corto, ya que es más fácil de escribir.
      2. Inicie un editor de texto de programación (como TextPad, NotePad++, Sublime Text, Atom). Comience con un nuevo archivo e introduzca el siguiente código fuente. Guarde el archivo como «Hello.java«, bajo su directorio de trabajo (por ejemplo, d:\myProject
        /* * First Java program to say Hello */public class Hello { // Save as "Hello.java" under "d:\myProject" public static void main(String args) { System.out.println("Hello, world!"); }}
      3. Paso 6: Compilar y ejecutar el programa Java Hola Mundo

        JavaBasics_GettingStarted.png

        Para compilar el código fuente «Hello.java«:

        1. Inicie un CMD Shell (Busque ⇒ introduzca «cmd» ⇒ seleccione «Command Prompt»).
        2. Configure la Unidad Actual a la unidad donde guardó su archivo fuente «Hello.java«.
          Si utiliza la unidad «c», sáltese este paso.
          Si utiliza la unidad «d«, introduzca «d:» como sigue:
          d:D:\xxx>
        3. Establezca el Directorio de trabajo actual en el directorio en el que guardó su archivo fuente mediante el comando cd (Cambiar directorio). Por ejemplo, suponga que su archivo fuente está guardado en el directorio «myProject«.
          cd \myProjectD:\myProject>
        4. Emita un comando dir (Listar Directorio) para confirmar que su archivo fuente está presente en el directorio actual.
          dir......xx-xxx-xx xx:xx PM 277 Hello.java......
        5. Invoca el compilador del JDK «javac» para compilar el código fuente «Hello.java
          javac Hello.java// If error message appears, correct your source code and re-compile

          La compilación se realiza con éxito si se devuelve el símbolo del sistema. En caso contrario, se mostrarán mensajes de error. Corrija los errores en su archivo fuente y vuelva a compilar. Compruebe «Errores comunes de instalación del JDK», si encuentra problemas al compilar su programa.

        6. El resultado de la compilación es una clase Java llamada «Hello.class«. Vuelve a emitir un comando dir (List Directory) para comprobar la salida.
          dir......xx-xxx-xx xx:xx PM 416 Hello.classxx-xxx-xx xx:xx PM 277 Hello.java......
        7. Para ejecutar el programa, invoca el Java Runtime «java«:

          java HelloHello, world!

          Todo lo que puede salir mal, saldrá mal: Lee «Errores comunes en la instalación del JDK».

          Paso 7: (Sólo para usuarios avanzados) Código fuente del JDK

          El código fuente del JDK se proporciona y se guarda en «<JAVA_HOME>\lib\src.zip» (o «<JAVA_HOME>\src.zip» antes de JDK 9). Te recomiendo encarecidamente que revises algunos de los archivos fuente como «String.javaMath.java«, y «Integer.java«, bajo «java\lang«, para aprender a programar a los expertos.

          Cómo instalar el JDK en macOS

          Paso 1: Comprobar si se ha preinstalado el JDK

          Para comprobar si se ha instalado el JDK, abre un «Terminal» (Busca «Terminal»; o Finder ⇒ Go ⇒ Utilidades ⇒ Terminal) y emite este comando:

          javac -version

  • Si se devuelve un número de versión del JDK (por ejemplo, JDK x.x.x), entonces el JDK ya ha sido instalado. Si la versión de JDK es anterior a la 1.8, continúe con el Paso 2 para instalar el último JDK; de lo contrario, continúe con el «Paso 3: Escribir un programa Java Hello-world».
  • Si aparece el mensaje «command not found», JDK NO está instalado. Continúe con el «Paso 2: Instalar JDK».
  • Si aparece el mensaje «Para abrir javac, necesita un runtime de Java», seleccione «Instalar» y siga las instrucciones para instalar JDK. A continuación, continúe con el «Paso 3: Escribir un programa Java Hello-world».
Paso 2: Descargar JDK
  1. Vaya al sitio de descarga de JDK (o Java SE) @ https://www.oracle.com/java/technologies/javase-downloads.html.
  2. Debajo de «Oracle JDK», haga clic en «JDK Download».
  3. Descarga el «instalador DMG de macOS» (por ejemplo, jdk-15.0.{x}_osx-x64_bin.dmg – unos 172MB, donde {x} es un número de actualización que cambia rápidamente).
Paso 3: Instalar JDK/JRE
  1. Haga doble clic en el archivo de imagen de disco (DMG) descargado. Siga las instrucciones en pantalla para instalar JDK/JRE.
  2. Expulse el archivo DMG.
  3. Para verificar su instalación, abra un «Terminal» y emita estos comandos.
    // Display the JDK versionjavac -versionjavac 15.0.{x} // Display the JRE versionjava -versionjava version "15.0.{x}"...... // Display the location of Java Compilerwhich javac/usr/bin/javac // Display the location of Java Runtimewhich java/usr/bin/java
Paso 3: Escribir un programa Java Hello-World
  1. Cree un directorio llamado «myProject» bajo su directorio «home» (Inicie «Finder» ⇒ «Go» ⇒ «Home»; Seleccione «File» ⇒ «New Folder» ⇒ «myProject«).
    En macOS/Unix, el directorio «home» del usuario actual puede ser referenciado como «~«. Por lo tanto, este nuevo directorio puede ser referenciado como «~/myProject«.
  2. Utiliza un editor de texto de programación (como Sublime Text o Atom) para introducir el siguiente código fuente y guardarlo como «Hello.java«bajo el directorio «~/myProject«.
    (Si usas el editor de texto por defecto de macOS «TextEdit» (NO se recomienda), tienes que abrir un nuevo archivo ⇒ elegir «Formato» ⇒ «Hacer texto plano» ⇒ Introducir el código fuente ⇒ Guardar como «Hello.java
    /* * My First Java program to say Hello */public class Hello { // Save as "Hello.java" under "~/myProject" public static void main(String args) { System.out.println("Hello, world from Mac!"); }}
  3. Paso 4: Compilar y ejecutar el programa Java Hola Mundo

    MacJavaCompile.png

    1. Para compilar el código fuente «Hello.java«, abre un nuevo «Terminal» («Go» ⇒ «Utilidades» ⇒ «Terminal») y emite estos comandos (como se ilustra):
      // Change Directory (cd) to where "Hello.java" residescd ~/myProject // Check if "Hello.java" exists using list (ls) commandlsHello.java ...... // Compile "Hello.java" using JDK compiler "javac"javac Hello.java// If error message appears, correct your source code and re-compile // Check for the compiled output "Hello.class"lsHello.class Hello.java ......
    2. Para ejecutar el Hello-world, invoca el Java Runtime «java» como sigue:
      java HelloHello, world from Mac!
    3. Cómo instalar el JDK en Ubuntu

      Probaremos tanto el OpenJDK (gratuito y de código abierto) como el JDK de Oracle (gratuito para uso personal y de desarrollo, pero no para producción).

      Paso 0: Comprobar si el JDK ya está instalado

      Abrir un Terminal y emitir este comando:

      $ javac -version

      Si un número de versión del JDK (por ejemplo, «javac x.x.x«) aparece, el JDK ya ha sido instalado. Puede skia la instalación y pasar a Open2.

      Paso 1a: Instalar OpenJDK

      Para eliminar OpenJDK, emita el comando:

      $ sudo apt-get purge openjdk-\*
      Paso 1b: Instalar el JDK de Oracle
      1. Ir al sitio de descarga del JDK de Oracle (Java SE) @ https://www.oracle.com/java/technologies/javase-downloads.html ⇒ En «Oracle JDK», haga clic en «JDK Download» ⇒ Seleccione el paquete «Linux x64 Compressed Archive» (por ejemplo, «jdk-15.0.{x}-linux-x64_bin.tar.gz» – 179MB).El tarball se descargará en el directorio «~/Downloads«, por defecto.
      2. Instalaremos el JDK en «/usr/local/java» (o el directorio JDK por defecto de Ubuntu /usr/lib/jvm; o /opt/java). En primer lugar, crea un directorio «java» bajo «/usr/local«. Abre un Terminal y emite estos comandos:
        $ cd /usr/local$ sudo mkdir java

        Extrae el paquete descargado (¡Comprueba el nombre del archivo descargado!)

        $ cd /usr/local/java$ sudo tar xzvf ~/Downloads/jdk-15.0.{x}-linux-x64_bin.tar.gz // x: extract, z: for unzipping gz, v: verbose, f: filename

        El JDK se extraerá en una carpeta «/usr/local/java/jdk-15.0.{x}«, donde {x} es el número de actualización.

      3. Informe al Ubuntu para que utilice este JDK/JRE:
        // Setup the location of java, javac and jshell via the "alternatives" system$ sudo update-alternatives --install "/usr/bin/java" "java" "/usr/local/java/jdk-15.0.{x}/bin/java" 1 // --install symlink name path priority$ sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/local/java/jdk-15.0.{x}/bin/javac" 1$ sudo update-alternatives --install "/usr/bin/jshell" "java/usr/local/java/jdk-15.0.{x}/bin/jshell" 1 // Use this Oracle JDK/JRE as the default$ sudo update-alternatives --set java /usr/local/java/jdk-15.0.{x}/bin/java // --set name path$ sudo update-alternatives --set javac /usr/local/java/jdk-15.0.{x}/bin/javac$ sudo update-alternatives --set jshell /usr/local/java/jdk-15.0.{x}/bin/jshell

        Los pasos anteriores configuran los enlaces simbólicos javajavacjshell en /usr/bin (que está en el PATH), que enlazan con /etc/alternatives y luego con el directorio bin del JDK.
        El sistema de «alternativas» pretende resolver la situación en la que varios programas que cumplen la misma función (Ej, diferentes versiones de JDKs). Establece enlaces simbólicos a través de /etc/alternatives para referirse a los programas reales que se van a utilizar.

        $ ls -ld /usr/bin/java*lrwxrwxrwx 1 root root xx xxx xx xx:xx /usr/bin/java -> /etc/alternatives/java...... $ ls -ld /etc/alternatives/java*lrwxrwxrwx 1 root root xx xxx xx xx:xx /etc/alternatives/java -> /usr/local/java/jdk-15.0.{x}/bin/java......// As the resultjava -> /usr/bin/java (thru PATH) -> /etc/alternatives/java -> /usr/local/java/jdk-15.0.{x}/bin/java (actual program)

        Alternativamente, se puede incluir el bin del JDK en el PATH directamente.

      4. Para verificar la instalación del JDK, emita estos comandos:
        // Show the Java Compiler (javac) version$ javac -versionjavac 15.0.{x} // Show the Java Runtime (java) version$ java -versionjava version "15.0.{x}"...... // Show the location of javac and java$ which javac/usr/bin/javac$ which java/usr/bin/java
      5. (No haga este paso – Se encarga de las «alternativas» en el paso 3. Mantenga aquí para mostrarle cómo configurar el PATH.)
        Agregar el directorio binario de JDK («bin«) al «PATH» editando «/etc/profile
        $ cd /etc$ sudo nano profile

        Agrega estas líneas al final del archivo «/etc/profile«, sustituye «{x}» por el número real:

        export JAVA_HOME=/usr/local/java/jdk-15.0.{x}export PATH=$JAVA_HOME/bin:$PATH

        Rejecuta el archivo de configuración por:

        // Refresh$ source /etc/profile // Check the new settings for JAVA_HOME and PATH$ echo $JAVA_HOME/usr/local/java/jdk-15.0.{x} $ echo $PATH/usr/local/java/jdk-15.0.{x}/bin:......
      6. Paso 2: Compilar y ejecutar un programa Java Hello-world
        1. Explorador de archivos ⇒ Inicio ⇒ Crear una nueva carpeta llamada «myProject» para guardar nuestros trabajos.
        2. Abrir el «Editor de textos» (gedit). Introduce el siguiente código fuente y guárdalo como «Hello.java» bajo el directorio «~/myProject» creado anteriormente.
          public class Hello { // To save as "Hello.java" under "~/myProject" public static void main(String args) { System.out.println("Hello, world from Ubuntu!"); }}
        3. Para compilar el programa Java de Hello-world, lanza un Terminal y emite estos comandos:
          // Change directory to where the source code resides$ cd ~/myProject // List the contents of current directory. Check for "Hello.java"$ ls...... Hello.java ...... // Compile "Hello.java" into "Hello.class"$ javac Hello.java // Check for "Hello.class"$ ls...... Hello.class ......
        4. Ejecuta el programa Java Hello-world:
          // Run "Hello.class"$ java HelloHello, world from Ubuntu!
        5. Nota: A partir del JDK 11, puedes compilar y ejecutar el hola-mundo en un solo paso a través de:

          // Compile and Run "Hello.java" in one step without creating the ".class"$ java Hello.javaHello, world from Ubuntu!

          Editores de código fuente & IDEs para la programación en Java

          Eclipse IDE

          1. Primero necesitas instalar Eclipse. Lea «Cómo instalar Eclipse».Y >
          2. javaan luego proceder a escribir su primer programa Java. Lea «Escribir su primer programa Java con Eclipse».
          3. Eclipse le permite depurar el programa gráficamente. Lea «Depuración de programas en Eclipse».

          NetBeans IDE

          1. Primero debe instalar NetBeans. Lea «Cómo instalar NetBeans».
          2. Luego puede proceder a escribir su primer programa Java. Lea «Cómo escribir su primer programa Java con NetBeans».
          3. NetBeans le permite depurar el programa gráficamente. Lea «Depuración de programas en NetBeans».

          Visual Studio (VS) Code IDE

          Pulsa AQUÍ, busca «VS Code para programación Java»

          Sublime Text (para Windows, macOS, Linux)

          Pulsa AQUÍ, busque «Sublime Text para programación Java»

          Atom (para Windows, macOS, Linux)

          TextPad (sólo para Windows)

          Haga clic AQUÍ, busque «TextPad para programación Java».

          NotePad++ (sólo para Windows)

          Haga clic AQUÍ, busque «NotePad++ for Java Programming».

          (JDK 11 New Feature) Launch Single-Source-File

          Desde JDK 11, puede «compilar y ejecutar» un programa de un solo archivo en un solo paso, sin compilación explícita.

          1. Escriba un «Hello.java» (ver apartado anterior).
          2. Borra «Hello.class«, si existe.
          3. Puede compilar/ejecutar «Hello.java» en un solo comando de la siguiente manera:
            // Change directory to the directory containing Hello.java// Compile and Run in ONE commandjava Hello.javaHello, world!
          4. Notas:

  • Esto es aplicable a un solo archivo fuente.
  • No es necesario utilizar javac para compilar el programa.
  • Compila en memoria (sin producir un archivo .class), y ejecuta.
  • Esta función se introduce para que los principiantes aprendan Java, y para que los profesionales prueben una función de Java.
  • El nombre del archivo y el nombre de la clase no tienen por qué ser iguales.

Cómo establecer la variable de entorno JAVA_HOME

Muchas aplicaciones Java (como Tomcat) requieren que la variable de entorno JAVA_HOME se establezca en el directorio instalado del JDK.

Vea «Cómo establecer JAVA_HOME para Windows» o «Cómo establecer JAVA_HOME para macOS/Linux».

Errores comunes en la instalación de JDK

SYMPTOM: Cannot compile Java program from the CMD shell (e.g., "javac Hello.java" does not work!)ERROR MESSAGE: 'javac' is not recognized as an internal or external command, operable program or batch file.PROBABLE CAUSES: The PATH environment variable, which maintains a list of search paths for executable programs (including "javac.exe"), does not include JDK's bin directory.POSSIBLE SOLUTIONS: 1) Start a CMD shell (click "Start" button ⇒ "run..." ⇒ enter "cmd") and issue a path command: prompt> path PATH=....... 2) Check if it includes your JDK's "bin" directory. For example, suppose that your JDK is installed in "c:\program files\java\jdk-15.0.1", then PATH should include "c:\program files\java\jdk-15.0.1\bin". Otherwise, include JDK's bin directory in the PATH environment variable. Read "Step 3 of How to install JDK".

SYMPTOM: Can compile but cannot run Java program from the CMD shell (e.g., "java Hello" does not work!)ERROR MESSAGE (Post JDK 1.7): Error: Could not find or load main class XxxERROR MESSAGE (Pre JDK 1.7): Exception in thread "main" java.lang.NoClassDefFoundError: XxxPROBABLE CAUSES: 1) The Java class (in this example, Hello.class) is NOT in the current directory. 2) The CLASSPATH environment variable is set, but does not include the current directory ".".POSSIBLE SOLUTIONS: 1) Issue a "dir" command to list the contents of the current directory. Check that it contains the Java class to be run (e.g., Hello.class). You need to compile the source program (".java") to get the class file (".class"). 2) If the Java class is present in the current directory, issue a "set classpath" command to check its settings: prompt> set classpath CLASSPATH=....... If you receive the message "Environment variable CLASSPATH not defined" and your program is correct, I can't help you here. Otherwise, if the CLASSPATH is defined, for beginner, I suggest that you remove the CLASSPATH environment variable. From "Control Panel" ⇒ System ⇒ (Vista only) Advanced system settings ⇒ Switch to "Advanced" tab ⇒ Environment Variables ⇒ System variables (and also User variables) ⇒ Select variable "CLASSPATH" ⇒ Delete (Delete from both the System variables and User variables) 3) (For Advanced Users Only) If CLASSPATH is not set, it is defaulted to the current directory. However, if CLASSPATH is set, the current directory is NOT implicitly included. You can include the current directory (denoted by a single dot ".") in front of the existing class-paths. Read "Java Applications and Environment Variable" for more discussion on CLASSPATH.

SYMPTOM: Can compile but cannot run the Hello-world program (e.g., "java Hello" does not work!)ERROR MESSAGE (Post JDK 1.7): Error: Main method not found in class Hello.POSSIBLE SOLUTIONS: Check whether there is a main() method in your program, and the signature of your main() as shown in the error message.

(Avanzado) Archivos JAR externos y bibliotecas nativas

Notas: Esta sección es aplicable a JDK anteriores a JDK 9. JDK 9 introduce un nuevo nivel llamado «módulo» encima de paquete, y archivos «jmod» para módulos Java. Necesidad de revisar esta sección para JDK 9.

Los paquetes externos de la API de Java (como Servlet API, MySQL Connector/J, JOGL, JUnit) se distribuyen a menudo en archivos JAR (Java Archive – un paquete de un solo archivo de muchas clases de Java similar a ZIP o TAR), con posibles Bibliotecas Nativas («.lib» y «.dll» en Windows, o «.a» y «.so» en Linux/macOS).

Archivos JAR externos («.jar»)

Si los archivos JAR externos no se incluyen correctamente:

  • Durante la compilación, recibirá el error de compilación «no puede encontrar el símbolo» para las clases pertenecientes a los paquetes externos.
  • Durante la ejecución, recibirá un error de ejecución «No se pudo encontrar o cargar la clase principal xxx» o «NoClassDefFoundError«.
  • Para incluir los archivos JAR externos, puede:

  1. (Antes de JDK 9) Copiar todos los archivos JAR de los paquetes externos a los directorios de extensión de Java (NO aplicable a partir de JDK 9).
    • Para Windows, el directorio de extensión del JDK se encuentra en «<JAVA_HOME>\jre\lib\ext» (e.g., «c:\Program Files\Java\jdk1.8.0_xx\jre\lib\ext«).
    • Para macOS, los directorios de extensión del JDK son «/Library/Java/Extensions» y «/System/Library/Java/Extensions«.
    • Para Ubuntu, los directorios de extensión del JDK son «<JAVA_HOME>/jre/lib/ext» (por ejemplo, «/usr/user/java/jdk1.8.0_xx/jre/lib/ext«) y «/usr/java/packages/lib/ext«.

    La ubicación de los directorios de extensión del JDK se mantiene en la propiedad del sistema de Java «java.ext.dirs«. Puedes imprimir su contenido mediante System.out.println(System.getProperty("java.ext.dirs")).

  2. También puedes incluir todos los archivos JAR en la variable de entorno CLASSPATHCLASSPATH puede contener directorios (de clases de Java) o archivos JAR (archivo de un solo fichero de clases de Java). Si establece el CLASSPATH, debe incluir también el directorio actual (denotado como «.«).
    • Para Windows, configure el CLASSPATH en Panel de control ⇒ Sistema ⇒ Configuración avanzada del sistema ⇒ Avanzado ⇒ Variables de entorno ⇒ Nuevas ⇒ En «Nombre de la variable», introduzca «CLASSPATH«. ⇒ En «Valor de la variable», introduzca «.;path1\xxx.jar;path2\yyy.jar«, donde las entradas están separadas por un punto y coma (;).
    • Para Linux y macOS: edita ~/.profile o ~/.bash_profile (o /etc/profile para la configuración de todo el sistema) para incluir la siguiente línea al final del archivo:
      export CLASSPATH=.:path1/xxx.jar:path2/yyy.jar

      Las entradas están separadas por dos puntos (:).

  3. También puedes establecer el CLASSPATH en la javacjava de la línea de comandos.mediante la opción -cp <paths> (o -classpath <paths>), por ejemplo,
    // For Windows// Compile Java source codejavac -cp .;path1\xxx.jar;path2\yyy.jar ClassName.java// Run Java classjava -cp .;path1\xxx.jar;path2\yyy.jar ClassName // For macOS and Ubuntu// Compile Java source codejavac -cp .:path1/xxx.jar:path2/yyy.jar ClassName.java// Run Java classjava -cp .:path1/xxx.jar:path2/yyy.jar ClassName
  4. Bibliotecas nativas externas («.lib», «.dll», «.a», «.so»)

    Algún paquete externo puede proporcionar bibliotecas nativas estáticas o compartidas en forma de «.lib» (Librería estática de Windows), «.dll» (biblioteca de enlace dinámico de Windows), «.a» (biblioteca estática (de archivo) de Unix), o «.so» (biblioteca de objetos compartidos de Unix).

    Las bibliotecas nativas deben mantenerse en un directorio accesible a través de la propiedad de JRE «java.library.path«, que normalmente pero no necesariamente incluye todos los directorios de la variable de entorno PATH.

    Las bibliotecas nativas no intervienen en la compilación. Pero si no se incluyen correctamente durante el tiempo de ejecución, obtendrá un error de ejecución «java.lang.UnsatisfiedLinkError: no xxx in java.library.path«.

    Para incluir las bibliotecas nativas externas:

    1. Copie las bibliotecas nativas en un directorio de bibliotecas del sistema, por ejemplo, c:\windows\system32 (Windows), /usr/lib o /usr/local/lib (macOS/Unix). Puedes comprobar que el directorio está incluido en la propiedad del sistema de Java «java.library.path«, a través de System.out.println(System.getProperty("java.library.path")).
    2. También puedes establecer la ruta de la biblioteca nativa a través de la opción de línea de comandos de java, por ejemplo,
      // Run a Java programjava -Djava.library.path=xxx ClassName
    3. Eclipse/NetBeans

      Utilizar un IDE puede simplificar mucho la inclusión de paquetes externos. Lea «Eclipse How-To» o «NetBeans How-To».

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *