¿Qué significan las llaves en Java por sí mismas?

Tengo un código Java que usa llaves de dos maneras

// Curly braces attached to an 'if' statement:
if(node.getId() != null)
{
    node.getId().apply(this);
}

// Curly braces by themselves:
{
    List<PExp> copy = new ArrayList<PExp>(node.getArgs());
    for(PExp e : copy)
    {
        e.apply(this);
    }
}
outAMethodExp(node);

¿Qué significan esas llaves independientes después de la primera ifdeclaración?

El único propósito de las llaves adicionales es proporcionar un límite de alcance. El List<PExp> copysolo existirá dentro de esos soportes y no tendrá alcance fuera de ellos.

Si se trata de un código generado, supongo que el generador de código hace esto para que pueda insertar algún código (como este) sin tener que preocuparse por cuántas veces ha insertado un List<PExp> copyy sin tener que preocuparse por la posibilidad de cambiar el nombre de las variables si este fragmento se inserta en el mismo método más de una vez.

Secundo lo que escribió Matt b, y agregaré que otro uso que he visto de llaves anónimas es declarar un constructor implícito en clases anónimas. Por ejemplo:

  List<String> names = new ArrayList<String>() {
    // I want to initialize this ArrayList instace in-line,
    // but I can't define a constructor for an anonymous class:
      {
        add("Adam");
        add("Eve");
      }

  };

Algunos marcos de pruebas unitarias han llevado esta sintaxis a otro nivel, lo que permite que funcionen algunas cosas ingeniosas que parecen totalmente incompilables. Dado que no parecen familiares, yo mismo no soy un gran admirador, pero vale la pena reconocer al menos lo que está sucediendo si se encuentra con este uso.

Estoy de acuerdo con la respuesta del límite de alcance, pero agregaría una cosa.

A veces ves una construcción como esa en el código de personas a las que les gusta doblar secciones de su código y tienen editores que doblan llaves automáticamente. Lo usan para plegar su código en secciones lógicas que no caen en una función, clase, bucle, etc. que normalmente se plegaría.

De hecho, supongo que alguien olvidó una declaración else.

Rara vez hay una buena razón para molestarse en crear ámbitos de bloque adicionales. En este, y en la mayoría de los casos, es mucho más probable que alguien haya olvidado escribir su declaración de control que que estaba haciendo algo inteligente.

Hacen un alcance interior. La variable declarada dentro de estas llaves no es visible fuera de ellas. Esto también se aplica a C / C ++.

Las llaves también son útiles para reducir el alcance en declaraciones switch / case.

switch(foo) {
  case BAR:
     int i = ...
     ...
  case BAZ:
     int i = ... // error, "i" already defined in scope
}

Pero puedes escribir

switch(foo) {
  case BAR:{
     int i = ...
     ...
  }
  case BAZ:{
     int i = ... // OK
  }
}

También se utiliza para bloques de inicialización .

Definen un nuevo alcance, lo que significa que todo lo declarado en este alcance no es visible fuera de las llaves.

Como nota interesante: las llaves en realidad permiten una clase de declaraciones: declaraciones.

Esto es ilegal: if(a) int f;

pero esto es legal: if(a) { int f; }

Creo que simplemente definen un nivel de alcance sin nombre.

La copia de traer un alcance no será visible fuera de ella, por lo que puede declarar otra variable con el mismo nombre más adelante. Y el recolector de basura puede recopilarlo justo después de salir de ese alcance. En este caso, copy sirve como variable temporal, por lo que es un buen ejemplo.