Java

Repaso de sintaxis: (), {}, [] y :

Referencia rápida de todos los significados que tienen los paréntesis, las llaves, los corchetes y los dos puntos en Java.

javasintaxisreferenciarepaso

Cómo usar esta página

Esta página no enseña nada nuevo. Es una referencia de consulta: recoge todos los usos de (), {}, [] y : que fueron apareciendo a lo largo de esta sección, cada uno en su propio contexto y a veces con varias páginas de distancia entre sí.

Está pensada para el momento en que estás leyendo código ajeno, ves un símbolo y te preguntas “¿qué significa aquí?”. Cada fila de cada tabla enlaza a la página donde ese uso se explicó de verdad, así que si una respuesta corta no te alcanza, el desarrollo completo está a un clic.

Los paréntesis: ()

Uso	Se ve así	Dónde se explicó
Llamar a un método	`saludar("Ana")`	Declarar un método
Declarar los parámetros de un método	`static int sumar(int a, int b)`	Declarar un método
Agrupar una expresión y forzar el orden	`(subtotal * IVA)`	Operadores aritméticos
Encerrar la condición de `if`, `while`, `switch`	`if (nota >= 6)`	if / else if / else
Encerrar las tres partes de un `for`	`for (int i = 1; i <= 5; i++)`	El bucle for
Conversión explícita (cast)	`(double) a / b`	División entera
Llamar a un constructor	`new Alumno("Ana", 8.5)`	Constructores
Llamar al constructor del padre	`super(nombre, edad)`	super: llamar al padre
Encerrar el tipo en un cast de bajada	`(Alumno) obj`	instanceof y el cast
La firma fija de `main`	`public static void main(String[] args)`	¿Qué es Java?

Nota

El caso especial son los paréntesis vacíos: main() no lleva nada adentro porque, por especificación, main recibe exactamente un array de String (el parámetro args) — los paréntesis vacíos de una llamada como saludar() significan en cambio “este método no recibe argumentos”, algo que también es válido si así se lo declaró.

Las llaves:

Uso	Se ve así	Dónde se explicó
Delimitar un bloque y su ámbito	`if (nota >= 6) { ... }`	if / else if / else
El cuerpo de un método	`static int sumar(...) { return a + b; }`	Declarar un método
El cuerpo de una clase	`public class Alumno { ... }`	Definir una clase propia
El cuerpo de una interfaz	`public interface Exportable { ... }`	Declarar e implementar una interfaz
El cuerpo de un `try`, `catch` o `finally`	`try { ... } catch (Exception e) { ... }`	try / catch
Inicializar un array con valores	`int[] notas = {8, 6, 9};`	Arrays: tamaño fijo

La división es simple: unas llaves delimitan código que se ejecuta (las tres primeras filas) o encierran una lista de valores (la última). Si adentro hay sentencias, es un bloque; si adentro hay valores separados por comas, es una inicialización de array.

Advertencia

A diferencia de una declaración de clase o de array, el cuerpo de un método o de un bloque if/for/while no lleva ; después de la llave de cierre. Java tampoco usa ; al cerrar una clase (a diferencia de C++, que sí lo exige) — } alcanza.

Los corchetes: []

Uso	Se ve así	Dónde se explicó
Declarar un tipo array	`int[] notas`	Arrays: tamaño fijo
Reservar un array de tamaño N	`new int[3]`	Arrays: tamaño fijo
Indexar: acceder a un elemento	`notas[0]`, `notas[1] = 9;`	Recorrer un array
El parámetro de `main`	`String[] args`	¿Qué es Java?

Nota

ArrayList no usa [] para nada — ni para declarar su tipo (ArrayList<Integer>, con <>, no []) ni para acceder a un elemento (notas.get(1), un método, no un índice entre corchetes). Confundir arr[i] con lista.get(i) es el error de sintaxis más común al pasar de uno al otro — ver la tabla comparativa en Arrays y ArrayList.

Los dos puntos: :

Uso	Se ve así	Dónde se explicó
Etiqueta `case` o `default` en un `switch` clásico	`case 2:`	switch
Separador del for-each	`for (int nota : notas)`	Recorrer un array

Los dos usos comparten la misma idea: el : introduce lo que sigue. En un case, el código que corre para ese valor; en un for-each, la colección que se recorre.

Nota

Hay un tercer uso de : que no se cubrió en esta sección: el operador condicional ternario (condicion ? valorA : valorB), una forma compacta de escribir un if/else que devuelve un valor. Se menciona aquí solo para que no te sorprenda al encontrarlo en código ajeno.

El punto y los dos puntos dobles: . y ::

Java no tiene un operador :: de resolución de ámbito como C++ — para acceder a un miembro de un objeto o de una clase siempre se usa . (a1.nombre, System.out.println(...), Math.max(3, 7)). Pero :: sí existe en Java moderno con un significado distinto: una referencia a método, una forma de nombrar un método sin llamarlo todavía, típicamente para pasarlo como argumento.

