Generics question

[Malcolm Ryan]

I have a question about generics.

Say I have an interface:

interface Copyable<T> {
T copy();
}

and a pair of classes:

class Parent implements Copyable<Parent> {

Parent copy() {
....
}
}

class Child extends Parent {

Child copy() {
....
}
}

Because of type erasure, I can't indicate that Child implements
Copyable<Child> as well as Copyable<Parent>. Which is a problem because
I have another class which expects its type parameter to be Copyable:
and a class which expects Copyable things:

class Processor<T extends Copyable<T>> {
T process(T thing) {
T copy = thing.copy();
// .. do stuff with copy
return copy;
}
}

Now I can make a Processor<Parent> but not a Processor<Child>, which is
frustrating if I want to specify that some subclass of Processor only
works on Child. Is there any way to get around this?

Malcolm

 

[Thomas Hawtin]

interface Copyable<T> {
T copy();
}
class Parent implements Copyable<Parent> {
Parent copy() {

class Child extends Parent {
Child copy() {

Because of type erasure, I can't indicate that Child implements
Copyable<Child> as well as Copyable<Parent>. Which is a problem because

In general it's best to keep non-leaf classes abstract. So you get:

abstract class AbstractNode<THIS>
implements Copyable<THIS extends Parent<THIS>>

class Parent extends AbstractNode<Parent>

class Child extends AbstractNode<Child>

Quite often it's more convenient not to distinguish between elements of
a tree that may be leaves and those that may not.

For instance, Swing has JComponent whereas AWT splits Component and
Container. java.awt.Choice (a combobox) is not a Container, but
JComboBox must be a container for the Basic PL&F to work.

AWT uses a class hierarchy the opposite way round from that of the
classes above. Neither approach is wrong, but neither are correct either.

Tom Hawtin