# Java desde cero: instalación, sintaxis y primera aplicación

**Categoría:** Programación · **Nivel:** Inicial · **Lectura:** 17 min
**Publicada:** 2026-07-29 · **Actualizada:** 2026-07-29 · **Autoría:** Underc0de
**Versión HTML (canónica):** https://underc0de.org/guias/programacion/java-desde-cero/

## Respuesta rápida

Java es un lenguaje de programación orientado a objetos que compila a un formato intermedio llamado **bytecode**, y la **JVM** (*Java Virtual Machine*, máquina virtual de Java) es el programa que ejecuta ese bytecode en cualquier sistema operativo: por eso Java se describe como «se escribe una vez y corre en cualquier lado». Para programar necesitás el **JDK** (*Java Development Kit*, kit de desarrollo); para solo ejecutar un programa ya compilado alcanza con el **JRE** (*Java Runtime Environment*). Desde la versión 17, y también con **Java 25** —la **LTS** (*long-term support*, soporte de largo plazo) vigente—, Oracle ofrece su JDK sin costo para cualquier uso, así que la vieja fama de que «Oracle Java siempre es de pago» ya no aplica. Acá vas a instalar el JDK, entender la sintaxis básica del lenguaje, y compilar y ejecutar tu primer programa paso a paso.

## ¿Qué es Java y qué es la JVM?

**Java** es un lenguaje de programación de propósito general, orientado a objetos, creado para que un mismo programa corra sin cambios en distintos sistemas operativos. La forma en que lo logra es indirecta a propósito: cuando compilás un archivo de código fuente (el texto que escribís vos, con extensión `.java`), el resultado no es un ejecutable de Windows, Linux o macOS, sino un formato intermedio llamado **bytecode**, guardado en un archivo `.class`. Ese bytecode no lo entiende directamente ningún sistema operativo: lo entiende la **JVM** (*Java Virtual Machine*, máquina virtual de Java), un programa que sí existe en una versión distinta para cada sistema operativo y que se encarga de interpretar el bytecode y ejecutarlo ahí.

La consecuencia práctica es la que hizo famoso a Java desde los años noventa: compilás una sola vez, y ese mismo archivo `.class` corre en cualquier máquina que tenga una JVM instalada, sin volver a compilar. El costo de esa portabilidad es una capa intermedia de traducción, que hoy en día está muy optimizada y no suele ser un problema perceptible para la inmensa mayoría de las aplicaciones.

## JDK, JRE y JVM: qué necesitás instalar

Antes de instalar nada conviene tener claros los tres nombres que más se confunden al empezar, porque cada uno hace una cosa distinta y uno contiene al otro.

| Componente | Qué incluye | Para qué sirve |
| --- | --- | --- |
| **JVM** (máquina virtual) | El motor que interpreta el bytecode | Ejecutar un archivo `.class` ya compilado |
| **JRE** (entorno de ejecución) | La JVM + las bibliotecas estándar de Java | Ejecutar aplicaciones Java terminadas, sin programarlas |
| **JDK** (kit de desarrollo) | El JRE completo + el compilador `javac` y herramientas de desarrollo | Escribir, compilar y depurar tus propios programas Java |

Como esta guía es para programar, no solo para ejecutar programas ya hechos, lo que necesitás instalar es el **JDK**: trae todo lo demás incluido.

*Diagrama: de código fuente a programa en ejecución. Arriba, el flujo de tres pasos: el código fuente (`.java`, escrito por la persona programadora), compilado por `javac` a bytecode (`.class`, independiente del sistema operativo), y ejecutado con el comando `java` igual en Windows, Linux y macOS. Abajo, tres rectángulos anidados muestran la contención: el JDK incluye al JRE, y el JRE incluye a la JVM, por lo que cada capa suma exactamente lo necesario para desarrollar y no solo para ejecutar.*

## ¿Java sigue siendo gratis? Lo que cambió con las licencias de Oracle

