Java desde cero — estructura de clase, main y sintaxis básica explicados de verdad

PorSergio Alejandro Medina Ospina
TeoríaDesde ceroFP213 min de lectura

Java desde cero sintaxis es exactamente lo que toca aquí. Si vienes de Python y en FP2 en la ULPGC es lo más probable que lo primero que te va a llamar la atención de Java es que parece mucho más verboso. Donde en Python escribías tres líneas, en Java escribes diez. Eso no significa que sea más complicado, significa que Java es más explícito. Cada cosa tiene que declararse, cada tipo tiene que especificarse, cada bloque tiene que abrirse y cerrarse.

En este artículo desmontamos cada pieza de ese primer programa Java para que no haya nada que se quede sin explicar.

El programa más simple en Java

Antes de explicar nada, aquí está el programa más simple que puedes escribir en Java, el equivalente exacto de print("Hola mundo") en Python:

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

Una sola línea de salida. Siete palabras de código real. Y sin embargo hay que escribir seis líneas para llegar ahí. Vamos a desmontar cada parte.

Por qué Java necesita una clase para cualquier cosa

En Python podías escribir código suelto — una variable aquí, una función allá, un print directamente. Java no permite eso. En Java todo el código tiene que vivir dentro de una clase. No hay excepciones.

# Python — código suelto, sin clase
print("Hola mundo")
nombre = "Sergio"
// Java — todo dentro de una clase, siempre
public class HolaMundo {
    // aquí va el código
}

La razón es filosófica: Java fue diseñado desde el principio como un lenguaje orientado a objetos puro. En Python la POO es opcional, puedes programar sin usar clases en todo FP1. En Java no existe ese modo, incluso el programa más simple es una clase.

Lo que tienes que llevarte: en Java, antes de escribir cualquier línea de código, necesitas una clase que lo contenga. Siempre. Sin excepción.

La palabra public antes de class significa que esta clase es accesible desde cualquier parte del programa. Por ahora quédate con que todos tus programas de FP2 van a empezar con public class NombreDeClase.

La regla del nombre de archivo la más importante de todas

Antes de continuar hay una regla que tienes que grabarte porque si la rompes el compilador da error inmediatamente:

El nombre del archivo .java debe coincidir exactamente con el nombre de la clase, incluyendo mayúsculas y minúsculas.

Clase:    public class HolaMundo
Archivo:  HolaMundo.java       ← correcto
Archivo:  holamundo.java       ← error
Archivo:  Holamundo.java       ← error
Archivo:  hola_mundo.java      ← error

En Python el archivo podía llamarse como quisieras. En Java esta regla es estricta. Si VS Code te da un error en la primera línea sin que hayas escrito nada mal, lo primero que tienes que revisar es que el nombre del archivo y el nombre de la clase coincidan exactamente.

Las llaves — cómo Java delimita los bloques

En Python los bloques de código se delimitan con indentación, el sangrado visual que indica que algo está dentro de algo. En Java los bloques se delimitan con llaves { }:

# Python — la indentación delimita el bloque
def saludar():
    print("Hola")      # dentro de la función
    print("Adiós")     # también dentro

print("Fuera")         # fuera de la función
// Java — las llaves delimitan el bloque
public class HolaMundo {           // llave abre la clase
    public static void main(...) { // llave abre el método
        System.out.println("Hola"); // dentro del método
    }                              // llave cierra el método
}                                  // llave cierra la clase

Las llaves abren y cierran bloques, clases, métodos, condiciones, bucles. Todo lo que en Python usaría indentación, en Java usa llaves. La indentación en Java también existe pero es solo visual, no tiene significado para el compilador.

Esto significa que en Java puedes escribir código perfectamente funcional sin ninguna indentación, aunque hacerlo sería una muy mala práctica:

// Funciona pero es ilegible
public class HolaMundo{public static void main(String[] args){System.out.println("Hola");}}

VS Code con la extensión Java formatea automáticamente el código con Shift + Alt + F, úsalo si las llaves se te descolocan.

El punto y coma — por qué cada instrucción termina en ;

En Python el fin de una línea es el fin de una instrucción, no necesitas ningún símbolo especial. En Java cada instrucción termina con punto y coma:

