Explicitly calling a default method in Java
Solution 1
As per this article you access default method in interface A
using
A.super.foo();
This could be used as follows (assuming interfaces A
and C
both have default methods foo()
)
public class ChildClass implements A, C {
@Override
public void foo() {
//you could completely override the default implementations
doSomethingElse();
//or manage conflicts between the same method foo() in both A and C
A.super.foo();
}
public void bah() {
A.super.foo(); //original foo() from A accessed
C.super.foo(); //original foo() from C accessed
}
}
A
and C
can both have .foo()
methods and the specific default implementation can be chosen or you can use one (or both) as part of your new foo()
method. You can also use the same syntax to access the default versions in other methods in your implementing class.
Formal description of the method invocation syntax can be found in the chapter 15 of the JLS.
Solution 2
This answer is written mainly for users who are coming from question 45047550 which is closed.
Java 8 interfaces introduce some aspects of multiple inheritance. Default methods have an implemented function body. To call a method from the super class you can use the keyword super
, but if you want to make this with a super interface it's required to name it explicitly.
class ParentClass {
public void hello() {
System.out.println("Hello ParentClass!");
}
}
interface InterfaceFoo {
public default void hello() {
System.out.println("Hello InterfaceFoo!");
}
}
interface InterfaceBar {
public default void hello() {
System.out.println("Hello InterfaceBar!");
}
}
public class Example extends ParentClass implements InterfaceFoo, InterfaceBar {
public void hello() {
super.hello(); // (note: ParentClass.super could not be used)
InterfaceFoo.super.hello();
InterfaceBar.super.hello();
}
public static void main(String[] args) {
new Example().hello();
}
}
Output:
Hello ParentClass!
Hello InterfaceFoo!
Hello InterfaceBar!
Solution 3
The code below should work.
public class B implements A {
@Override
public void foo() {
System.out.println("B.foo");
}
void aFoo() {
A.super.foo();
}
public static void main(String[] args) {
B b = new B();
b.foo();
b.aFoo();
}
}
interface A {
default void foo() {
System.out.println("A.foo");
}
}
Output:
B.foo
A.foo
Solution 4
You don't need to override the default method of an interface. Just call it like the following:
public class B implements A {
@Override
public void foo() {
System.out.println("B.foo");
}
public void afoo() {
A.super.foo();
}
public static void main(String[] args) {
B b=new B();
b.afoo();
}
}
Output:
A.foo
GOTO 0
My private activities are currently focused on the development of programming language tools and the instrumentation of web technologies. I'm a Node.js fan. See also my profile on GitHub.
Updated on April 24, 2021Comments
-
GOTO 0 about 3 years
Java 8 introduces default methods to provide the ability to extend interfaces without the need to modify existing implementations.
I wonder if it's possible to explicitly invoke the default implementation of a method when that method has been overridden or is not available because of conflicting default implementations in different interfaces.
interface A { default void foo() { System.out.println("A.foo"); } } class B implements A { @Override public void foo() { System.out.println("B.foo"); } public void afoo() { // how to invoke A.foo() here? } }
Considering the code above, how would you call
A.foo()
from a method of class B?-
Maciej Cygan over 10 yearsCan you tell me why you have implementation to your foo() method inside you interface A ??.
-
Rohit Jain over 10 years@MaciejCygan It's allowed in Java 8
-
-
Sergey Kalinichenko over 10 yearsOP says: "[is it] possible to explicitly invoke the default implementation of a method when that method has been overridden"
-
gvlasov about 9 yearsAlso note that if
A extends SomeOtherInterface
, andSomeOtherInterface
hasdefault Type method()
, then you can't just callSomeOtherInterface.super.method()
from ChildClass. You can only call default methods of interfaces enumerated in theChildClass
'simplements
clause, not their parent interfaces' methods. -
Richard Tingle about 9 years@Suseika good point, the same as there is no
super.super.someMethod();
(because that would be horrible) -
Raaghu over 6 years@gvlasov good point , but how to access a parent interface's default method from a child interface , is it possible ?? Update.......... Yes Possible , the more concrete explanation here stackoverflow.com/a/24280376/3791156
-
Hemanth Peela over 5 yearsI think this is best example which describes the above question. Thanks
-
Gaurav almost 5 years@RichardTingle flawless answer!
-
tejasvi88 almost 3 yearsWhat is the rationale behind
Interface.super.method()
? Why not simplyInterface.method()
? -
Richard Tingle almost 3 years@tejasvi88
Interface.method()
would imply a static method inInterface
. It is a "kind of super" so the super part is arguably the most important