默认接口实现

Question

In Android, when I use AsyncTask , I usually use interface method, so that I can implement it in activity :

 public class DownloadTask extends AsyncTask<String, Integer, Response> {

private Context context;
private DownloadTaskListener listener;
private List<MyObject> objectList;


public interface DownloadObjectsTaskListener {
    void startTask();
    void finishTask();
    void ObjectsDownloaded(List<Object> ObjectList);

    void withoutInternet();
}

public DownloadObjectsTask(Context context) {
    this.context = context;
}


public void setListener(DownloadObjectsTaskListener listener) {
    this.listener = listener;
}

@Override
protected void onPreExecute() {
    super.onPreExecute();

    if (CommonUtils.isThereInternetConnection(context)) {
        listener.startTask();
    } else {
        listener.withoutInternet();
        cancel(true);
    }
}

protected Response doInBackground(String... urls) {
    RestApiObject api2 = new RestApiObject();
    return api2.getMyObjects();

}

protected void onPostExecute(Response results) {
    listener.finishTask();
    if (results != null) {
        if (results.body() != null) {
            ObjectsResponse request = (ObjectsResponse) results.body();
            ObjectList = request.getObjectsList();
            listener.ObjectsDownloaded(ObjectList);
        } else {
            ResponseBody jsonObject = results.errorBody();
            try {
                Log.d(DEBUG, jsonObject.string());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    } else {
        Log.d(DEBUG, "result is null");
    }

   }
}

And then In my Activity , I implement the interface, and define the method.

The thing is for method such as withoutInternet() , the method definition will always be the same, so it will just be redundant code each time I redefine method implementation, even if I extract code in a method.

Is there a way to define just once withoutInternet() ?

Answer 1

Sure, you want an abstract class instead of an interface. Like this:

public abstract DefaultDownloadObjectTasksListener implements DownloadObjectsTaskListener{
    abstract void startTask();
    abstract void finishTask();
    abstract void ObjectsDownloaded(List<Object> ObjectList);

    void withoutInternet(){
      //some default implementation
    }
}

And then you can extend (versus implement ) the abstract class overriding the methods you want to provide functionality for. Because the first three methods are abstract you will be required to override them. However, because withoutInternet is not abstract, the default implementation will be used, unless you choose to override it.

Edit To address your issue: the solution then would be to make your DefaultDownloadObjectTasksListener extend AppCompatActivity and implement DownloadObjectsTaskListener and then extend DefaultDownloadObjectTasksListener from your activity.

Or, really, what I would do is use an anonymous subclass as a listener if you really want a default implementation.

Answer 2

You can create a base activity that implements your interface, implement withoutInternet() , and declare the other methods as abstract. Your activities would then extend your activities from the base activity and you only need to implement the other methods.