# Python — sin punto y coma
print("Hola")
nombre = "Sergio"
// Java — punto y coma obligatorio
System.out.println("Hola");
String nombre = "Sergio";

El punto y coma le dice al compilador «aquí termina esta instrucción». Sin él, el compilador no sabe dónde acaba una instrucción y empieza la siguiente, y da error.

El error de olvidar el punto y coma es el más común cuando empiezas con Java viniendo de Python. VS Code lo marca inmediatamente con una línea roja ondulada, búscala en cuanto tengas un error de compilación.

// Sin punto y coma — error de compilación
System.out.println("Hola")   // ← error: ';' expected
String nombre = "Sergio"     // ← error: ';' expected

// Con punto y coma — correcto
System.out.println("Hola");
String nombre = "Sergio";

Las llaves de apertura y cierre no llevan punto y coma:

public class HolaMundo {     // sin punto y coma — es una llave, no una instrucción
    ...
}                            // sin punto y coma

El método main — la puerta de entrada del programa

En Python cuando ejecutas un archivo, Python empieza a ejecutar el código desde la primera línea del archivo hacia abajo. En Java el compilador necesita saber exactamente por dónde empezar, y eso se indica con el método main.

El método main es el punto de entrada de cualquier programa Java. Cuando ejecutas una clase Java, la JVM busca el método main y empieza a ejecutar desde ahí:

public class HolaMundo {
    public static void main(String[] args) {
        // todo lo que escribas aquí se ejecuta al arrancar el programa
        System.out.println("Hola mundo");
    }
}

La firma completa es siempre esta exactamente igual, sin variaciones:

public static void main(String[] args)

Si cambias cualquier cosa de esa firma, el nombre, los tipos de parámetros, lo que sea, Java no reconoce el método como punto de entrada y el programa no arranca.

Qué significa cada palabra de public static void main(String[] args)

Esta es la parte que más confunde al principio porque hay cinco palabras antes del cuerpo y ninguna es obvia. Las vemos una a una:

public — significa que este método es accesible desde cualquier parte. La JVM necesita poder llamar a main desde fuera de la clase para arrancar el programa, así que tiene que ser public. Si lo pusieras private, la JVM no podría encontrarlo.

static — significa que este método pertenece a la clase, no a un objeto concreto de la clase. Cuando arranca un programa Java no existe ningún objeto todavía, la JVM llama a main directamente sobre la clase antes de crear nada. Por eso tiene que ser static. Si no lo fuera, la JVM tendría que crear un objeto de la clase antes de poder llamar a main, lo cual crea un problema circular.

void — significa que el método no devuelve ningún valor. Es el equivalente de una función Python que no tiene return. main nunca devuelve nada — cuando termina, el programa termina.

main — el nombre del método. Este nombre es especial, la JVM lo busca exactamente con este nombre. No Main, no MAIN, no inicio, tiene que ser main en minúscula.

String[] args — el parámetro del método. String[] significa «array de Strings» y args es el nombre de ese array. Contiene los argumentos que se pasan al programa desde la línea de comandos. En FP2 casi nunca los usarás, pero la firma del main siempre los incluye.

El resumen para memorizar:

public  → accesible desde fuera (la JVM puede llamarlo)
static  → pertenece a la clase, no a un objeto
void    → no devuelve nada
main    → nombre especial que la JVM busca
String[] args → parámetros de línea de comandos (casi nunca se usan en FP2)

Los comentarios en Java

Java tiene tres tipos de comentarios. Los dos primeros son equivalentes a los de Python:

# Python — comentario de una línea
# Esto es un comentario

"""
Esto es un comentario
de varias líneas
"""
// Java — comentario de una línea (equivale al # de Python)
// Esto es un comentario

/* Java — comentario de varias líneas (equivale al """ de Python)
   Esto es un comentario
   de varias líneas
*/

/** Javadoc — comentario de documentación (no existe en Python)
 * Se usa para documentar clases y métodos.
 * Las herramientas de Java lo leen para generar documentación automática.
 */

