Question

I’m not sure if I convey the question well enough and I couldn’t find a better way to do this, as I am quite new to java.

I believe the best is by way of illustration, if I have a class

public abstract class Genome
{
    abstract public Genome randomize();
    abstract public Genome mutate();
    abstract public Genome crossOver(Genome genome);
}

Can I make sure that its subclasses would always implement by using generics

public class GenomeSubclass extends Genome
{
    public GenomeSubclass randomize();
    // etc...
}

instead of the abstract methods provided in the contract?

Answer 1

The normal way would be to define it like this:

public abstract class Genome<T extends Genome<T>> {
    abstract public T randomize();
    abstract public T mutate();
    abstract public T crossOver(T genome);
}

public class GenomeSubclass extends Genome<GenomeSubclass>
{
    public GenomeSubclass randomize();
    // etc...
}

This is the approach used by Comparable (or at least most uses of Comparable) and Enum, too.

Of course, this does not avoid subclassing other subclasses.

---

Edit to detail my comment:

You can’t have both

class GenomeSubclass extends Genome {
    public GenomeSubclass crossOver(GenomeSubclass other);
}

and

class GenomeSubSubclass extends GenomeSubclass {
    public GenomeSubclass crossOver(GenomeSubSubclass other);
}

while both are implementing the same Genome method. Every subtype of GenomeSubSubclass must implement the crossOver(GenomeSubclass) method, and can’t restrain the argument further.

Of course, you could provide GenomeSubclass with an type parameter of its own:

public class GenomeSubclass<T extends GenomeSubclass<T>> extends Genome<GenomeSubclass<T>>
{
    public GenomeSubclass<T> randomize();
    // etc...
}

but then you can’t really use this class directly without somehow going back to the raw type. (You would have to write GenomeSubclass<GenomeSubclass<GenomeSubclass<...>>>, which is not really possible. Or I’m somehow mis-thinking here.)

---

The principle idea here is that every Genome subtype being used as a type parameter T would be compatible to all its own subtypes. This means, we could have this:

public abstract class GenomeA extends Genome<GenomeA> {}

and then

public class AImpl1 extends GenomeA {
   public GenomeA randomize();
   public GenomeA mutate();
   public GenomeA crossOver(GenomeA other);
}

public class AImpl2 extends GenomeA {
   public GenomeA randomize();
   public GenomeA mutate();
   public GenomeA crossOver(GenomeA other);
}