What do you do when a subclass can't implement an interface method because the superclass has a final method with the same signature?

Question

Let's say you have a class that extends Activity and implements MyInterface, where Activity contains public final void setProgress(int progress) and MyInterface contains public abstract void setProgress(int progress)

I need to override the method from the interface, but I can't because Activty says it's final and can't be overridden.

What do I do?

Example:

public class MyActivity extends Activity implements MyInterface
{
  @Override
  protected void onCreate(Bundle bundle)
  {
    //stuff goes here
  }
  //Cannot override the final method from Activity
  @Override
  public void setProgress(int progress)
  {
  }

}

Let's also extend this question and say you don't have access to the source of MyInterface to change it, what does one do in such situations?

Answer 1

Use a decorator Design Pattern.

and here's a simplified example of the decorator pattern. (adapted from the interwebs and polygenelubricants' answer on SO)

Note: before we begin remove the abstract keyword from the interface, that's wrong syntax

The class hierarchy is restructured as static inner classes so that the whole example is contained in one compilation unit (as seen on ideone.com):

Here's a diagrammatic overview of intended class hierarchy

public class AnimalDecorator {

    static interface Animal {
        public String makeNoise();
            public void wagTail();
            //other methods
    }   
    static class Dog implements Animal {
        public final String makeNoise() { return "woof"; }
        public final void wagTail() { //do wag tail action }
    }
    static class DogDecorator implements Animal {
            //delegate
            private Animal animal;

            public DogDecorator (Animal animal){this.animal = animal;}
        public String makeNoise() { animal.makeNoise();}
            public void wagTail() { animal.wagTail();}

    }

    static class LoudDog extends DogDecorator {
        @Override public String makeNoise() {
            return "WOOF WOOF WOOF!!!";
        }
    }
}

So here we have a simple Animal hierarchy, with Dog subclass. We also have a DogDecorator decorator -- also an Animal -- that simply delegates all methods to another Animal. That is, it doesn't really do any effective decoration, but it's ready to be subclassed so that actual decorations can be added.

We only have two methods here, makeNoise() and wagTail(). We then create the class we want LoudDog and use it. (Consider the case where Animal has many methods; then Normal would be most valuable).

Note that we can even stack one decoration on top of another. The exact implementation details may vary, but this simplified example pretty much captures the essence of the decorator pattern.

---

Steps

1. Subclass the original "Component" class into a "Decorator" class (see UML diagram);
2. In the Decorator class, add a Component pointer as a field;
3. Pass a Component to the Decorator constructor to initialize the Component pointer;
4. In the Decorator class, redirect all "Component" methods to the "Component" pointer; and
5. In the ConcreteDecorator class, override any Component method(s) whose behavior needs to be modified.

See also

• Effective Java 2nd Edition, Item 18: Prefer interfaces to abstract classes

Related questions

• Interface vs Abstract Class (general OO)
• Is it just me or are interfaces overused?

Answer 2

Edit:

In this case, the class cannot override the final method. So either your interface will have the exact same signature as the parent class (hence the interface is implemented automatically by inheritance), or you create a method with a different name.

The solution would largely depend on the circumstances, there's no textbook solution here.

Answer 3

You cannot override the final method because in the Java programming language, the final keyword is used to define an entity which cannot later be changed.

form Java Language Specification

Answer 4

Never tried but can give it a try. You must implement the MyInterface in subclass too and can override the setProgress method of MyInterface and not of its superclass.

Should say..a good question:)

Answer 5

Don't have your MyActivity implement MyInterface and instead create anonymous or inner class that implements it.

This ways you still have access to all MyActivity components and functions from setProgress(int) which is completly separate from final Activity.setProgress(int).