En FP2 usarás principalmente // para comentarios cortos y /* */ cuando necesites comentar varias líneas. El /** */ lo verás en código de ejemplo pero no necesitas escribirlo tú por ahora.

System.out.println — la salida por pantalla

En Python la salida es simplemente print(). En Java es System.out.println() y sí, es más largo. Aquí está lo que significa cada parte:

System     → clase del sistema de Java (viene incluida, no hay que importar nada)
.          → accedemos a algo dentro de System
out        → el objeto que representa la salida estándar (la pantalla)
.          → accedemos a algo dentro de out
println    → el método que imprime y añade salto de línea al final

La diferencia entre println y print:

System.out.println("Hola");    // imprime "Hola" y salta a la siguiente línea
System.out.println("Mundo");   // imprime "Mundo" en la línea siguiente

// Salida:
// Hola
// Mundo
System.out.print("Hola");      // imprime "Hola" SIN saltar de línea
System.out.print(" Mundo");    // imprime " Mundo" en la MISMA línea

// Salida:
// Hola Mundo
System.out.print("Hola");
System.out.println(" Mundo");  // imprime " Mundo" y salta de línea
System.out.println("!");       // imprime "!" en la siguiente línea

// Salida:
// Hola Mundo
// !

La regla fácil: println = print en Python (con salto de línea). print en Java = print en Python con end="" (sin salto de línea).

Para imprimir una línea vacía — el equivalente de print() en Python sin argumentos:

System.out.println();    // imprime solo el salto de línea → línea vacía

Salida con formato — printf

Java también tiene printf para formatear la salida, equivalente al f-string de Python:

# Python
nombre = "Sergio"
nota = 7.5
print(f"Hola {nombre}, tu nota es {nota:.2f}")
// Java
String nombre = "Sergio";
double nota = 7.5;
System.out.printf("Hola %s, tu nota es %.2f%n", nombre, nota);

Los especificadores de formato de Java:

%s   → String (texto)
%d   → int (entero)
%f   → double o float (decimal)
%.2f → decimal con 2 decimales
%n   → salto de línea (equivale a \n pero multiplataforma)
%b   → boolean
%c   → char (carácter)
System.out.printf("Nombre: %s%n", "Sergio");       // → Nombre: Sergio
System.out.printf("Edad: %d años%n", 22);           // → Edad: 22 años
System.out.printf("Nota: %.2f%n", 7.5);             // → Nota: 7.50
System.out.printf("%s tiene %d años%n", "Sergio", 22); // → Sergio tiene 22 años

Concatenación de Strings

Para unir texto en Java puedes usar +, igual que en Python:

# Python
nombre = "Sergio"
print("Hola " + nombre + ", bienvenido")
// Java
String nombre = "Sergio";
System.out.println("Hola " + nombre + ", bienvenido");

En Java puedes concatenar cualquier tipo con un String usando +, Java convierte automáticamente números y booleanos a texto:

int edad = 22;
System.out.println("Tengo " + edad + " años");    // → Tengo 22 años
System.out.println("El resultado es " + (3 + 4)); // → El resultado es 7
System.out.println("Es " + true);                 // → Es true

Fíjate en los paréntesis en "El resultado es " + (3 + 4), sin los paréntesis Java haría "El resultado es 3" + 4 = "El resultado es 34" porque suma el 3 al String primero. Con los paréntesis primero suma 3 + 4 = 7 y luego concatena.

La estructura completa — todo junto

Aquí tienes un programa que usa todo lo que hemos visto:

/**
 * Primer programa Java completo.
 * Muestra el uso de println, print, printf y concatenación.
 */
public class PrimerPrograma {

    public static void main(String[] args) {

        // println — imprime con salto de línea
        System.out.println("=== Mi primer programa Java ===");
        System.out.println();    // línea vacía

        // print — imprime sin salto de línea
        System.out.print("Hola ");
        System.out.print("desde ");
        System.out.println("Java");    // este sí salta de línea

        // printf — salida formateada
        String nombre = "Sergio";
        int edad = 22;
        double nota = 8.75;

        System.out.printf("Nombre: %s%n", nombre);
        System.out.printf("Edad:   %d años%n", edad);
        System.out.printf("Nota:   %.2f%n", nota);
        System.out.println();

        // concatenación con +
        System.out.println("Estudiante: " + nombre + ", " + edad + " años");
        System.out.println("Aprobado: " + (nota >= 5));

        // comentario de una línea
        /* comentario de
           varias líneas */
    }
}
=== Mi primer programa Java ===