Esta es la confusión más extendida entre quienes vuelven a Java después de un tiempo, o lo escuchan de terceros sin verificarlo: «Oracle Java es de pago». Fue cierto durante un período concreto, y dejó de serlo.

Durante varios años, usar el JDK de Oracle en producción sí requería una licencia comercial. Eso cambió con **Java 17**: desde esa versión, Oracle distribuye su propio JDK bajo términos que permiten usarlo sin costo para cualquier uso, incluida la producción, mientras esos términos sigan vigentes para esa versión concreta. Esa política se mantiene con **Java 25**, según la hoja de ruta de Oracle consultada el 29 de julio de 2026. En otras palabras: si instalás el JDK de Oracle hoy, no le debés nada a nadie por usarlo, aunque conviene revisar los términos de la versión puntual que instalás si tu proyecto es comercial y de largo plazo.

Esto no elimina la otra opción, que además es muy usada en la industria: **OpenJDK**. OpenJDK es el proyecto de código abierto que funciona como implementación de referencia del estándar de Java, publicado bajo licencia GPL. A partir de ese mismo código, distintas organizaciones arman y distribuyen sus propios instaladores: Oracle arma el suyo (Oracle JDK), y también lo hacen Eclipse Adoptium (con sus builds Temurin), Microsoft (con el Microsoft Build of OpenJDK) y Amazon (Corretto), entre otros. Todos ejecutan el mismo lenguaje y el mismo bytecode; lo que cambia es quién lo empaqueta, con qué calendario de actualizaciones y qué soporte comercial opcional ofrece.

| Aspecto | Oracle JDK | Distribuciones basadas en OpenJDK |
| --- | --- | --- |
| Quién lo distribuye | Oracle | Eclipse Adoptium, Microsoft, Amazon y otros |
| Costo de uso | Sin costo bajo los términos vigentes desde Java 17 | Sin costo, bajo licencia GPL |
| Soporte comercial extendido | Premier y Extended, de pago y opcionales | Depende de cada proveedor |
| Base de código | La misma que OpenJDK | Implementación de referencia del estándar |

> **Para esta guía, cualquiera sirve.** No importa demasiado cuál elijas: cualquier distribución basada en OpenJDK, incluido el JDK de Oracle, sirve para instalar, compilar y ejecutar los ejemplos que siguen.

## Qué versión de Java instalar: Java 25 LTS

Java publica versiones nuevas cada seis meses, pero no todas reciben el mismo nivel de soporte. Algunas se marcan como **LTS** (*long-term support*, soporte de largo plazo) y reciben actualizaciones de seguridad durante varios años; el resto son versiones intermedias de vida corta, pensadas para quien quiere probar novedades del lenguaje antes de que lleguen a una LTS.

Según la hoja de ruta de Oracle consultada el 29 de julio de 2026, **Java 25 es la LTS vigente**: tuvo disponibilidad general el **16 de septiembre de 2025**, con soporte Premier de Oracle hasta **septiembre de 2030** y soporte Extended hasta **septiembre de 2033**. La LTS anterior, **Java 21**, sigue recibiendo soporte Premier hasta **septiembre de 2028**, así que todavía es una opción razonable si estás manteniendo un proyecto que ya la usa.

Para un proyecto nuevo, la recomendación general es instalar la LTS más reciente, es decir, Java 25 al momento de escribir esta guía. Si un curso, un framework o un empleador te pide explícitamente una versión anterior, instalá esa: Java permite tener varias versiones conviviendo en la misma máquina sin conflicto, siempre que sepas cuál estás usando en cada momento.

## Cómo instalar el JDK en Windows, Linux y macOS

Instalar el JDK cambia según el sistema operativo, pero el resultado que buscás es siempre el mismo: tener los comandos `java` y `javac` disponibles desde la terminal.

### Windows

