Lo que realmente sucede (es decir, lo que genera el compilador a partir de las clases)

"¡Hola, amigo! Aquí hay más información para ti".

"Ya te dije que el compilador en realidad convierte todas las clases anónimas en clases internas ordinarias".

"Sí. Incluso recuerdo que sus nombres son números: 1, 2, 3, etc."

"Exactamente. Pero hay otro matiz aquí".

"Si una clase se declara dentro de un método y usa alguna de sus variables, las referencias a esas variables se agregarán a la clase generada. Compruébelo usted mismo".

"Empezamos con esto:"

class Car
{
 public ArrayList createPoliceCars(int count)
 {
  ArrayList result = new ArrayList();

  for(int i = 0; i < count; i++)
  {
 final int number = i;
   result.add(new Car()
    {
     public String toString()
     {
      return ""+number;
     }
    });
  }
  return result;
 }
}

"Y el compilador genera esto:

class Car
{
 public ArrayList createPoliceCars(int count)
 {
  ArrayList result = new ArrayList();

  for(int i = 0; i < count; i++)
  {
   final int number = i;
   result.add(new Anonymous2 (number));
  }
   return result;
  }

 class Anonymous2
 {
  final int number;
  Anonymous2(int number)
 {
  this.number = number;
 }

  public String toString()
  {
   return ""+ number;
  }
 }
}

"¿Entendió el punto? La clase interna no puede cambiar la variable local del método, porque para cuando se ejecuta el código de la clase interna, es posible que estemos saliendo del método por completo".

"Ahora el segundo punto. El método toString() usa una variable pasada. Para lograr esto, fue necesario:"

A) guardarlo dentro de la clase generada

B) agregarlo al constructor.

"Entendido. Las clases declaradas dentro de los métodos siempre usan copias de variables".

"¡Exactamente!"

"Entonces tiene sentido por qué las variables deben ser definitivas. Y por qué no se pueden cambiar. Si en realidad estás trabajando con copias en lugar de los originales, el usuario no entenderá por qué no puede cambiar los valores de las variables, lo cual significa que tenemos que prohibirle que los cambie".

"Correcto, declarar las variables como final parece un pequeño precio a pagar a cambio de que el compilador genere una clase para ti, se la pase al método y guarde todas las variables del método que quieras usar".

"Estoy de acuerdo. Las clases locales anónimas siguen siendo geniales".

"Si declaro una clase local dentro de un método y uso las variables del método en él, ¿el compilador también las agregará a la clase?"

"Sí, los agregará a la clase y su constructor".

"Es lo que pensaba."