Saltar a contenido

3. Estructura de un programa Java

3.1 La clase como contenedor obligatorio

En Java, todo el código vive dentro de una clase. No existe la posibilidad de escribir instrucciones "sueltas" a nivel de fichero, como sí podrías hacer en Python. Una clase, en su forma más básica, es simplemente un contenedor con nombre:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
package dam.programacion.ud1;

/**
 * Primer programa del curso: la forma "clásica y completa" de escribir
 * un punto de entrada en Java, tal y como se ha hecho desde su primera versión.
 *
 * @author Tu nombre aquí
 */
public class Main {

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

🏢 Analogía: piensa en public class Main como la fachada y la puerta principal de un edificio. Nada puede existir "flotando en la calle": todo tiene que estar dentro de algún edificio (clase). Y dentro de ese edificio concreto, hay una sala especial —la recepción— por donde siempre entra todo el mundo primero.

Regla de oro que IntelliJ te recordará constantemente: el nombre del fichero debe coincidir exactamente con el nombre de la clase pública que contiene, respetando mayúsculas y minúsculas. La clase Main debe vivir en un fichero llamado Main.java, ni main.java ni Main.txt.

3.2 El método main: punto de entrada del programa

Esa "sala de recepción" de la que hablábamos es el método main. Es el único sitio donde la JVM sabe, por convención, que debe empezar a ejecutar tu programa.

1
2
3
public static void main(String[] args) {
    // Aquí empieza literalmente toda la ejecución de tu programa
}

Desglosemos cada palabra de esa línea, porque cada una tiene un motivo de estar ahí (aunque algunas se explicarán en detalle más adelante en el curso):

Palabra Significado (adelanto)
public El método es accesible desde fuera de la clase; la JVM necesita poder "verlo" y llamarlo desde el exterior
static El método pertenece a la clase en sí, no a un objeto concreto; la JVM lo ejecuta sin tener que crear antes una instancia (profundizaremos en static en UD4)
void El método no devuelve ningún valor
main El nombre exacto que la JVM busca como punto de entrada. No es opcional: tiene que llamarse así
(String[] args) Un array de textos con los argumentos que se le pueden pasar al programa desde la línea de comandos

3.3 Unnamed classes e instance main methods (Java 25, estable)

Java 25 estabiliza una característica que llevaba varias versiones en fase de preview: los programas pueden arrancar sin necesidad de envolver el código en una clase explícita ni declarar main como static. Es una simplificación pensada sobre todo para programas pequeños, scripts y para que quien empieza a programar no tenga que memorizar de golpe cinco palabras clave (public static void main(String[] args)) antes de escribir su primer "Hola, mundo".

1
2
3
4
5
6
7
// Fichero: Hola.java
// Observa: no hay ninguna línea "public class Hola { ... }" envolviendo el código.
// Java 25 permite este formato reducido para programas sencillos.

void main() {
    System.out.println("¡Hola, mundo Java! (sin clase explícita)");
}

Este fichero se puede incluso ejecutar directamente con java Hola.java, sin un paso de compilación explícito y separado: la propia herramienta java compila y ejecuta en un solo paso, algo muy útil para probar ideas rápidas o para dar los primerísimos pasos sin la carga cognitiva de Maven y los paquetes.

Aspecto Clase clásica (public class Main) Unnamed class (Java 25)
Necesita public class NombreClase { } Sí No
main es static Sí No (es un método de instancia implícito)
Firma típica public static void main(String[] args) void main() (los args son opcionales)
Recomendado para Proyectos reales, con Maven, con varias clases Aprendizaje inicial, scripts rápidos, prototipado
¿Lo usaremos en este curso? Sí, será nuestro estándar a partir de UD2 en adelante Lo verás puntualmente como curiosidad de Java 25, pero en proyectos Maven trabajaremos siempre con la forma clásica

⚖️ Por qué seguimos enseñando la forma clásica como estándar: en el mundo profesional real, casi todo el código Java que te vas a encontrar (y casi todo lo que construiremos con Maven, JavaFX y bases de datos en este módulo) usa la forma clásica con clase explícita. La unnamed class es una herramienta estupenda para aprender y prototipar rápido, pero no sustituye a la estructura que necesitarás dominar para trabajar en equipo en un proyecto real.

3.4 System.out.println(), System.out.printf(), System.out.print()

Estas tres instrucciones son las que usarás para "hablar" con quien ejecute tu programa desde la consola.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
package dam.programacion.ud1;

public class Impresion {

