====== 02.1 - Fundamentos de programación en Java ======

===== 1. Lenguajes de programación =====

Podemos clasificar los lenguajes de programación atendiendo a distintos criterios

==== Según su nivel de abstracción ====

  * **Lenguajes de bajo nivel:** Están muy cercanos al hardware. Dependen de la arquitectura de la máquina, por lo que **no son portables** (no se pueden ejecutar en otra máquina distinta a aquella para la que se programaron). A cambio, aprovechan al máximo el rendimiento del hardware.
    * **Lenguaje máquina:** Único lenguaje que comprende directamente el procesador. Formado exclusivamente por cadenas de bits (0 y 1).
    * **Lenguaje ensamblador:** Representación simbólica (mnemónicos) del código máquina. Cada arquitectura de procesador tiene su propio ensamblador.

Ejemplo de código máquina:
<sxh base>
0010 0000 1001 1001 1000 1110
</sxh>

Ejemplo de lenguaje ensamblador:
<sxh base>
MOV R1, DPL
CJNE R1, #78H, T05SEG
RET
</sxh>

  * **Lenguajes de alto nivel:** Se aproximan al lenguaje natural humano e ignoran las complejidades del hardware. Son **portables** entre distintas arquitecturas. Ejemplos: Java, Python, C#, JavaScript, PHP.

==== Según su forma de ejecución ====

  * **Lenguajes compilados:** Necesitan un programa **compilador** que traduce todo el código fuente a lenguaje máquina antes de su ejecución (ej. C, C++).

  * **Lenguajes interpretados:** Un programa **intérprete** lee y traduce el código fuente a lenguaje máquina línea a línea, en tiempo real mientras se ejecuta (ej. Python, JavaScript).


===== 2. Elementos de un lenguaje de programación =====

Hay una serie de elementos que están presentes en casi todo lenguaje de programación:

  * **Tipos de datos**: enteros, reales, cadena de caracteres...

  * **Palabras reservadas**: conjunto de palabras propias del lenguaje de programación. No pueden utilizarse, por ejemplo, para nombrar variables o constantes.

  * **Operadores**: Crean instrucciones utilizando cálculos matemáticos (operadores aritméticos), comparaciones (operadores relacionales) u operaciones lógicas (operadores lógicos).

  * **Constantes y variables**: Posiciones de memoria que almacenan los datos con los que trabaja nuestro programa. Las constantes no pueden variar a lo largo de la ejecución del programa, mientras que las variables sí.

  * **Estructuras de control**: Secuenciales, condicionales o bucles.

  * **Funciones**: Bloques de código empaquetados con una cabecera que realizan una tarea específica, lo que permite, entre otras cosas, la reutilización del código.

  * **Comentarios**: Bloques dentro del código que no se ejecutan. Su función es la de aclarar partes del programa. 


===== 3. Introducción al lenguaje Java =====

Java es un lenguaje de programación de alto nivel, de propósito general y con una sintaxis ampliamente derivada de C/C++. Fue creado originalmente por **Sun Microsystems** (actualmente propiedad de Oracle) en 1995.

Entre sus pilares fundamentales destacan:

  * **Lenguaje híbrido (compilado e interpretado):** Combina ambas técnicas mediante un proceso en dos fases:
    - **Compilación:** Traduce el código fuente (archivos ''.java'') a un código intermedio universal llamado **bytecode** (archivos ''.class'').
    - **Ejecución e interpretación:** La **Máquina Virtual de Java** (**JVM**) interpreta ese //bytecode// en la máquina de destino. Gracias a este modelo, el programa es totalmente **portable**: se puede ejecutar en cualquier sistema operativo o arquitectura que disponga de la //JVM// (*"Escríbelo una vez, ejecútalo en cualquier lugar"*).

  * **Orientación a Objetos (POO):** Salvo los tipos primitivos, todo el código se estructura en clases y objetos, lo que favorece la modularidad, el mantenimiento y la reutilización.

  * **Gran ecosistema y librerías:** Incluye una amplia biblioteca estándar (API) que proporciona herramientas listas para usar en casi cualquier tipo de desarrollo (gestión de archivos, estructuras de datos, redes, etc.).

==== Compilación y ejecución de aplicaciones Java ====

Los archivos de código fuente en Java tienen la extensión ''.java'' y su nombre **debe coincidir exactamente con la clase principal** que contienen.

<sxh java>
public class HolaMundo {

        static void main() {
                IO.println("Hola Mundo");
        }
}
</sxh>

Existen dos formas de ejecutar este programa desde la consola:

**1. Ejecución directa en un solo paso**: Ideal para pruebas rápidas. Compila en memoria y ejecuta el resultado de forma transparente:

