可以使用默认方法实现来在基类中实现抽象方法

Question

If I have a class with an abstract method:

abstract class Base {
    abstract void foo();
}

and an interface that declares the same method with a default implementation:

interface Inter {
     default void foo() {
         System.out.println("foo!");
     }
}

do I need to provide an implementation in a class that implements/extends both?

class Derived extends Base implements Inter {

}

It seems like this should work, but I get a compilation error that Derived is not abstract and does not override the abstract method foo .

I am guessing that the abstract method from the class is "more important" than the default method from the interface.

Is there a good way to make this work?

My underlying problem is that I have a three level abstract class hierarchy ( A and B extend C , D and E extend F , C and F extend G ), which will have multiple implementations of the leaf classes. Within each set of implementations, there are common methods being implemented that are defined in the base classes, so I hoped to write

abstract class C extends G {
     abstract void foo();
     abstract void bar();
     abstract void quz();
     void baz() {
         foo();
         bar();
     }
}

abstract class A extends C {
    void quz() { /* impl */ }
}
abstract class B extends C {
    void quz() { /* different impl */ }
}

interface C1 {
     default void foo() { /* impl for first set of classes */ }
}
class A1 extends A implements C1 {
     @Override void bar() { ... }
     // foo implementation from C1
}
class B1 extends B implements C1 {
     @Override void bar() { ... }
}

interface C2 {
     default void foo() { /* impl for second set of classes */ }
}
class A2 extends A implements C2 {
     @Override void bar() { ... }
     // foo implementation from C2
}
class B2 extends B implements C2 {
     @Override void bar() { ... }
}

Answer 1

Just call the default method from your concrete class:

@Override
public void foo() {
    Inter.super.foo();
}