¿Cómo puedo reutilizar una clase interna en Java / Android?

Soy un desarrollador de C # mucho tiempo (8 años) dabbling en un poco desarrollo androide. Esta es la primera vez que he utilizado Java y estoy teniendo un pequeño problema cambiando mi mentalidad cuando se trata de clases internas.

Estoy tratando de escribir una clase para envolver una API RESTful para ejecutar varias llamadas en el servidor desde un lugar typesafe, por ejemplo

string jsonResult = APIWrapper.getItems("category 1");

Y quiero usar un AsyncTask para obtener cosas en segundo plano.

Así que una forma es esto: tener el AsyncTask en el APIWrapper:

 class ActivityA extends Activity { myButton.setOnClickListener(new OnClickListener() { public void onClick(View v) { //get stuff and use the onPostExecute inside the APIWrapper new APIWrapper().GetItems("Category A", MyGetItemsCallBack); }}); function void MyGetItemsCallBack(String result) { //render the result in the activity context, in a listview or something } }

¡No estoy seguro de que la idea de devolución de llamada / delegado funcione en Java de todos modos!

La otra manera es tener el AsyncTask en la actividad y crear el APIWrapper para obtener los datos como un trabajador / auxiliar:

 class ActivityA extends Activity { myButton.setOnClickListener(new OnClickListener() { public void onClick(View v) { //get stuff and use the onProcessComplete inside the APIWrapper new GetItems("Category A"); }}); class GetItems(String theCategory) extends AsyncTask { doInBackground() { return new APIWrapper().GetItems(theCategory); } onPostExecute(String result) { //render the result in the activity context, in a listview or something } } }

¿Puede alguien ayudarme a tomar la decisión correcta?

Java no tiene algo como delegados de C #, por lo que su primera propuesta no es posible tal cual.

La solución estándar es declarar una interfaz que se puede pasar como una devolución de llamada:

 public interface MyCallback { void gotItems(String data); }

Entonces usted puede hacer algo como

 class ActivityA extends Activity { myButton.setOnClickListener(new OnClickListener() { public void onClick(View v) { //get stuff and use the onPostExecute inside the APIWrapper new APIWrapper().getItems("Category A", new MyGetItemsCallBack()); }}); private class MyGetItemsCallBack implements MyCallback { public void gotItems(String result) { // bla bla bla } } }

O puede utilizar una clase anónima:

 class ActivityA extends Activity { myButton.setOnClickListener(new OnClickListener() { public void onClick(View v) { //get stuff and use the onPostExecute inside the APIWrapper new APIWrapper().getItems("Category A", new MyCallback() { public void gotItems(String result) { // bla bla bla } }); }});

Si necesita muchos tipos diferentes de devoluciones de llamada, puede usar genéricos para evitar tener que declarar muchas interfaces pequeñas:

 interface Callback<T> { void run(T arg); } class ActivityA extends Activity { myButton.setOnClickListener(new OnClickListener() { public void onClick(View v) { //get stuff and use the onPostExecute inside the APIWrapper new APIWrapper().getItems("Category A", new Callback<String>() { public void run(String result) { // bla bla bla } }); }});

La clase interna regular tiene referencia a un objeto de clase externa, por lo que su instancia no puede ser creada sin clase externa. Significa que las clases internas no pueden ser reutilizadas fuera de la clase externa.

Las clases internas anónimas que está utilizando no pueden reutilizarse con seguridad: se crean en el contexto del método externo.

Sin embargo, puede definir la clase interna como estática. En este caso, puedes usarlo desde cualquier parte de tu código.

Pero en su caso, creo que la mejor solución es lo que usted sugirió como una solución 2. Simplemente crear una clase por separado, por lo que será capaz de utilizarlo desde cualquier parte de su código.