How can I reuse an inner class in Java / Android?

Question

I'm a long time (8 years) C# developer dabbling in a little android development. This is the first time I've used Java and am having a little trouble shifting my mindset when it comes to inner classes.

I'm trying to write a class to wrap an RESTful API to execute various calls on the server from one typesafe place, e.g.

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

And I want to use a AsyncTask to get stuff in the background.

So one way is this - have the AsyncTask in the 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
 }

}

I'm not sure the callback / delegate idea works in Java anyway!

The other way is to have the AsyncTask in the Activity and create the APIWrapper to just get the data like a worker / helper:

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
    }

 }


}

Can anyone help me make the right choice?

Answer 1

Java doesn't have something like C# delegates, so your first proposal is not possible as-is.

The standard solution is to declare an interface that can be passed as a callback:

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

Then you can do something like

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
    }
  }
}

or you can use an anonymous class:

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
        }
      });
  }}); 

If you need many different kinds of callbacks you can use generics to avoid having do declare many small interfaces:

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
        }
      });
  }}); 

Answer 2

Regular inner class holds reference to object of outer class, so its instance cannot be created without outer class. It means that inner classes cannot be re-used from outside the outer class.

Anonymous inner classes you are using cannot be reused for sure: they are created in context of outer method.

You can however define inner class as static. In this case you can use it from everywhere in your code.

But you your case I think that the better solution is what you suggested yourself as a solution 2. Just create separate class, so you will be able to use it from anywhere in your code.