Implementing parent-child relationship with generics

Question

I am trying to make a container(parent) object where you can specify type of objects(children) it can contain.

Similarly, you can specify type of parent of the child. Parent and child needs to communicate in the future, so I need them both to have object references to each other.

This code is a simpler representation of the actual code in my app.

class Parent<T extends Child> {
    ArrayList<T> childObjects;
    public void addChildChild(T newChild) {
        childObjects.add(newChild);
        newChild.setParent(this);
    }
    public void newChildConnected(T connectedChild) {
        System.out.println("Child connected");
    }
}

class Child <T extends Parent> {
    T parentObject;
    public void setParent(T newParent) {
        parentObject = newParent;
        parentObject.newChildConnected(this);
    }
}

My IDE says: Unchecked call to 'newChildConnected(T)' as a member of raw type 'test.Parent'

I have been trying different ways to make it better with wildcards and stuff, but I this is best I can do. So what is the correct way of implementing such a behavior?

My goal is to be able to specify the child type for parent and parent type for child and do it in the way that both children and parent are able to use functionality of each other without using the intanceof() operator and casting. (that's why I use generics after all)

Is is even possible in Java?

I don't think it's possible, no. See "Typesafe Heterogenous Containers" in Joshua Bloch's *Effective Java* for a better approach. — markspace, Dec 28 '18 at 22:36
Are there any dangers associated with my first approach ignoring raw-type warning? — Jerry Lundegaard, Dec 28 '18 at 22:50
Sure, it's not type safe. You could/should prevent the raw types, e.g. by writing `T extends Child>` and `T extends Parent>>`, just to turn the warnings into errors, indicating that the types, at this point, are simply not compatible. There could be some workarounds, but given the dummy code, it's hard to say what would be the most appropriate one here... — Marco13, Dec 28 '18 at 22:53
@JerryLundegaard it would allow something like `new ChildA().setParent(new ParentB())` with `class ParentB extends Parent`. So you end up with a parent expecting only ChildBs having a ChildA. — Marcono1234, Dec 28 '18 at 22:56

score 2 · Answer 1 · answered Dec 28 '18 at 23:07

Your usage of generic types creates a circular type reference. If the type(or interface/base class) of the parent and child are the same, use a tree structure within a single class:

class MyObject<T> {
T parentObject;
ArrayList<T> childObjects = new ArrayList();
public void addChildChild(T newChild) {
    childObjects.add(newChild);
    newChild.setParent(this);
}
public void newChildConnected(T connectedChild) {
    System.out.println("Child connected");
}
public void setParent(T newParent) {
    parentObject = newParent;
    parentObject.newChildConnected(this);
}

When using this class you must check for top level objects where parentObject == null and leaf objects where childObjects.size()==0.

If there is no common interface or base class, this is not possible to do safely.

Thomas · Answer 2 · 2019-11-11T08:42:38.217

As @Strom pointed out correctly, this cannot be done in a typesafe way without base classes or interfaces.

If you can extend a class/interface, a typesafe solution without any casts would look like this:

interface BaseParent<P extends BaseParent<P, C>, C extends BaseChild<P, C>> {

    List<C> getChildren();

    void setChildren(List<C> children);

    P self();

    default void addChild(C child) {
        if (child.getParent() == null) {
            child.setParent(self());
        }

        final ArrayList<C> newChildren = new ArrayList<>(getChildren());
        newChildren.add(child);
        setChildren(newChildren);
    }
}

interface BaseChild<P extends BaseParent<P, C>, C extends BaseChild<P, C>> {

    void setParent(P parent);

    P getParent();

}

final class Parent implements BaseParent<Parent, Child> {

    private List<Child> children = new ArrayList<>();

    @Override
    public List<Child> getChildren() {
        return children;
    }

    @Override
    public void setChildren(List<Child> children) {
        this.children = children;
    }

    @Override
    public Parent self() {
        return this;
    }
}

final class Child implements BaseChild<Parent, Child> {

    private Parent parent;

    public Child(Parent parent) {
        this.parent = parent;
        this.parent.addChild(this);
    }

    @Override
    public void setParent(Parent parent) {
        this.parent = parent;
    }

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

The solution uses "recursive" generics for type safety and a self-type reference to avoid casts. Both of these approaches have caveats and are not entirely safe because you have to rely on the implementor of the base/class interface to return the correct self type and define correct type parameters, but should be good enough for internal APIs.

Implementing parent-child relationship with generics

2 Answers2