Símbolo	Nombre	Significado
`.`	Punto	Acceder a un atributo o método de un objeto o una clase
`::`	Referencia a método	Nombrar un método sin invocarlo, ej. `System.out::println`

Esto último es un tema de Java más avanzado (aparece junto con streams y programación funcional) y no se desarrolla en esta sección — se nombra aquí solo para que reconozcas :: si lo ves y no lo confundas con un error de tipeo de ..

La arroba: @

La @ marca una anotación: metadatos que se le pegan al código para que el compilador o una herramienta los lea. No ejecuta nada por sí misma.

Uso	Se ve así	Dónde se explicó
Verificar que un método sobrescribe al del padre	`@Override`	Qué es realmente @Override

Nota

@Override es la única anotación que aparece en esta sección, pero en cualquier proyecto real vas a ver muchas más (@Deprecated, @FunctionalInterface, y las de frameworks como Spring: @Service, @Autowired). Todas siguen la misma idea: una marca declarativa que alguien más interpreta.

Los ángulos: <>

Uso	Se ve así	Dónde se explicó
Indicar el tipo que guarda una colección	`ArrayList<Integer> notas`	ArrayList
El diamante: repetir el tipo sin escribirlo	`new ArrayList<>()`	ArrayList
Parametrizar una interfaz	`implements Comparable<Alumno>`	Interfaces que ya usas

Esto se llama genéricos. La diferencia con [] vale la pena tenerla clara: int[] es un array de enteros y ArrayList<Integer> es una lista de enteros — misma intención, sintaxis completamente distinta, y no son intercambiables.

Las palabras clave de la orientación a objetos

No son símbolos, pero se leen igual de rápido en una tabla y son lo que más aparece al mirar código ajeno:

Palabra	Qué significa	Dónde se explicó
`extends`	Esta clase hereda de otra	extends
`implements`	Esta clase cumple el contrato de una interfaz	Declarar e implementar
`super`	El padre: su constructor o su versión de un método	super
`this`	El objeto actual	this
`abstract`	Sin implementación; obliga a la hija a escribirla	Clases abstractas
`static`	Pertenece a la clase, no a cada objeto	static
`final`	No se reasigna, no se sobrescribe, no se hereda	final
`private` / `protected` / `public`	Quién puede acceder	Modificadores de acceso
`instanceof`	¿El objeto es de este tipo?	instanceof
`throw` / `throws`	Lanzar una excepción / declarar que puede lanzarse	throw

Advertencia

Los dos pares que más se confunden: throw (lanza, dentro del cuerpo) contra throws (avisa, en la firma); y extends (una sola vez, hereda implementación) contra implements (todas las que quieras, solo el contrato).

Los cuatro símbolos en un solo programa

Este programa no hace nada útil: existe para que veas los cuatro delimitadores conviviendo, cada uno en un uso distinto, en pocas líneas.

Ejemplo: los cuatro símbolos en un solo programajava

public class Jugador {                          // {} delimita el cuerpo de la clase
    private String nombre;
    private int puntos;

    Jugador(String nombre) {                     // () encierra el parámetro
        this.nombre = nombre;
        this.puntos = 0;
    }

    void sumar(int p) {                           // {} delimita el cuerpo del método
        puntos += p;
    }

    int getPuntos() {
        return puntos;
    }

    public static void main(String[] args) {     // [] en el parámetro de main
        int[] tabla = {10, 20, 30};               // [] fija el tamaño, {} inicializa
        Jugador ana = new Jugador("Ana");         // () llama al constructor

        for (int p : tabla) {                     // : separa la variable del array
            ana.sumar(p);                         // () llama al método
        }

        switch (ana.getPuntos()) {                // () obligatorio en switch
            case 60:                              // : cierra la etiqueta del case
                System.out.println(ana.nombre + " sumó los tres valores");
                break;
            default:
                System.out.println("total inesperado: " + ana.getPuntos());
                break;
        }

        System.out.println("primer valor: " + tabla[0]);  // [] indexa
    }
}

bashbash

javac Jugador.java
java Jugador

texttext

Ana sumó los tres valores
primer valor: 10

Si puedes leer ese programa y decir en voz alta qué hace cada símbolo en cada línea, esta sección cumplió su trabajo.

Hasta aquí llega esta sección

Repasando el camino: empezaste por qué es Java y cómo se compila, seguiste con variables y tipos y control de flujo, empaquetaste comportamiento en métodos y agrupaste datos en arrays y ArrayList.

De ahí en adelante construiste tus propios tipos: clases y objetos, los cerraste con encapsulación, los relacionaste con herencia y polimorfismo, los hiciste compartir capacidades con interfaces, les diste identidad con toString y equals, entendiste static y final, y aprendiste a que fallen con criterio usando excepciones.

Con eso ya puedes leer y escribir programas completos en Java, y entender por qué el lenguaje se comporta como se comporta en vez de memorizar recetas. El paso natural después de esto es un framework como Spring (para backends web) o Android (para apps móviles) — ahí vas a reconocer casi todo lo que viste aquí, con una capa extra encima que resuelve gran parte de la ceremonia manual.