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

StackOverflow https://stackoverflow.com/questions/241088

Pregunta

Tengo un código Java que utiliza 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? if ¿Qué significa la declaración?

¿Fue útil?

Solución

El único propósito de las llaves adicionales es proporcionar un límite de alcance.El List<PExp> copy solo existirá dentro de esas llaves y no tendrá alcance fuera de ellas.

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

Otros consejos

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 incompatibles. Como parecen desconocidos, yo tampoco soy un gran admirador, pero vale la pena reconocer al menos lo que está sucediendo si te encuentras con este uso.

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

A veces se ve una construcción así en el código de las personas a las que les gusta doblar secciones de su código y tienen editores que doblarán llaves automáticamente. Lo usan para plegar su código en secciones lógicas que no se incluyen en una función, clase, bucle, etc. que generalmente se plegarían.

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 de lo que está haciendo algo inteligente.

Hacen un alcance interno. La variable declarada dentro de estos aparatos no es visible fuera de ellos. Esto también se aplica a C / C ++.

Las llaves también son útiles para reducir el alcance en las declaraciones de cambio / caso. 

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 usa 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 solo definen un nivel de alcance sin nombre.

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

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top