Implementing Super and sub interfaces both in a class(class A implements SuperInterface, SubInterface)

Question

interface A {

    public void doSomething();
}

interface B extends A {

    public void doSomethingElse();
}

public class AClass implements A, B {

    public void doSomething() {}

    public void doSomethingElse() {}

}

Why does Java permit such a declaration? What's the use of implementing both interfaces when same thing can be achieved by implementing the SubInterface (B)?

possible duplicate of [Why would both a parent and child class implement the same interface?](http://stackoverflow.com/questions/5668429/why-would-both-a-parent-and-child-class-implement-the-same-interface) — Kate Gregory, Jan 23 '13 at 16:59

score 6 · Accepted Answer · edited May 23 '17 at 12:26

I think the "why" question can only be answered by Java designers.

One reason might be that it permits retrofitting extends A to B without breaking any existing classes that already happen to implement both.

Another reason for using this construct might be to make it immediately clear to the end user of AClass that the class implements both A and B. This is discussed in Redundant implementation of List interface in ArrayList.java

Ted Hopp · Answer 2 · 2013-01-23T16:10:10.990

This is simply a convenience. It can be difficult to track what the interface structure is, and would be onerous on a programmer to have to track it all down. Besides, no good can come from not permitting redundant interfaces: implementing an interface multiple times may be unavoidable. For example:

interface A { ... }
interface B extends A { ... }
interface C extends A { ... }
public class AClass implements B, C { ... }

In this case, A is "implemented" twice, but that's no problem. It simply means that AClass must implement each method declared in A, B, and C.

score 2 · Answer 3 · answered Jan 23 '13 at 16:14

2

Had this been an error, adding a base interface to an existing public interface would have been a breaking change.
(in case client code has a class that already implements both interfaces)

answered Jan 23 '13 at 16:14

SLaks

868,454
176
1,908
1,964

score 1 · Answer 4 · answered Jan 23 '13 at 16:06

1

1) Why not implementing A twice is redundant but leads to no confusion.

2) interface B may be changed (and may no longer extending A). AClasswould still implement A and B

answered Jan 23 '13 at 16:06

MrSmith42

9,961
6
38
49

score 0 · Answer 5 · answered Jan 06 '21 at 22:07

Redundant inheritance declarations have an effect on certain reflection calls.

interface One {}
interface Two extends One {}
static class Three implements Two {}
static class Four implements One, Two {}

public static void main(String... args) {
    Three three = new Three();
    Four four = new Four();
    System.out.println(Arrays.toString(three.getClass().getInterfaces()));  // [Two]
    System.out.println(Arrays.toString(four.getClass().getInterfaces()));  // [One, Two]
}

This probably isn't a reason to design your classes in a certain way, but demonstrates that it does have an effect at runtime.

Implementing Super and sub interfaces both in a class(class A implements SuperInterface, SubInterface)

5 Answers5

Linked

Related