Java desde cero — estructura de clase, main y sintaxis básica explicados de verdad
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.
Tabla de Contenidos
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
- Crea un archivo llamado
PrimerPrograma.java(nombre exacto de la clase) - Pega el código
- Haz clic en el botón Run que aparece encima del
main— o pulsaF5 - 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:
- Haz clic en el número de línea donde quieres pausar — aparece un punto rojo (breakpoint)
- Pulsa
F5en vez de Run - Usa
F10para avanzar línea a línea - 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.
Java from scratch — class structure, main and basic syntax really explained
Java from scratch is exactly what this article is. If you’re coming from Python, likely in FP2 at ULPGC, the first thing you’ll notice about Java is that it looks much more verbose. Where Python needed three lines, Java needs ten. That doesn’t mean it’s more complicated, it means Java is more explicit. Everything must be declared, every type must be specified, every block must be opened and closed.
This article breaks down every single piece of that first Java program so nothing goes unexplained.
The simplest Java program
Before explaining anything, here’s the simplest program you can write in Java, the exact equivalent of print("Hello world") in Python:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world");
}
}
One line of actual output. Seven words of real code. Yet six lines to get there. Let’s break down each part.
Why Java needs a class for everything
In Python you could write loose code, a variable here, a function there, a print directly. Java doesn’t allow that. In Java all code must live inside a class. No exceptions.
# Python — loose code, no class needed
print("Hello world")
name = "Sergio"
// Java — everything inside a class, always
public class HelloWorld {
// code goes here
}
The reason is philosophical: Java was designed from the beginning as a pure object-oriented language. In Python OOP is optional, you can code through all of FP1 without ever writing a class. In Java that mode doesn’t exist, even the simplest program is a class.
Take away: in Java, before writing any line of code, you need a class to contain it. Always. No exceptions.
public before class means this class is accessible from anywhere in the program. For now, just remember that all your FP2 programs start with public class ClassName.
The file naming rule — the most important of all
Before going further, here’s a rule to memorise because breaking it causes an immediate compiler error:
The .java file name must match the class name exactly, including capitalisation.
Class: public class HelloWorld File: HelloWorld.java ← correct File: helloworld.java ← error File: Helloworld.java ← error File: hello_world.java ← error
In Python the file could be named anything. In Java this rule is strict. If VS Code gives you an error on the first line when you haven’t typed anything wrong, the first thing to check is that the file name and class name match exactly.
Curly braces — how Java delimits blocks
In Python code blocks are delimited by indentation, the visual indent that shows something is inside something else. In Java blocks are delimited by curly braces { }:
# Python — indentation delimits the block
def greet():
print("Hello") # inside the function
print("Goodbye") # also inside
print("Outside") # outside the function
// Java — curly braces delimit the block
public class HelloWorld { // brace opens class
public static void main(...) { // brace opens method
System.out.println("Hello"); // inside the method
} // brace closes method
} // brace closes class
Indentation in Java also exists but is purely visual, the compiler ignores it entirely. This means technically valid but unreadable code like this compiles fine:
public class HelloWorld{public static void main(String[] args){System.out.println("Hello");}}
VS Code auto-formats with Shift + Alt + F, use it whenever the braces get misaligned.
The semicolon — why every statement ends with ;
In Python the end of a line is the end of a statement, no special symbol needed. In Java every statement ends with a semicolon:
# Python — no semicolon
print("Hello")
name = "Sergio"
// Java — semicolon required
System.out.println("Hello");
String name = "Sergio";
The semicolon tells the compiler «this statement ends here». Without it, the compiler doesn’t know where one statement ends and the next begins, error.
Forgetting the semicolon is the most common mistake when starting Java from Python. VS Code marks it immediately with a red wavy underline.
System.out.println("Hello") // error: ';' expected
String name = "Sergio" // error: ';' expected
Opening and closing curly braces do not get semicolons:
public class HelloWorld { // no semicolon
...
} // no semicolon
The main method — the program’s entry point
In Python when you run a file, Python starts executing from the first line downward. In Java the compiler needs to know exactly where to start, and that’s indicated by the main method.
main is the entry point of any Java program. When you run a Java class, the JVM looks for main and starts executing from there:
public class HelloWorld {
public static void main(String[] args) {
// everything here runs when the program starts
System.out.println("Hello world");
}
}
The full signature is always this, exactly the same, no variations:
public static void main(String[] args)
If you change anything about that signature, the name, the parameter types, anything, Java won’t recognise it as an entry point and the program won’t run.
What each word in public static void main(String[] args) means
This is the part that confuses most at the start because there are five words before the body and none are obvious.
public — this method is accessible from anywhere. The JVM needs to be able to call main from outside the class to start the program, so it must be public. If it were private, the JVM couldn’t find it.
static — this method belongs to the class, not to a specific object. When a Java program starts there are no objects yet, the JVM calls main directly on the class before creating anything. So it must be static. If it weren’t, the JVM would need to create an object of the class before calling main, a circular problem.
void — the method returns no value. Equivalent to a Python function with no return. main never returns anything, when it finishes, the program finishes.
main — the method name. This name is special, the JVM searches for it exactly. Not Main, not MAIN, not start, must be main lowercase.
String[] args — the method’s parameter. String[] means «array of Strings» and args is the array’s name. It holds command-line arguments passed to the program. You’ll almost never use this in FP2, but the main signature always includes it.
Summary to memorise:
public → accessible from outside (JVM can call it) static → belongs to class, not an object void → returns nothing main → special name the JVM looks for String[] args → command-line arguments (rarely used in FP2)
Comments in Java
Java has three comment types:
# Python — single line comment """ Multi-line comment """
// Java — single line comment (equivalent to Python's #) /* Java — multi-line comment (equivalent to Python's """) Multiple lines */ /** Javadoc — documentation comment (no Python equivalent) * Used to document classes and methods. * Tools read this to generate automatic documentation. */
In FP2 you’ll mainly use // for short comments and /* */ for multiple lines. You’ll see /** */ in example code but don’t need to write it yourself yet.
System.out.println — screen output
In Python output is simply print(). In Java it’s System.out.println(). Here’s what each part means:
System → Java's system class (included, nothing to import) . → accessing something inside System out → the object representing standard output (the screen) . → accessing something inside out println → the method that prints and adds a newline at the end
The difference between println and print:
System.out.println("Hello"); // prints "Hello" and moves to next line
System.out.println("World"); // prints "World" on the next line
// Output:
// Hello
// World
System.out.print("Hello"); // prints "Hello" WITHOUT newline
System.out.print(" World"); // prints " World" on the SAME line
// Output:
// Hello World
System.out.println(); // empty line
Easy rule: Java’s println = Python’s print() (with newline). Java’s print = Python’s print(..., end="") (no newline).
Formatted output — printf
# Python f-string
name = "Sergio"
grade = 7.5
print(f"Hello {name}, your grade is {grade:.2f}")
// Java printf
String name = "Sergio";
double grade = 7.5;
System.out.printf("Hello %s, your grade is %.2f%n", name, grade);
Format specifiers:
%s → String %d → int %f → double %.2f → 2 decimals %n → newline %b → boolean
String concatenation
String name = "Sergio";
int age = 22;
System.out.println("Hello " + name + ", welcome"); // → Hello Sergio, welcome
System.out.println("I am " + age + " years old"); // → I am 22 years old
System.out.println("Result: " + (3 + 4)); // → Result: 7
// Note the parentheses — without them: "Result: 34" (concatenates 3 first)
Complete structure — everything together
/**
* First complete Java program.
*/
public class FirstProgram {
public static void main(String[] args) {
// println — with newline
System.out.println("=== My first Java program ===");
System.out.println(); // empty line
// print — without newline
System.out.print("Hello ");
System.out.print("from ");
System.out.println("Java");
// printf — formatted output
String name = "Sergio";
int age = 22;
double grade = 8.75;
System.out.printf("Name: %s%n", name);
System.out.printf("Age: %d years%n", age);
System.out.printf("Grade: %.2f%n", grade);
System.out.println();
// concatenation
System.out.println("Student: " + name + ", " + age + " years old");
System.out.println("Passed: " + (grade >= 5));
}
}
=== My first Java program === Hello from Java Name: Sergio Age: 22 years Grade: 8.75 Student: Sergio, 22 years old Passed: true
How to run this in VS Code
- Create a file named
FirstProgram.java(exact class name) - Paste the code
- Click the Run button above
main— or pressF5 - VS Code compiles automatically and shows output in the integrated terminal
Most common beginner errors:
error: ';' expected → missing semicolon error: class X is public → file name doesn't match class name error: cannot find symbol → typo in variable or method name
Quick summary
// BASIC STRUCTURE
public class ClassName { // name = file name
public static void main(String[] args) { // entry point
// code here
}
}
// SEMICOLONS — at end of every statement
System.out.println("Hello"); // ← required
String name = "Sergio"; // ← required
// curly braces { } don't get ;
// COMMENTS
// single line comment
/* multi-line
comment */
/** documentation comment */
// OUTPUT
System.out.println("text"); // with newline (like Python's print())
System.out.print("text"); // without newline (like print(..., end=""))
System.out.println(); // empty line (like print())
System.out.printf("Hello %s, you are %d years old%n", name, age);
// CONCATENATION
System.out.println("Text " + variable + " more text");
// PRINTF SPECIFIERS
// %s → String %d → int %f → double %.2f → 2 decimals %n → newline
// PUBLIC STATIC VOID MAIN
// public → accessible from outside (JVM needs it)
// static → belongs to class, not an object
// void → returns nothing
// main → special name JVM looks for
// String[] args → command-line args (rarely used in FP2)
// GOLDEN RULE
// File name = class name (exact match, capitalisation included)
// HelloWorld.java → public class HelloWorld
2 comentarios