====== 00 - Preparando el entorno de trabajo ======

===== 1. IDE: IntelliJ IDEA =====

Para escribir programas no utilizamos un bloc de notas común, sino un **IDE** (Entorno de Desarrollo Integrado). Un IDE es como un "procesador de textos para programadores": un programa que nos ayuda a escribir el código, detecta errores mientras escribimos y nos permite ejecutar nuestras aplicaciones con un solo clic.

Durante este curso utilizaremos **IntelliJ IDEA**, que es una de las herramientas más utilizadas y profesionales del sector.

==== Licencia gratuita (GitHub Education) ====

Aunque la versión profesional (IntelliJ IDEA Ultimate) es de pago, podemos conseguirla gratis por ser estudiantes:

Regístrate en [[https://education.github.com/pack|GitHub Education Pack]] utilizando tu correo electrónico académico.

Una vez aprobada tu cuenta de estudiante, ve a la web de [[https://www.jetbrains.com/es-es/idea/download/|JetBrains]] y descarga IntelliJ IDEA.

Al abrirlo por primera vez, inicia sesión con tu cuenta de JetBrains vinculada a GitHub para activar la licencia Ultimate.

<note>Si tienes algún problema con la verificación de estudiante, puedes descargar la versión Community Edition, que es totalmente gratuita, aunque incluye menos herramientas adicionales.</note>

==== Crear proyectos, paquetes y archivos en IntelliJ ====

Una vez instalado el IDE, necesitamos organizar nuestro trabajo. En IntelliJ la estructura se divide en Proyectos (el contenedor principal), Paquetes (carpetas para organizar el código) y Archivos (donde escribimos los programas).

A lo largo del curso veremos tres formas distintas de crear proyectos a medida que avance nuestro aprendizaje:

=== Proyectos ===

Al principio utilizaremos el formato básico y nativo de IntelliJ. Es la opción más sencilla para empezar sin complicaciones.

  * Abre IntelliJ y selecciona **New Project** (o ve al menú **File -> New -> Project**).

  * En el panel izquierdo, selecciona **Java**.

  * Asigna un nombre a tu proyecto y elige la carpeta donde se guardará.

  * En el campo Build system, asegúrate de que esté seleccionada la opción **IntelliJ**.

  * En JDK, seleccionaremos el JDK que instalaremos más adelante (**Temurin JDK 25**).

  * Haz clic en **Create**.

<note>Más adelante en el curso aprenderemos a utilizar Maven, una herramienta que nos ayuda a gestionar la estructura de aplicaciones más complejas y a incluir librerías externas fácilmente.

En etapas más avanzadas del curso utilizaremos **Spring Initializr** para crear proyectos de **Spring Boot**.</note>

=== Paquetes (Packages) y Archivos ===

Independientemente del tipo de proyecto que utilices, el código siempre se organiza de la misma manera dentro de la carpeta fuente (habitualmente llamada **src** o **src/main/java**):

Crear un Paquete (Package): Los paquetes son carpetas que sirven para agrupar archivos relacionados y evitar que todo el código esté mezclado.

  * Haz clic derecho sobre la carpeta src (o java).

  * Selecciona **New -> Package**.

  * Escribe el nombre del paquete (por convención se escriben en minúsculas, por ejemplo: com.miempresa.miaplicacion) y pulsa Enter.

Crear un Archivo:

  * Haz clic derecho sobre el paquete que acabas de crear.

  * Selecciona **New -> tipo_archivo**. Normalmente crearemos **Java Class**, aunque durante el curso también crearemos archivos de otros tipos.

  * Escribe el nombre del archivo y pulsa Enter.
===== 2. Lenguaje: Java 25 (JDK) =====

Java es un lenguaje de programación de alto nivel de propósito general derivado de C. Fue creado por Sun Microsystems Inc. y algunas de sus características son:

  * Es un lenguaje compilado/interpretado. Aunque en esencia es un lenguaje interpretado, necesita una fase intermedia de compilación como veremos más adelante.
  * Es un lenguaje totalmente orientado a objetos.
  * Tiene una gran funcionalidad gracias a sus librerías.
  * Los programas creados con Java son independientes de la máquina, lo que hace que se puedan ejecutar en una gran variedad de equipos con diferente microprocesadores y sistemas operativos.
  * Incorpora un recolector de basura (garbage collector) que se encarga de administrar la memoria automáticamente, con lo que no es necesario destruir objetos manualmente.


Primero compila el código fuente para crear un fichero que almacena lo que se denomina **bytecode** (una especie de pseudocódigo al nivel de código máquina). Para ejecutar este //bytecode// necesitamos un "intérprete", la **Java Virtual Machine** (**JVM**). De esta forma, cualquier equipo que tenga esta //JVM// puede ejecutar los //bytecodes// generados, con lo que se pueden portar entre ordenadores con distintas arquitecturas.

==== JDK y JRE ====

Para instalar esa máquina virtual (//JVM//) y poder ejecutar aplicaciones en Java, podemos optar por dos soluciones:

  * **Java Runtime Environment** (**JRE**): Entorno de ejecución de Java. Contiene la //JVM// y otras herramientas necesarias para ejecutar las aplicaciones Java. //JRE// **no posee el compilador** ni las herramientas para desarrollar las aplicaciones Java, con lo que **solo se puede ejecutar el código, pero no desarrollarlo**.
  * **Java Development Kit** (**JDK**): Además de la //JVM//, contiene herramientas para el desarrollo de aplicaciones Java. Entre otras, tiene la herramienta **javac**, que se encarga de compilar el código escrito en Java. El //JDK// ya contiene el //JRE//.

{{ :clase:daw:prog:1eval:jdk_jre.png?400 |}}
 
Por lo tanto, para desarrollar aplicaciones Java **necesitamos tener instalado en nuestra máquina //JDK//**.

==== Versiones JDK ====

Existen varias implementaciones de JDK, cada una con características y enfoques distintos, entre las cuales destacan:

**[[https://www.oracle.com/java/technologies/downloads/|JDK]]**: Desarrollado y mantenido por Oracle. Es de uso gratuito solo para desarrollo y pruebas, pero requiere una licencia de pago para entornos de producción en versiones posteriores a Java 8. Incluye herramientas como javac, java, y jlink. Oracle lanza versiones LTS (Long-Term Support) con actualizaciones de seguridad y soporte extendido.

**[[https://openjdk.org/|OpenJDK]]**: Implementación de código abierto del JDK, liderada por Oracle pero con contribuciones de otras empresas y la comunidad. Totalmente gratuito y con actualizaciones regulares. Es la base de otras distribuciones del JDK.

**[[https://adoptium.net/es/|Temurin JDK (Adoptium)]]**: Administrado por la Fundación Eclipse a través del proyecto Adoptium. Es una de las implementaciones más populares de OpenJDK. Proporciona builds gratuitos, probados y certificados. Una de las ventajas de Temurin JDK es que cuentan con contenedores Docker oficiales, lo que facilita su implementación en entornos de desarrollo y producción.

**[[https://aws.amazon.com/es/corretto/?filtered-posts.sort-by=item.additionalFields.createdDate&filtered-posts.sort-order=desc|Amazon Corretto]]**: Distribución de OpenJDK mantenida por Amazon. Diseñada para entornos de producción con mejoras de rendimiento y estabilidad. Soporte gratuito con actualizaciones de seguridad a largo plazo.

**[[https://www.azul.com/downloads/?package=jdk#zulu|Azul Zulu JDK]]**: Distribución de OpenJDK mantenida por Azul Systems. Ofrece versiones gratuitas y de pago con soporte comercial. Disponible para diversas plataformas, incluyendo versiones específicas para IoT y tiempo real.

**[[https://bell-sw.com/libericajdk/|Liberica JDK]]**: Desarrollado por BellSoft. Compatible con todas las versiones de OpenJDK y con soporte extendido para versiones antiguas. Incluye JavaFX en su distribución completa.

Cada una de estas versiones tiene ventajas dependiendo del entorno en el que se use. Para proyectos empresariales, Temurin, Corretto y Azul Zulu son opciones populares por su estabilidad y soporte extendido. Para desarrolladores individuales, OpenJDK suele ser suficiente.

En nuestro caso, instalaremos la última versión [[https://adoptium.net/es/temurin/releases|Temurin JDK 25]].

<note warning>
A lo largo de este curso utilizaremos la **sintaxis moderna introducida en Java 25** (como el método principal simplificado ''static void main()'' o la librería ''java.io.IO'').\\ \\

Ten en cuenta que este código **no es retrocompatible con versiones anteriores de Java** (como Java 8, 11, 17 o 21). Si intentas ejecutar estos programas en un entorno configurado con un JDK antiguo, obtendrás errores de compilación. Asegúrate de tener seleccionado **JDK 25** en tu IDE.
</note>

===== 3. Asistencia por IA: GitHub Copilot y OpenCode =====

  * [[https://docs.github.com/es/copilot/how-tos/copilot-cli/set-up-copilot-cli/install-copilot-cli|GitHub Copilot CLI]]: Herramienta de asistencia por Inteligencia Artificial. Permite usar la asistencia de Copilot directamente desde la terminal del sistema. También puedes instalar el plugin de Github Copilot en IntelliJ IDEA (ve a **Settings -> Plugins**, busca **GitHub Copilot**, instálalo y conecta tu cuenta de GitHub).

  * [[https://opencode.ai/|OpenCode]]: Permite conectar modelos de lenguaje diferentes para mantener la asistencia de IA activa en el entorno de trabajo. 

===== 4. Gestor de proyectos: Apache Maven =====

Maven gestiona la estructura del proyecto, las dependencias (librerías externas) y el ciclo de compilación.

Aunque IntelliJ incluye Maven integrado por defecto, lo instalaremos para no depender del IDE. En su [[https://maven.apache.org/|web]] están las instrucciones de instalación según el Sistema Operativo usado.