Java Inheritance. Parent has list of parent, child must have list of childs. How?

Question

I am trying to achieve the next:

Parent:

public class Animal {
    private List<Animal> relatives;

    public List<Animal> getRelatives() {
        return relatives;
    }

    public void setRelatives(List<Animal> relatives) {
        this.relatives = relatives;
    }
}

Child:

public class Dog extends Animal {
    private List<Dog> relatives;

    public List<Dog> getRelatives() {
        return relatives;
    }

    public void setRelatives(List<Dog> relatives) {
       this.relatives = relatives;
    }
}

But for some reason, I get errors that the methods are clashing. Is this even possible with inheritance, without using generic types?

maybe that helps: https://stackoverflow.com/questions/5346847/java-generic-method-inheritance-and-override-rules — ItFreak, Sep 05 '19 at 15:12
This design would violate Liskov substitution principle. `Animal.getRelatives()` should return a `List`, so by Liskov substitution principle, `dog.getRelatives().add(new Cat())` must be ok. — Johannes Kuhn, Sep 05 '19 at 15:16

Andrew Tobilko · Accepted Answer · 2019-09-05T16:06:42.367

7

You don't really need to override/duplicate anything in the child class.

class Animal<Relative extends Animal<?>> {
  private List<? extends Relative> relatives;

  public List<? extends Relative> getRelatives() {
    return relatives;
  }

  public void setRelatives(List<? extends Relative> relatives) {
    this.relatives = relatives;
  }
}

class Dog extends Animal<Dog> {}

edited Sep 05 '19 at 16:06

answered Sep 05 '19 at 15:13

Andrew Tobilko

48,120
14
91
142

Why ` extends Relative>`, rather than just ``? – Andy Turner Sep 05 '19 at 15:21
4

`class Dog extends Animal` seems legit – Michael Sep 05 '19 at 15:23
`class Animal { private List relatives;` ? – Victor Gubin Sep 05 '19 at 15:25
Gonna try this out on my work tommorow. Is Relative a conincidental java class, or does it function as T? – dendimiiii Sep 05 '19 at 15:25
@dendimiiii It functions as `T`. – Michael Sep 05 '19 at 15:26
2

@AndyTurner to allow to pass, let's say, a `List` to `setRelatives` (`DomesticDog` extends `Dog`) – Andrew Tobilko Sep 05 '19 at 15:30
@VictorGubin I am not sure it's right. It would be possible to write `class Dog extends Animal {}` – Andrew Tobilko Sep 05 '19 at 15:48
@Michael how would you bound it? `Relative extends Animal>` doesn't look right to me since we put no restrictions on who could be a relative to an animal. I came up with `class Animal` which would reject things like `class Dog extends Animal` but I am not sure if it's always OK. – Andrew Tobilko Sep 05 '19 at 15:55
@AndrewTobilko The first one is almost right, but you are using the raw type. It should be `Animal>` – Michael Sep 05 '19 at 15:57

Oleg Cherednik · Answer 2 · 2019-09-05T15:25:25.297

2

You could use generic and hold relatives in parent class. Additionally, you should aware of holding of unexpected modification:

public class Animal<T extends Animal<?>> {

    private final List<T> relatives = new ArrayList<>();

    public final List<T> getRelatives() {
        return relatives.isEmpty() ? Collections.emptyList() : Collections.unmodifiableList(relatives);
    }

    public final void addRelative(T relative) {
        Objects.requireNonNull(relative);
        relatives.add(relative);
    }
}

public class Dog extends Animal<Dog> {

    // just for test
    public List<Dog> getRelativesDogs() {
        return super.getRelatives();
    }

    // just for test
    public void addRelativeDog(Dog dog) {
        super.addRelative(dog);
    }

}

edited Sep 05 '19 at 15:25

answered Sep 05 '19 at 15:19

Oleg Cherednik

17,377
4
21
35

`relatives.add(relative)` won't compile. – Andy Turner Sep 05 '19 at 15:19
I am not sure if `T extends Animal>` is correct since you can write `class Dog extends Animal {}` – Andrew Tobilko Sep 05 '19 at 15:49
I am thinking of `class Animal` which would reject things like class `Dog extends Animal` but I am not sure if it's always OK. – Andrew Tobilko Sep 05 '19 at 15:56
@AndrewTobilko I think this is not what should care about. – Oleg Cherednik Sep 05 '19 at 15:57

Java Inheritance. Parent has list of parent, child must have list of childs. How?

2 Answers2