Itérer sur un attribut hérité

Bonjour,

Je bloque totalement sur comment faire pour itérer sur un attribut hérité en Java. Soit deux classes, Foo et Bar, cette dernière héritant de la première.

Voici le code correspondant aux deux classes :

1
2
3

abstract class Foo {
    protected ArrayList<Foo> children;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Bar extends Foo {
    public ArrayList<Bar> getLeaves() {
        ArrayList<Bar> leaves = new ArrayList<>();

        for (Bar child : children) {
            if (child.children.size() > 0) {
                leaves.addAll(child.getLeaves());
            } else {
                leaves.add(child);
            }
        }

        return leaves;
    }
}

À la ligne 5, j’ai l’erreur suivante :

1
2
3

Incompatible types.
Required: Foo
Found:    Bar

Je pensais que avec le métamorphisme ça ne posait pas de problème de faire ce genre de chose… Je dois sûrement tout mélanger. Or je dois forcément avoir un Bar car j’utilise des méthodes propres à cette classe.
Comment suis-je sensé faire ce que je souhaite faire ?

Merci pour votre aide !

Désolé pour les noms qui n’aident pas.

Effectivement, merci pour votre aide, il suffisait de caster après l’objet :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

    public ArrayList<Bar> getLeaves() {
        ArrayList<Bar> leaves = new ArrayList<>();

        for (Foo child : children) {
            if (child.children.size() > 0) {
                leaves.addAll(((Bar)child).getLeaves());
            } else {
                leaves.add((Bar)child);
            }
        }

        return leaves;
    }

Ce qui fonctionne parfaitement, merci à vous !

Euh, ton cast est un peu sauvage là !

Il faudrait que tu penses à vérifier le type avant.

Sinon, si ta classe Foo sert juste à contenir une ArrayList du type qui hérite de Foo, tu peux faire une tambouille comme suit (mais si tu ne sais pas ce que ça fait, ni ce que tu fais, évite):

1
2
3

public abstract class Foo<T> {
  ArrayList<T> children;
}

1
2
3

public class Bar extends Foo<Bar> {
  ...
}

Ouep je comprend, c’est les templates, comme en C++ ! Seulement ce n’est pas ce que je recherche, Foo étant un peu plus complexe.

Comment ça mon cast est un peu sauvage ? Comment vérifier le type de ?

Merci pour tes conseils !

D’accord merci !

Petite précision, c’est toujours mieux de mettre l’interface la plus proche en type de retour d’une méthode, en paramètre, ou en déclaration. Si un jour tu veux changer l’implémentation de ta collection et passer d’ArrayList<> à LinkedList<> ça sera plus beaucoup plus simple, principalement si tu donnes un « contrat » à quelqu’un d’autres, ça évite d’avoir à modifier tous les prototypes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public List<Bar> getLeaves() {
  List<Bar> leaves = new ArrayList<>();

  for (Foo child : children) {
    if (!(child instanceof Bar)) continue;

    if (child.children.isEmpty()) {
      leaves.add((Bar)child);
    } else {
      leaves.addAll(((Bar)child).getLeaves());
    }
  }
  return leaves;
}