如何避免实现所有方法

Question

I'm using an interface for a callback that I use in a lot of classes, so when I implement this callback I need to override all methods, but I only used 1 or 2 of then from class. How I can avoid this?

This is the callback:

public interface DatabaseCallback {

    void onContactPhotoSaved();

    void onContactPhotoUpdated();

    void onContactPhotoDeleted();

    void onContactPhotoFounded(ContactInfo item);

    void onDataNotAvailable();

    void onErrorDuringProcess();

    void onContactPhotoLoaded(List<ContactInfo> users);

}

EDIT:

This is possible??

public class DatabaseManagerCallback {

public interface ContactInfoInsertCallback{
    void onContactPhotoSaved();
    void onErrorOcurred();
}

public interface ContactInfoUpdateCallback{
    void onContactPhotoUpdated();
    void onErrorOcurred();
}

public interface ContactInfoDeleteCallback{
    void onContactPhotoDeleted();
    void onErrorOcurred();
}

public interface ContactInfoFoundedCallback{
    void onContactPhotoFounded(ContactInfo item);
    void onErrorOcurred();
}

}

Answer 1

Write a class that implements all the functions but has an empty body for each. Then extend your classes from that, so they inherit the empty body functions.

If you're the owner of the interface class you can also consider giving them a default do nothing implementation. But if its a library class that won't work.

Answer 2

There are only two things you can do with an interface implementation in Java language:

• Implement all methods (as you say).
• Implement only a few methods and declare the class abstract (and, therefore, you cannot instance it).

Depending on what you want to do, you can create a class which implements all the methods with some kind of default behavior, and then override the methods you need to define in each case.

Answer 3

You can create a class which implements all the methods and then inherit from it:

public class MyDatabaseCallback implements DatabaseCallback{

    @Override void onContactPhotoSaved(){}

    @Override void onContactPhotoUpdated(){}

    @Override void onContactPhotoDeleted(){}

    @Override void onContactPhotoFounded(ContactInfo item){}

    @Override void onDataNotAvailable(){}

    @Override void onErrorDuringProcess(){}

    @Override void onContactPhotoLoaded(List<ContactInfo> users){}

}

Now, all you have to do is inherit from MyDatabaseCallback :

public class MyCustomDatabaseCallback extends MyDatabaseCallback {
    @Override void onDataNotAvailable(){
        // TODO
    }
}

Answer 4

You can add default implementations in your interface, so you won't need to override all the methods:

public interface DatabaseCallback {

    default void onContactPhotoSaved() {}

    default void onContactPhotoUpdated() {}

    default void onContactPhotoDeleted() {}

    default void onContactPhotoFounded(ContactInfo item) {}

    default void onDataNotAvailable() {}

    default void onErrorDuringProcess() {}

    default void onContactPhotoLoaded(List<ContactInfo> users) {}

}

This will allow you to extend another class with your implementation if needed.

If the interface comes from a library and you're not able to modify it, you can create an intermediate interface that extends the first one and adds the default implementations. Then you implement your interface.

public interface MyDatabaseCallback extends DatabaseCallback {

    @Override default void onContactPhotoSaved() {}

    @Override default void onContactPhotoUpdated() {}

    @Override default void onContactPhotoDeleted() {}

    @Override default void onContactPhotoFounded(ContactInfo item) {}

    @Override default void onDataNotAvailable() {}

    @Override default void onErrorDuringProcess() {}

    @Override default void onContactPhotoLoaded(List<ContactInfo> users) {}

}