La forma más simple es descargar el instalador `.msi` desde la página oficial de descargas de Java, o instalarlo con el gestor de paquetes `winget` si tu Windows lo tiene disponible. También podés optar por una distribución basada en OpenJDK como Eclipse Temurin (Adoptium), que trae su propio instalador gráfico. En cualquiera de los tres casos, el instalador configura solo la variable de entorno `PATH`, así que después de instalar podés abrir una terminal nueva y probar directamente `java -version`.

### Linux

Acá conviene la advertencia más importante de esta sección: **los nombres de paquete varían según la distribución, y no todas las distribuciones tienen todavía el paquete de Java 25 en sus repositorios estables** al momento de escribir esto. Antes de copiar un comando `apt install` o `dnf install` de cualquier lado —incluida esta guía—, confirmá en la página oficial de descargas de Java o en el repositorio de tu distribución qué paquete corresponde a la versión que querés instalar. Si tu distribución todavía no lo tiene empaquetado, la alternativa segura es descargar el archivo comprimido del JDK desde la página oficial y descomprimirlo donde prefieras, agregando su carpeta `bin` al `PATH` manualmente.

### macOS

Para macOS, Oracle distribuye un instalador `.dmg` con soporte tanto para procesadores Intel como para Apple Silicon. También es habitual instalar Java con Homebrew usando una fórmula de alguna distribución de OpenJDK. En los dos casos, verificá después de instalar con `java -version` y `javac -version` para confirmar que la terminal encuentra la versión que instalaste.

> **Ya no hace falta tocar el PATH a mano.** En 2013, un hilo del foro de Underc0de explicaba cómo configurar manualmente la variable `PATH` en Windows para poder usar `javac`, sobre Java 6 y Windows 7. Era un paso necesario en ese momento; hoy **ya no aplica**: los instaladores actuales de Windows, Linux y macOS configuran el `PATH` automáticamente, y solo hace falta tocarlo a mano si instalaste el JDK desde un archivo comprimido, sin usar ningún instalador.

## Sintaxis básica de Java

Java es un lenguaje de **tipado estático**: cada variable tiene un tipo declarado que no cambia, y el compilador lo verifica antes de generar el bytecode. Estas son las reglas que vas a usar todo el tiempo:

- Todo el código vive dentro de una **clase**. No existen instrucciones sueltas a nivel de archivo, como sí pasa en otros lenguajes.
- Cada instrucción termina con un **punto y coma** (`;`).
- Los bloques de código (el cuerpo de una clase, un método o un condicional) van entre llaves `{ }`.
- Java distingue mayúsculas de minúsculas: `Nombre` y `nombre` son identificadores distintos.
- Los tipos primitivos más usados son `int` (números enteros), `double` (números con decimales), `boolean` (verdadero o falso) y `char` (un solo carácter). El texto (`String`) no es un tipo primitivo: es una clase, aunque se use todo el tiempo como si lo fuera.
- Los comentarios se escriben con `//` para una línea, o entre `/*` y `*/` para varias.

```java
// Variables con tipo declarado, una condición y un bucle
int edad = 20;
double promedio = 8.75;
boolean aprobado = promedio >= 6.0;

if (aprobado) {
    System.out.println("Aprobado con " + promedio);
} else {
    System.out.println("No aprobado");
}

for (int i = 1; i <= 3; i++) {
    System.out.println("Vuelta " + i);
}
```

No hace falta memorizar todo esto de una sentada: con la clase, el punto y coma, las llaves y estos cuatro tipos primitivos alcanza para escribir el primer programa completo, que es lo que sigue.

## Tu primera aplicación: Hola Mundo paso a paso

Con la sintaxis básica ya vista, este es el programa más pequeño posible en Java, explicado bloque por bloque.

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

