Accediendo al constructor de una clase anónima

Digamos que tengo una clase concreta Class1 y estoy creando una clase anónima.

Object a = new Class1(){ void someNewMethod(){ } }; 

Ahora, ¿hay alguna manera de sobrecargar el constructor de esta clase anónima? Como se muestra a continuación

 Object a = new Class1(){ void someNewMethod(){ } public XXXXXXXX(int a){ super(); System.out.println(a); } }; 

¿Con algo en xxxxxxxx para nombrar el constructor?

De la Especificación del lenguaje Java , sección 15.9.5.1:

Una clase anónima no puede tener un constructor declarado explícitamente.

Lo siento 🙁

EDITAR: como alternativa, puede crear algunas variables locales finales y / o incluir un inicializador de instancia en la clase anónima. Por ejemplo:

 public class Test { public static void main(String[] args) throws Exception { final int fakeConstructorArg = 10; Object a = new Object() { { System.out.println("arg = " + fakeConstructorArg); } }; } } 

Es desagradable, pero podría ayudarte. Alternativamente, usa una clase anidada apropiada 🙂

Eso no es posible, pero puede agregar un inicializador anónimo como este:

 final int anInt = ...; Object a = new Class1() { { System.out.println(anInt); } void someNewMethod() { } }; 

No olvide las declaraciones finales de las variables locales o los parámetros utilizados por la clase anónima, como lo hice para anInt.

Aquí hay otra forma de resolver el problema:

 public class Test{ public static final void main(String...args){ Thread t = new Thread(){ private String message = null; Thread initialise(String message){ this.message = message; return this; } public void run(){ System.out.println(message); } }.initialise(args[0]).start(); } } 

Sé que el hilo es demasiado viejo para publicar una respuesta. Pero aún así creo que vale la pena.

Aunque no puede tener un constructor explícito, si su intención es llamar al constructor de la superclase, lo siguiente es todo lo que tiene que hacer.

 StoredProcedure sp = new StoredProcedure(datasource, spName) { {// init code if there are any} }; 

Este es un ejemplo de creación de un objeto StoredProcedure en Spring al pasar un DataSource y un objeto String .

Entonces, en resumen, si desea crear una clase anónima y desea llamar al constructor de la superclase, cree la clase anónima con una firma que coincida con el constructor de la superclase .

Puede tener un constructor en la clase abstracta que acepte los parámetros init. La especificación de Java solo especifica que la clase anónima, que es la descendencia de la clase abstracta (opcionalmente) o la implementación de una interfaz, no puede tener un constructor por derecho propio.

Lo siguiente es absolutamente legal y posible:

 static abstract class Q{ int z; Q(int z){ this.z=z;} void h(){ Q me = new Q(1) { }; } } 

Si tiene la posibilidad de escribir la clase abstracta usted mismo, coloque un constructor allí y use una API fluida donde no haya una mejor solución. De esta manera puede anular el constructor de su clase original creando una clase de hermanos nombrada con un constructor con parámetros y usar eso para instanciar su clase anónima.

Sí, es correcto que no puedas definir constructo en una clase anónima, pero eso no significa que la clase anónima no tenga constructor. Confunde … En realidad, no puedes definir construir en una clase Anónima, pero el comstackdor genera un constructor para él con la misma firma que su constructor padre llamado. Si el padre tiene más de un constructor, el anónimo tendrá uno y solo un constructor

Si no necesita pasar argumentos, entonces el código del inicializador es suficiente, pero si necesita pasar argumentos de un contribuyente, hay una manera de resolver la mayoría de los casos:

 Boolean var= new anonymousClass(){ private String myVar; //String for example @Overriden public Boolean method(int i){ //use myVar and i } public String setVar(String var){myVar=var; return this;} //Returns self instane }.setVar("Hello").method(3); 

IAQ de Java de Peter Norvig: Preguntas poco frecuentes

http://norvig.com/java-iaq.html#constructors – Constructores de clase anónimos

http://norvig.com/java-iaq.html#init – Construtors e inicialización

En resumen, puedes construir algo como esto …

 public class ResultsBuilder { Set errors; Set warnings; ... public Results build() { return new Results() { private Result[] errorsView; private Result[] warningsView; { errorsView = ResultsBuilder.this.getErrors(); warningsView = ResultsBuilder.this.getWarnings(); } public Result[] getErrors() { return errorsView; } public Result[] getWarnings() { return warningsView; } }; } public Result[] getErrors() { return !isEmpty(this.errors) ? errors.toArray(new Result[0]) : null; } public Result[] getWarnings() { return !isEmpty(this.warnings) ? warnings.toArray(new Result[0]) : null; } } 

No tiene ningún sentido tener un constructor con nombre sobrecargado en una clase anónima, ya que no habría manera de llamarlo, de todos modos.

Dependiendo de lo que realmente está tratando de hacer, acceder a una variable local final declarada fuera de la clase, o usar un inicializador de instancia como lo muestra Arne, podría ser la mejor solución.

En mi caso, una clase local (con constructor personalizado) funcionaba como una clase anónima:

 Object a = getClass1(x); public Class1 getClass1(int x) { class Class2 implements Class1 { void someNewMethod(){ } public Class2(int a){ super(); System.out.println(a); } } Class1 c = new Class2(x); return c; }