With raw typing issue

Question

I have an inheritance issue where it is easier to explain the problem in code rather than text so given the following inheritance design for the Parents:

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Parent<T extends Offspring> {

    @OneToMany(mappedBy = "parent", targetEntity = Offspring.class)
    private Set<T> offsprings;

    // Getters/Setters relevant for all sub types
}

@Entity
public class Cat extends Parent<Kitten> {

}

@Entity
public class Dog extends Parent<Puppy> {

}

And the Offspring:

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Offspring<T extends Parent> {
    @ManyToOne(targetEntity = Parent.class)
    @JoinColumn(name = "parent_id", referencedColumnName = "id")
    private T parent;

    // Getters/Setters relevant for all sub types
}

@Entity
public class Kitten extends Offspring<Cat> {

}

@Entity
public class Puppy extends Offspring<Dog> {

}

Say I want to get a list of parents: List<Parent> parents = parentService.getAll();

The parent list, because it is now a raw type, has no understanding that the parents..get(0).getOffsprings() should return a type Set<Offspring>. It instead, because of the raw typing, thinks it returns Set.

I might want to do this because a Person might have a list of all their Parent's like:

@Entity
public class Person {
    @OneToMany(mappedBy = 'person')
    private Set<Parent> parents;
}

And I might want to get all of the offspring of all the parents owned by the person: person.getParents().get(0).getOffsprings() but this then returns a type Set because it is a raw type.

Clearly I am going down the wrong route with this so:

The goals are:

• To be able to have an object of Cat and only be able to put Kitten offsprings into its set. Or an object of Puppy and only be able to set Dog as its parent.
• To be able to query for all Parents and for it to keep its typing so that only Offspring can be put into the object.

I have gone through many different permutations of how this should be done. One option was for instance the Cat object to hold its own container of Kitten offspring:

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Parent {
    @OneToMany(mappedBy = "parent")
    private Set<Offspring> offsprings;
}

@Entity
public class Cat extends Parent {

    private Set<Cat> offsprings;
}

But this doesn't work because the Cat class is unable to override the getter/setter for the parent class Parent. As well as causing Hibernate issues because it now things that the database table Kitten has a link to Cat.

Disclaimer

I might be missing something obvious or going about this the whole wrong way so I am open to suggestions on the best way to handle this. Also my inheritance strategy might be causing the issues so all advice is welcome and I am happy to provide more if needed.

Answer 1

Looks like what you're looking for are abstract classes (and methods). These allow you to specify a behavior and leave the implementation to its subclass. I would make Parent and Offspring abstract classes and then inherit from them while specifying the exact return types:

public abstract class Parent {

    public abstract Set<? extends Offspring> getOffsprings();
}

public abstract class Offspring {

    public abstract Parent getParent();
}

public class Cat extends Parent {

    private Set<Kitten> offsprings;

    @Override
    public Set<Kitten> getOffsprings() {
        return offsprings;
    }
}

public class Kitten extends Offspring {

    private Cat parent;

    @Override
    public Cat getParent() {
        return parent;
    }
}

public class Dog extends Parent {

    private Set<Puppy> offsprings;

    @Override
    public Set<Puppy> getOffsprings() {
        return offsprings;
    }
}

public class Puppy extends Offspring {

    private Dog parent;

    @Override
    public Dog getParent() {
        return parent;
    }
}

While the Offspring class dictates a method that returns a Parent, its subclasses can return a subtype of it like Cat or Dog. I believe it's called Liskov substitution principle.

When it comes to Animal, it dictates a method that returns Set<? extends Offspring>, which means "a specific single type that extends Offspring" (in contrast to Set<Offspring>, which means "any Offspring" and will give you a compilation error). This allows subtypes to return a Set of their specific Offspring, like Set<Kitten> or Set<Puppy>.

Now, when you have a List<Parent> parents = parentService.getAll(); each Parent will return a Set<? extends Offspring> via parent.getOffsprings().

Answer 2

There is a technique to pass the class itself as a generic parameter:

class MyDerived extends MyBase<MyDerived> { ... }

class MyBase<T> {
    T ...
}

In Java SE enum classes are implemented as such, as extends Enum<TheEnumClass>.

Here not all parameter types are parametrized themselves; so do:

public class Parent<P, T extends Offspring<P>> {
    public Set<T> getOffsprings();

public class Offspring<O, T extends Parent<O>> {

public class Cat extends Parent<Cat, Kitten> {

public class Kitten extends Offspring<Kitten, Cat> {

Cat cat = ...;
cat.getOffsprings.add(new Kitten()); // Okay.
cat.getOffsprings.add(new Puppy()); // ERROR.

Kitten kitty = ...
cat = kitty.getParent();

However I am wondering whether such fine grained inheritance is needed.