- **`public class HolaMundo`:** declara una clase pública llamada `HolaMundo`. Esto no es arbitrario: **el archivo tiene que llamarse `HolaMundo.java`, exactamente igual que la clase pública que contiene**, con las mismas mayúsculas. Si no coinciden, `javac` rechaza la compilación.
- **`public static void main(String[] args)`:** es el método por el que la JVM empieza a ejecutar el programa. `public` lo hace visible desde afuera de la clase, `static` permite llamarlo sin crear un objeto primero, `void` indica que no devuelve ningún valor, y `String[] args` recibe los argumentos que se le pasen al programa desde la línea de comandos.
- **`System.out.println(...)`:** imprime un texto en la consola, seguido de un salto de línea. `System.out` es el flujo de salida estándar del sistema.

### Compilar y ejecutar

1. **Guardar el archivo.** Guardalo como `HolaMundo.java`, en una carpeta donde después vas a abrir la terminal.
2. **Compilar.** Ejecutá `javac HolaMundo.java`. Si no hay errores, no aparece ningún mensaje, y se genera `HolaMundo.class` en la misma carpeta.
3. **Ejecutar.** Ejecutá `java HolaMundo`, **sin** la extensión `.class`. El comando espera el nombre de la clase, no el nombre de un archivo.
4. **Ver el resultado.** La consola imprime `¡Hola, mundo!`.
5. **Si algo falla.** Verificá con `java -version` y `javac -version` que ambos comandos respondan antes de seguir buscando el error en el código.

## Errores frecuentes

- **Ejecutar con la extensión.** `java HolaMundo.class` falla. El comando `java` espera el nombre de la **clase**, sin `.class`: `java HolaMundo`.
- **Nombre de archivo y clase distintos.** Si la clase pública se llama `HolaMundo` pero el archivo es `hola.java`, `javac` no compila.
- **Confundir JDK con JRE.** Si solo instalaste un JRE (cada vez menos frecuente, porque casi todas las distribuciones actuales instalan el JDK completo) no vas a tener `javac` disponible para compilar, aunque `java` sí funcione para ejecutar programas ya compilados por otra persona.
- **Creer que Oracle Java siempre es pago.** Ya no es así desde Java 17; ver la sección de licencias más arriba.
- **Pensar que hay que configurar el `PATH` a mano siempre.** Los instaladores actuales de Windows, Linux y macOS lo hacen solos; configurarlo a mano solo hace falta si instalaste desde un archivo comprimido, sin instalador.
- **Copiar un comando `apt`/`dnf` de un tutorial sin verificar la versión.** Los nombres de paquete cambian, y no todas las distribuciones tienen ya empaquetada la última versión de Java.

## Preguntas frecuentes

**¿Cuál es la diferencia entre JDK y JRE, y cuál necesito?**
El JDK (Java Development Kit, kit de desarrollo de Java) y el JRE (Java Runtime Environment, entorno de ejecución de Java) resuelven necesidades distintas, y elegir mal entre los dos es un error común al empezar. El JRE incluye únicamente lo necesario para ejecutar un programa Java que ya fue compilado por otra persona: la JVM (máquina virtual) y las bibliotecas estándar. No incluye `javac`, el compilador, así que con un JRE podés correr aplicaciones Java pero no podés compilar tu propio código fuente. El JDK incluye todo lo del JRE y le suma el compilador `javac`, además de otras herramientas de desarrollo y depuración. Si vas a escribir y compilar programas Java —que es el objetivo de esta guía y de cualquier persona que esté aprendiendo el lenguaje— necesitás el JDK, no alcanza con el JRE. En la práctica esto simplifica la decisión: casi todas las distribuciones que se descargan hoy en día, tanto de Oracle como de OpenJDK, se instalan como JDK completo por defecto, así que en la mayoría de los casos no vas a tener que elegir entre uno y otro de forma explícita.

