Java Generics and interfaces

Question

Having this design :

interface Foo<T> {
   void doSomething(T t);
}

class FooImpl implements Foo<Integer> {
   //code... 
}

interface Bar extends Foo {
   //code...
}

class BarImpl extends FooImpl implements Bar {
     //code...
}

It gives me Compile Error :

The interface Foo cannot be implemented more than once with different arguments: Foo and Foo

a simple fix for this issue is :

interface Bar extends Foo<Integer> {
 // code...
}

Integer type in Bar interface is totally useless.

is there any better way to solve this issue ? any better design?

Thanks for your advices.

EDIT:

given solution:

> interface Bar<T> extends Foo<T>

is ok, but its same as my previous solution. i don't need T type in Bar.

let me give a better sample:

interface ReadOnlyEntity {
}

interface ReadWriteEntity extends ReadOnlyEntity {
}

interface ReadOnlyDAO<T extends ReadOnlyEntity> {
}

interface ReadWriteDAO<K extends ReadWriteEntity, T extends ReadonlyEntity> extends ReadOnlyDAO<T> {
}

is this a good design?

This question cannot be answered without your actual interface names. — SLaks
– SLaks, Commented Oct 14, 2010 at 12:39
That's because generics are compile-time magic in Java (erasure), and therefore you cannot implement the same interface twice with different generic arguments. — Lucero
– Lucero, Commented Oct 14, 2010 at 12:56

duffymo · Accepted Answer · 2010-10-14 14:08:28Z

5

I'd recommend thinking of a type for the Bar generic or rethink your design. If there's no object that makes sense for Bar, then it shouldn't be implementing Foo<T>.

EDIT:

is this a good design?

No, not in my opinion.

edited Oct 14, 2010 at 14:08

answered Oct 14, 2010 at 12:41

duffymo

310k46 gold badges376 silver badges570 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Bozho · Accepted Answer · 2010-10-14 12:41:45Z

3

interface Bar<T> extends Foo<T> {
    // code...
}

class BarImpl extends FooImpl implements Bar<Integer> {
    // code...
}

However, it would be best if we know the exact semantics of your interfaces.

answered Oct 14, 2010 at 12:41

Bozho

599k147 gold badges1.1k silver badges1.2k bronze badges

Comments

Colin Hebert · Accepted Answer · 2010-10-14 12:48:03Z

2

The main problem is that you have the same interface used with two different generics; one with Integer and the other with the default Object.

The only solution is to have the exact same generic Integer.

You can do so by specifying directly interface Bar extends Foo<Integer> but if Bar isn't specifically related to a Foo<Integer> it doesn't make sense.

The other way is to generify Bar and use this generic to extend Foo :

interface Bar<T> extends Foo<T>{
    //...
}

Either way, as Bar is related to Foo; so either you specify the type for Foo in Bar (hardcode) or you must have a generic Bar.

edited Oct 14, 2010 at 12:48

answered Oct 14, 2010 at 12:41

Colin Hebert

93.5k15 gold badges164 silver badges154 bronze badges

Comments

tylermac · Accepted Answer · 2010-10-14 12:42:17Z

0

interface Bar<T> extends Foo<T> {
 // code …
}

Is this what you are looking for? A Generic bar?

"Better Way" is kind of ambiguous.

answered Oct 14, 2010 at 12:42

tylermac

4892 silver badges8 bronze badges

Comments

jwenting · Accepted Answer · 2010-10-14 12:53:55Z

0

"Integer type in Bar interface is totally useless. "

would indicate that Bar does not in fact extend Foo if the generic type is relevant there. More appropriate would be a base interface from which both Foo and Bar extend.

answered Oct 14, 2010 at 12:53

jwenting

5,6613 gold badges28 silver badges33 bronze badges

Comments

Community · Accepted Answer · 2020-06-20 09:12:55Z

0

Integer type in Bar interface is totally useless.

I don't need T type in Bar.

This indicates that something is wrong on your design, there is no need for Bar to extend Foo. By the way what would fit perfect here is multi inheritance, but Java does not support it.

Following your example it should make more sense the following:

interface ReadOnlyEntity<T> {
 /* do something with generics */
 T read();
}

interface WriteOnlyEntity {
 /* do something without generics */
 void write();
}

class abstract BaseReadWriteEntity<T> implements ReadOnlyEntity<T>, WriteOnlyEntity {
}

interface ReadOnlyDAO<T extends ReadOnlyEntity> {
}

interface ReadWriteDAO<T extends BaseReadWriteEntity> extends ReadOnlyDAO<T> {
}

edited Jun 20, 2020 at 9:12

CommunityBot

11 silver badge

answered Oct 14, 2010 at 15:01

mtrovo

8791 gold badge6 silver badges15 bronze badges

Collectives™ on Stack Overflow

Java Generics and interfaces

6 Answers 6

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related