Hola desde Java
Nombre: Sergio
Edad:   22 años
Nota:   8.75

Estudiante: Sergio, 22 años
Aprobado: true

Cómo ejecutar este programa en VS Code

  1. Crea un archivo llamado PrimerPrograma.java (nombre exacto de la clase)
  2. Pega el código
  3. Haz clic en el botón Run que aparece encima del main — o pulsa F5
  4. VS Code compila automáticamente y muestra la salida en el terminal integrado

Si hay errores de compilación aparecen en el panel Problems (Ctrl + Shift + M) antes de ejecutar. El error más común al empezar:

error: ';' expected       → olvidaste el punto y coma
error: class X is public  → el nombre del archivo no coincide con la clase
error: cannot find symbol → escribiste mal el nombre de una variable o método

Visualízalo

Java funciona en pythontutor.com, pero VS Code tiene un depurador excelente. Para ejecutar paso a paso:

  1. Haz clic en el número de línea donde quieres pausar — aparece un punto rojo (breakpoint)
  2. Pulsa F5 en vez de Run
  3. Usa F10 para avanzar línea a línea
  4. El panel Variables muestra el valor de cada variable en tiempo real

Para un programa tan simple como este el depurador es innecesario, pero cuando llegues a bucles y clases será tu mejor herramienta.

Resumen rápido

// ESTRUCTURA BÁSICA — siempre esta forma
public class NombreClase {              // nombre = nombre del archivo
    public static void main(String[] args) {  // punto de entrada
        // código aquí
    }
}

// PUNTO Y COMA — al final de cada instrucción
System.out.println("Hola");     // ← obligatorio
String nombre = "Sergio";       // ← obligatorio
// las llaves { } no llevan ;

// COMENTARIOS
// comentario de una línea
/* comentario
   de varias líneas */
/** comentario de documentación */

// SALIDA POR PANTALLA
System.out.println("texto");    // con salto de línea (como print() en Python)
System.out.print("texto");      // sin salto de línea (como print(..., end=""))
System.out.println();           // línea vacía (como print() sin args)
System.out.printf("Hola %s, tienes %d años%n", nombre, edad); // formateada

// CONCATENACIÓN
System.out.println("Texto " + variable + " más texto");

// ESPECIFICADORES printf
// %s → String    %d → int    %f → double
// %.2f → 2 decimales    %n → salto de línea

// PUBLIC STATIC VOID MAIN
// public  → accesible desde fuera (la JVM lo necesita)
// static  → pertenece a la clase, no a un objeto
// void    → no devuelve nada
// main    → nombre especial que busca la JVM
// String[] args → argumentos de línea de comandos (rara vez se usan)

// LLAVES vs INDENTACIÓN
// Python → indentación delimita bloques
// Java   → llaves { } delimitan bloques, indentación es solo visual

// REGLA DE ORO
// Nombre del archivo = nombre de la clase (exacto, con mayúsculas)
// HolaMundo.java → public class HolaMundo

En el próximo artículo practicamos todo esto con programas reales, entradas y salidas, múltiples clases y los primeros errores de compilación resueltos paso a paso.

Siguiente paso: prácticaSintaxis de Java — 3 programas reales para perderle el miedo al punto y coma

¿Te ha servido este artículo? Así puedes apoyar SergioLearns →

Estudiante de Ciencia e Ingeniería de Datos en la ULPGC. Explico lo
que aprendo en la carrera como me hubiera gustado que me lo explicaran
a mí: con sus dudas, sus errores y el camino hasta la solución.

Sigue aprendiendo

3 comentarios

  1. Pingback: Bucles en Java: guía escencial de for, for each y while para FP2
  2. Pingback: Control de flujo en Java: guía indispensable de Scanner, if/else y switch para FP2
  3. Pingback: Sintaxis Java práctica: 3 programas reales desde cero

Deja una respuesta

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