<sxh base>
java HolaMundo.java
</sxh>

**2. Proceso tradicional en dos pasos (entornos de producción):**

1. Compilar el código fuente a bytecode (genera el archivo ''HolaMundo.class''):

<sxh base>
javac HolaMundo.java
</sxh>

2. Ejecutar el bytecode compilado en la JVM:

<sxh base>
java HolaMundo
</sxh>

<note tip>
Al ejecutar con el comando ''java'' un archivo ya compilado, **no debemos poner la extensión .class**, solo el nombre de la clase. Esta ejecución es más rápida porque no requiere recompilar el código.
</note>

==== Generación de archivos .class ====

El compilador de Java genera **un archivo .class por cada clase definida** en nuestro código fuente, independientemente de si están en el mismo archivo ''.java'' o en archivos separados.

<sxh java>
public class HolaMundo2 {

    static void main() {
        IO.println("Hola Mundo 2");
    }
}

class HolaMundo3 {

    static void main() {
        IO.println("Hola Mundo 3");
    }
}
</sxh>

Al ejecutar ''javac HolaMundo2.java'', se generarán dos archivos independientes: ''HolaMundo2.class'' y ''HolaMundo3.class''.

<note important>
**Regla de visibilidad de archivos:** Un archivo ''.java'' solo puede contener **una clase pública (public)** como máximo, y el nombre del archivo debe coincidir exactamente con el nombre de dicha clase.
</note>
==== Estructura de una aplicación Java ====


Vamos a ver la estructura del ejemplo anterior //HolaMundo.java//:

<sxh java>
public class HolaMundo {

        static void main() {
                IO.println("Hola Mundo");
        }
}
</sxh>

  * **''public class HolaMundo''**: Define la clase. Todo código en Java debe residir dentro de una clase.

  * **Llaves (''{'' ''}'')**: Delimitan los bloques de código (clases, métodos, bucles, etc.).

  * **''static void main()''**: Es el **método de entrada** (punto de inicio) de la aplicación. La JVM busca y ejecuta automáticamente este método al arrancar el programa.

  * **''IO.println(...)''**: Instrucción que imprime el texto indicado por pantalla y añade un salto de línea.

==== Secuencia de instrucciones ====

Las instrucciones se ejecutan secuencialmente (de arriba a abajo) y **deben terminar obligatoriamente con punto y coma (;)**.

<sxh java>
static void main() {
    IO.println("Primera instrucción");
    IO.println("Segunda instrucción");
}
</sxh>

==== Indentación del código ====

Aunque Java no obliga a sangrar el código para que compile (a diferencia de Python), la **indentación es fundamental** para garantizar la legibilidad del proyecto. Se recomienda usar **4 espacios** por cada nivel de anidamiento.

Ejemplo con correcta indentación:
<sxh java>
public class HolaMundo {
    
    static void main() {
        IO.println("Código fácil de leer");
    }
}
</sxh>

==== Comentarios ====

Los comentarios son anotaciones dentro del código fuente que el compilador ignora por completo. Su objetivo es explicar la lógica del programa, añadir notas aclaratorias o generar documentación técnica.

En Java podemos escribir comentarios de tres formas:

  * **Comentarios de una sola línea:** Empiezan con dos barras (''<nowiki>//</nowiki>'').

  * **Comentarios de bloque (multilínea):** Se encierran entre ''<nowiki>/*</nowiki>'' y ''<nowiki>*/</nowiki>''.

  * **Comentarios de documentación (JavaDoc):** Se encierran entre ''<nowiki>/**</nowiki>'' y ''<nowiki>*/</nowiki>'' para generar documentación técnica en HTML.

<sxh java>
/**
 * Comentario de documentación (JavaDoc).
 * Muestra información sobre la clase o el autor.
 */
public class HolaMundo {

    static void main() {
        /*
         * Comentario de bloque o multilínea.
         * Útil para detallar algoritmos o bloques
         * de código complejos.
         */
        
        // Comentario de una línea: explica la instrucción siguiente
        IO.println("Hola mundo");
    }
}
</sxh>

<note important>
**No abuses de los comentarios:** Como indica Robert C. Martin en su libro //Código limpio// (Clean Code), el mejor comentario es el que no hace falta escribir. Es preferible escribir código expresivo y autoexplicativo (utilizando buenos nombres de variables y métodos) antes que llenar el programa de comentarios redundantes.
</note>

<note important>
**Limpia el código "muerto":** Durante la fase de desarrollo es habitual comentar bloques de código para realizar pruebas. Es importante eliminar todo ese código comentado antes de finalizar y entregar el proyecto, ya que genera ruido y confunde a otros programadores.
</note>