**¿Java sigue siendo gratis? ¿Qué cambió con las licencias de Oracle?**
Sí, Java sigue siendo gratuito, pero la afirmación merece precisión porque hubo un período real de confusión. Durante varios años, usar el JDK de Oracle en producción exigía una licencia comercial paga, y de ahí surgió la idea de que «Oracle Java es de pago» que todavía circula. Eso cambió a partir de Java 17: desde esa versión, Oracle distribuye su propio JDK bajo términos que permiten usarlo sin costo para cualquier tipo de uso, incluida la producción, mientras esos términos sigan vigentes para la versión instalada. Esa política sigue aplicando con Java 25, la LTS (long-term support, soporte de largo plazo) vigente según la hoja de ruta de Oracle consultada el 29 de julio de 2026. Además, nunca dejó de existir la alternativa de instalar una distribución basada en OpenJDK —como Eclipse Temurin, el Microsoft Build of OpenJDK o Amazon Corretto—, que son gratuitas bajo licencia GPL desde antes de ese cambio. En resumen: si instalás cualquier JDK actual, sea el de Oracle o uno basado en OpenJDK, no pagás nada por usarlo para aprender, desarrollar o poner en producción tus programas.

**¿Qué entorno de desarrollo conviene para empezar?**
Para empezar no hace falta un entorno de desarrollo integrado (IDE): con un editor de texto simple y una terminal alcanza para escribir, compilar con `javac` y ejecutar con `java` los primeros programas, que es exactamente lo que sigue esta guía. Esa fricción manual, de hecho, ayuda a entender qué hace cada comando antes de que un IDE lo automatice por vos. Cuando el código empiece a crecer, tres opciones cubren la mayoría de los casos. Visual Studio Code, con el paquete de extensiones para Java, es liviano y sirve tanto para Java como para otros lenguajes que probablemente uses después. IntelliJ IDEA, en su edición Community gratuita, está pensado específicamente para Java y ofrece autocompletado y refactorización muy maduros. Eclipse es la opción más veterana, todavía muy usada en entornos corporativos y educativos. Ninguna de las tres es una elección incorrecta: la diferencia real aparece cuando el proyecto crece y empezás a valorar la integración con herramientas de compilación, control de versiones y depuración que cada una ofrece de forma distinta.

**¿Por qué me dice que javac no se reconoce como comando en Windows?**
Ese mensaje significa que la terminal no encuentra el ejecutable `javac` en ninguna de las carpetas listadas en la variable de entorno `PATH`, aunque el JDK esté instalado en el disco. Antes de tocar nada, probá `java -version` en la misma terminal: si tampoco reconoce ese comando, el problema es que el JDK no terminó de instalarse o la terminal se abrió antes de instalarlo, así que cerrala y abrí una nueva. Si `java` sí funciona pero `javac` no, es probable que hayas instalado solo un JRE en lugar de un JDK completo, porque el JRE no incluye el compilador; revisá qué descargaste e instalá el JDK si hace falta. Si ambos comandos fallan y estás seguro de haber instalado el JDK, el instalador puede no haber agregado la carpeta `bin` del JDK al `PATH`; podés agregarla manualmente ubicando la carpeta de instalación (algo como `C:\Program Files\Java\jdk-25\bin`) y sumándola a las variables de entorno del sistema, o simplemente reinstalar usando el instalador oficial, que en la gran mayoría de los casos configura esto automáticamente.

**¿Qué diferencia hay entre Oracle JDK y OpenJDK?**
OpenJDK es el proyecto de código abierto que funciona como implementación de referencia del estándar de Java, publicado bajo licencia GPL, y es la base de código a partir de la cual se arman prácticamente todos los JDK que existen hoy, incluido el de Oracle. Oracle JDK es, específicamente, el build que Oracle compila, empaqueta y distribuye a partir de ese código, y que desde Java 17 también se puede usar sin costo para cualquier propósito bajo los términos vigentes de esa versión. La diferencia práctica más relevante no es técnica sino de quién lo distribuye y qué soporte comercial opcional hay detrás: Oracle ofrece soporte de pago Premier y Extended más allá del período estándar, mientras que otras distribuciones basadas en OpenJDK, como Eclipse Temurin, el Microsoft Build of OpenJDK o Amazon Corretto, tienen sus propios calendarios de mantenimiento y soporte según el proveedor. Para aprender el lenguaje, escribir la sintaxis básica o compilar los ejemplos de esta guía, el comportamiento es el mismo lenguaje y el mismo bytecode en cualquiera de las opciones: la elección importa más cuando el proyecto es grande y de largo plazo.