    public static void main(String[] args) {

        // println añade un salto de línea AUTOMÁTICAMENTE al final
        System.out.println("Esto se imprime y salta de línea");

        // print NO añade salto de línea: el cursor se queda pegado al final
        System.out.print("Esto no salta de línea... ");
        System.out.println("...así que esto continúa en la misma línea");

        // printf permite dar formato con "especificadores" como %s, %d, %.2f
        String nombre = "Ana";
        int edad = 22;
        double notaMedia = 8.567;

        // %s -> texto (String), %d -> entero, %.2f -> decimal con 2 cifras, %n -> salto de línea
        System.out.printf("Alumno: %s, edad: %d años, nota media: %.2f%n", nombre, edad, notaMedia);
    }
}

Salida por consola al ejecutar este programa:

1
2
3
Esto se imprime y salta de línea
Esto no salta de línea... ...así que esto continúa en la misma línea
Alumno: Ana, edad: 22 años, nota media: 8.57

📎 Nota: edad y notaMedia aquí son variables de ejemplo para ilustrar printf — profundizaremos en variables y tipos primitivos en el siguiente bloque (puntos 4 a 8 de esta misma unidad).

3.5 Sensibilidad a mayúsculas, punto y coma, bloques { }

Java es un lenguaje estricto y case-sensitive (distingue mayúsculas de minúsculas). Estos son los tres tropiezos más habituales de cualquier persona en su primera semana de curso:

Error típico Ejemplo incorrecto Por qué falla Corrección
Falta el punto y coma System.out.println("Hola") Cada instrucción debe terminar en ;. El compilador no "adivina" dónde acaba una frase System.out.println("Hola");
Mayúsculas/minúsculas mal escritas Sytem.out.println(...) o system.out.println(...) Java distingue System (clase real) de system (no existe) Escribir System exactamente así, con S mayúscula
Bloque { } sin cerrar public class Main { public static void main(...) { ... (falta una }) El compilador no sabe dónde termina la clase o el método Comprobar que hay tantas } como {

🔎 Truco de IntelliJ: cuando el cursor está justo al lado de una llave { o }, el IDE resalta automáticamente su pareja. Es la forma más rápida de detectar un bloque mal cerrado sin contarlas a mano.

3.6 Comentarios: //, /* */, Javadoc /** */

Los comentarios son texto que el compilador ignora por completo: están ahí solo para que los humanos (tú dentro de seis meses, o tu compañero de equipo) entiendan qué hace el código y por qué.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package dam.programacion.ud1;

/**
 * Clase de demostración de los tres tipos de comentarios en Java.
 * Este comentario Javadoc describe la clase completa y puede generar
 * documentación HTML automática con la herramienta "javadoc".
 *
 * @author Tu nombre aquí
 */
public class Comentarios {

    public static void main(String[] args) {

        // Comentario de una sola línea: ideal para aclaraciones puntuales
        // y explicaciones breves justo antes de la línea que comentan

        /*
         * Comentario multilínea: útil para explicaciones más largas,
         * o para "desactivar" temporalmente varias líneas de código
         * sin borrarlas mientras pruebas cosas.
         */

        System.out.println("Los comentarios no afectan a la ejecución del programa");
    }
}
Tipo Sintaxis Uso principal
Línea simple // comentario Aclaraciones breves, una idea por línea
Multilínea /* comentario \n más texto */ Explicaciones largas o desactivar bloques de código temporalmente
Javadoc /** comentario */ Documentar oficialmente clases y métodos; puede generar documentación HTML con mvn javadoc:javadoc (lo veremos con más detalle en UD2 y UD7)

✍️ Buena práctica desde el día 1: un comentario debería explicar el por qué de una decisión, no el qué obvio del código. // sumamos 1 encima de contador++; no aporta nada. En cambio, // empezamos en 1 porque el primer día de matrícula ya cuenta sí aporta contexto real.

3.7 Convenciones de nomenclatura Java

Java tiene convenciones de nombres muy asentadas en toda la comunidad. No son obligatorias para que el compilador acepte tu código, pero sí son obligatorias en cualquier entorno profesional real y son las que evaluaremos como buena práctica durante todo el curso.

Convención Se usa para Ejemplo
camelCase (primera palabra en minúscula, resto con mayúscula inicial) Variables y métodos edadAlumno, calcularNotaMedia()
PascalCase (todas las palabras con mayúscula inicial) Nombres de clases e interfaces CuentaBancaria, Comentarios
UPPER_SNAKE_CASE (todo en mayúsculas, palabras separadas por _) Constantes (static final, lo veremos en el punto 6) MAX_INTENTOS, IVA_GENERAL
minúsculas.con.puntos Paquetes dam.programacion.ud1

🎯 Fíjate en que el propio nombre de nuestro paquete, dam.programacion.ud1, ya sigue la convención de paquetes: todo en minúsculas, sin espacios ni guiones, separado por puntos.

🧩 Ejercicio integrador de cierre del bloque

Vamos a atar juntos los tres puntos de este bloque: crear el entorno (punto 2) y escribir un programa bien estructurado (punto 3).

Enunciado: crea un proyecto Maven llamado ud1-fundamentos con el pom.xml visto en el punto 2.3. Dentro del paquete dam.programacion.ud1, crea una clase llamada FichaAlumno cuyo método main imprima, usando System.out.printf(), una pequeña ficha con tu nombre, el ciclo que estás cursando y el nombre de la unidad didáctica actual. Añade al menos un comentario de línea y un comentario Javadoc explicando la clase.

Solución propuesta:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package dam.programacion.ud1;

/**
 * Ficha de presentación del alumno, primer ejercicio integrador del curso.
 * Combina lo aprendido en los puntos 2 y 3 de la UD1: proyecto Maven,
 * paquete propio, estructura de clase y salida formateada por consola.
 *
 * @author Tu nombre aquí
 */
public class FichaAlumno {

    public static void main(String[] args) {

        // Datos de ejemplo: en unidades posteriores aprenderemos a
        // guardarlos en variables de tipos adecuados (puntos 4 a 8 de UD1)
        String nombre = "Tu nombre aquí";
        String ciclo = "Desarrollo de Aplicaciones Multiplataforma (DAM)";
        String unidad = "UD1 - Fundamentos de Programación";

        System.out.println("========================================");
        System.out.printf("Alumno/a : %s%n", nombre);
        System.out.printf("Ciclo    : %s%n", ciclo);
        System.out.printf("Unidad   : %s%n", unidad);
        System.out.println("========================================");
    }
}

Salida esperada por consola:

1
2
3
4
5
========================================
Alumno/a : Tu nombre aquí
Ciclo    : Desarrollo de Aplicaciones Multiplataforma (DAM)
Unidad   : UD1 - Fundamentos de Programación
========================================
🧠 Autoevaluación exprés — Punto 3 (haz clic para ver las preguntas) 1. ¿Por qué en Java no se puede escribir una instrucción "suelta" fuera de cualquier clase (en la forma clásica)? 2. ¿Qué ocurre si el nombre del fichero `.java` no coincide con el nombre de la clase pública que contiene? 3. ¿Qué diferencia práctica hay entre `System.out.print()` y `System.out.println()`? 4. Cita los tres tipos de comentarios en Java y para qué se usa cada uno. 5. ¿Por qué en este curso trabajaremos con la forma clásica `public static void main(String[] args)` en lugar de las *unnamed classes*, aunque Java 25 las permita? Respuestas orientativas: (1) porque en Java todo el código debe vivir dentro de una clase, es una regla del lenguaje. (2) El proyecto no compila: Java exige que coincidan exactamente. (3) print no añade salto de línea al final, println sí. (4) // (línea), /* */ (multilínea), /** */ (Javadoc, genera documentación). (5) Porque es la forma que usaremos en proyectos Maven reales con varias clases, y es la que te encontrarás en el mundo profesional.