Sintaxis de Java

La sintaxis de Java es lo que le da forma a un archivo .java: dónde terminan las sentencias, cómo se agrupan los bloques de código, qué palabras tienen un significado especial para el compilador y qué caracteres son válidos en un nombre. Estas reglas se verifican en tiempo de compilación — javac se niega a producir un archivo .class hasta que todas se cumplan — por lo que aprenderlas bien desde el principio te ahorrará muchos errores confusos más adelante.

Este capítulo cubre las reglas en las que te apoyarás durante el resto del libro: la estructura de un archivo fuente, sentencias, bloques, identificadores, palabras clave, comentarios, sensibilidad a mayúsculas y espacios en blanco.

Un archivo fuente Java completo

Todo programa Java independiente necesita al menos una clase con un método main. Este es el archivo mínimo:

public class App {
    public static void main(String[] args) {
        System.out.println("Hello, syntax!");
    }
}

Hay tres cosas que suceden en la página:

• La declaración de clase public class App { ... } envuelve todo dentro de una clase.
• La declaración de método public static void main(String[] args) { ... } es el punto de entrada del programa.
• La sentencia System.out.println(...) realiza el trabajo.

El archivo debe guardarse como App.java porque la clase pública se llama App. Esta es una regla estricta: un archivo fuente puede contener como máximo una clase public, y el nombre del archivo debe coincidir exactamente con el nombre de esa clase, incluidas las mayúsculas. Consulta Java Hello World para ver el ciclo completo de compilación y ejecución.

Las sentencias terminan con punto y coma

Una sentencia Java es una instrucción que le indica al programa que haga algo. Cada sentencia termina con un punto y coma:

int score = 0;
score = score + 5;
System.out.println(score);

Debido a que el punto y coma — no el salto de línea — es lo que termina una sentencia, puedes distribuir una sentencia larga en varias líneas o (con menos legibilidad) poner varias sentencias en una sola línea:

int total = 1 + 2 + 3
          + 4 + 5;        // one statement, two lines
int a = 1; int b = 2;     // two statements, one line

Olvidar el punto y coma es el error más común para los principiantes. El compilador señalará la línea donde detectó el problema, que generalmente es la línea siguiente a la que realmente le falta el punto y coma — por lo tanto, cuando veas "';' expected", revisa la línea anterior a la señalada.

Los bloques agrupan sentencias

Las llaves { y } agrupan sentencias en un bloque. Los cuerpos de clases, métodos, bucles e instrucciones if son todos bloques:

public class Counter {        // class block opens
    public static void main(String[] args) {   // method block opens
        for (int i = 0; i < 3; i++) {          // loop block opens
            System.out.println(i);
        }                                       // loop block closes
    }                                           // method block closes
}                                               // class block closes

La indentación no forma parte de la sintaxis (el compilador ignora los espacios en blanco), pero todo lector esperará cuatro espacios por bloque anidado. La mayoría de los IDE lo formatean automáticamente al guardar.

Identificadores

Un identificador es cualquier nombre que elijas — para una clase, un método, una variable o una constante. Las reglas:

• Comienza con una letra, _ o $.
• Después del primer carácter, también puede contener dígitos.
• Distingue entre mayúsculas y minúsculas: total y Total son nombres diferentes.
• No puede ser una palabra clave reservada (class, int, return, etc.).
• Sin límite de longitud.

Válidos: total, lineCount, _temp, $jquery, userName2. No válidos: 2lines (comienza con dígito), line-count (guión), class (palabra clave).

Esas son las reglas que aplica el compilador. Además de ellas, Java tiene convenciones de nomenclatura estrictas que el compilador ignora, pero que todo desarrollador Java espera:

• Las clases usan UpperCamelCase — BankAccount, HttpServer.
• Los métodos y variables usan lowerCamelCase — accountBalance, parseInput.
• Las constantes usan UPPER_SNAKE_CASE — MAX_SIZE.

Seguirlas no es opcional en la práctica. El capítulo Java Variables profundiza en la nomenclatura y declaración de datos.

Palabras clave

Java reserva aproximadamente 50 palabras para el propio lenguaje. No puedes usarlas como identificadores. Las que verás con más frecuencia:

abstract  case      do        finally    int         private     synchronized  throws
assert    catch     double    float      interface   protected   this          transient
boolean   char      else      for        long        public      throw         try
break     class     enum      if         new         return      void          while
byte      continue  extends   import     null        short       volatile      switch

Además de algunas palabras clave contextuales añadidas en versiones modernas de Java que solo son especiales en ciertas posiciones (var, yield, record, sealed, permits).

Sensibilidad a mayúsculas y minúsculas

Java distingue entre mayúsculas y minúsculas en todas partes — nombres de clases, métodos, variables y palabras clave. System no es lo mismo que system, e if no es lo mismo que If. El compilador te indicará "cannot find symbol" si escribes mal un nombre.

Espacios en blanco y saltos de línea

Los espacios, tabulaciones y saltos de línea entre tokens son equivalentes. Al compilador no le importa si escribes:

int x=1+2;

o:

int x = 1 + 2;

Usa lo que sea más legible; la hoja de estilo estándar (y el formateador de tu IDE) te darán la respuesta correcta.

El único lugar donde los espacios en blanco sí importan es dentro de literales de cadena y de carácter: "Hello world" y "Helloworld" son valores diferentes, y los espacios entre ellos se conservan exactamente como se escribieron.

Comentarios

Un comentario es texto que el compilador ignora por completo. Java tiene tres formas:

// line comment — runs to the end of the line

/* block comment —
   can span multiple lines */

/**
 * Javadoc comment — a block comment whose first character
 * is an extra asterisk. Tools generate API docs from these.
 */

Usa comentarios para explicar el por qué de algo, no para reafirmar qué hace el código de forma obvia. El capítulo Java Comments cubre cada forma y cuándo usarla.

Un programa que ejercita las reglas

Observa que cada sentencia termina con ;, los cuerpos de la clase y del método son bloques { ... }, los nombres x, y y product son identificadores válidos, y el archivo se guardaría como Demo.java.

Qué sigue

El siguiente capítulo, Java Output, cubre los tres métodos de impresión (print, println, printf) que usarás para inspeccionar lo que hacen tus programas. A partir de ahí, Java Data Types explica qué tipos de valores pueden contener tus identificadores.

Práctica