**¿Cómo ejecuto mi primer programa después de compilarlo?**
Después de compilar con `javac MiPrograma.java` vas a tener en la misma carpeta un archivo `MiPrograma.class` con el bytecode. Para ejecutarlo, usá el comando `java` seguido del nombre de la clase, sin extensión y sin la ruta del archivo: `java MiPrograma`. Es un error frecuente escribir `java MiPrograma.class`, incluyendo la extensión, porque el comando `java` no espera el nombre de un archivo sino el nombre de una clase que va a buscar entre los archivos `.class` disponibles. Para que esto funcione, tenés que estar parado en la terminal dentro de la misma carpeta donde quedó el archivo `.class`, o indicarle a `java` dónde buscar con la opción `-cp` seguida de la ruta correspondiente. Si el programa se ejecutó bien, vas a ver en la consola exactamente lo que indican tus instrucciones `System.out.println`; si en cambio aparece un error de tipo `NoClassDefFoundError` o `ClassNotFoundException`, casi siempre significa que `java` está buscando el archivo `.class` en una carpeta distinta de la que realmente está.

## Fuentes

Documentación oficial y material de la comunidad consultados para esta guía. Fecha de consulta: 29 de julio de 2026.

### Aportes de la comunidad Underc0de

1. **Underc0de, foro.** [Como compilar programas Java en la consola de comandos de Windows](https://underc0de.org/foro/java/como-compilar-programas-java-en-la-consola-de-comandos-de-windows/), por *tar3kw0rm3d*, sección Java. Explica cómo configurar el `PATH` a mano sobre Java 6 y Windows 7. Es un antecedente histórico del interés de la comunidad por Java: hoy ya no aplica, porque los instaladores actuales lo hacen solos.
2. **Underc0de, foro.** [Curso - Java desde 0](https://underc0de.org/foro/java/curso-java-desde-0/), por *iatsm*, sección Java. Es solo un enlace a un curso de terceros, sin contenido técnico propio en el hilo.

### Documentación oficial

3. **Oracle.** [Java SE Support Roadmap](https://www.oracle.com/java/technologies/java-se-support-roadmap.html). Fechas de disponibilidad y de fin de soporte de cada versión de Java.
4. **OpenJDK.** [JDK 25 project](https://openjdk.org/projects/jdk/25/). Página oficial del proyecto de la versión 25 del JDK.
5. **Oracle.** [Java downloads](https://www.oracle.com/java/technologies/downloads/). Instaladores oficiales por sistema operativo.
6. **Oracle.** [javac (manual, JDK 25)](https://docs.oracle.com/en/java/javase/25/docs/specs/man/javac.html). Referencia del compilador de Java.
7. **Oracle.** [Trail: Getting Started — Hello World](https://docs.oracle.com/javase/tutorial/getStarted/application/index.html). Tutorial oficial del primer programa en Java.
8. **Microsoft.** [Install the Microsoft Build of OpenJDK](https://learn.microsoft.com/en-us/java/openjdk/install). Guía de instalación de una distribución de OpenJDK.

## Guías relacionadas

- [API profesional con Java y Spring Boot](../api-profesional-con-java-y-spring-boot/index.md)
- [Programación orientada a objetos desde cero](../programacion-orientada-a-objetos-desde-cero/index.md)
- [Aprender programación desde cero](../aprender-programacion-desde-cero/index.md)
- [Ruta de estudio completa para aprender a programar](../ruta-de-estudio-completa-para-aprender-a-programar/index.md)

URL canónica: https://underc0de.org/guias/programacion/java-desde-cero/