Discussion :

[jayjay78]

Bonsoir tout le monde,

J'ai un problèmes pour identifier les objets d'une ArrayList.

Dans la méthode de la fin de la classe Index ci-dessous qui s'appelle afficherMotPage j'aimerai bien savoir quel est la valeur de current.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
public class Index {
    ArrayList<Entree> i = new ArrayList<Entree>();
    /** Creates a new instance of Index */
    public Index() {
 
    }
    //public String toString(Entree e){
    //    return e.getNom();
    //}
 
    public void afficher(){
        for (Entree current: i){
            current.afficher();
        }
    }
    public void afficherMotPage(int p){
        System.out.println("Voici les mots contenue par la page");
        for (Entree current: i){
 
            if(current.instanceof EntreeImbriquee){
                System.out.println("oui");
            }
            }
            }
        }

Mon programme se décompose de la manière suivante :
une classe Entree qui est abstraite
une sous-classe de Entree qui est EntreePlat
une sous-classe de Entree qui est EntreeImbriquee

Donc l'ArrayList peut-être remplie par une des 2 sous classes, soit EntreePlat soit EntreeImbriquee.
J'aimerai bien traiter la variable current de la fonction afficherMotPage(int p) afin de savoir si current est un objet EntreePlat ou une EntreeImbriquee.

J'ai essayé avec instanceof mais ça ne marche pas malheuresement. Voilà je suis toute ouïe si vous avez des propositions.

[visiwi]

Salut,

Mais si instanceof est ce qu'il faut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import java.util.ArrayList;
import java.util.List;
 
public class Essai {
 
	private List<Abstraite> list = new ArrayList<Abstraite>();
 
	public static void main(String[] args) {
		Essai e = new Essai();
		e.affiche();
	}
 
	public Essai() {
		A a1 = new A("class A - 1");
		A a2 = new A("class A - 2");
		A a3 = new A("class A - 3");
		B b1 = new B("class B - 1");
 
		list.add(a1);
		list.add(a2);
		list.add(a3);
		list.add(b1);
	}
 
	public void affiche() {
		for (Abstraite a : list) {
			if (a instanceof A) {
				System.out.println("Classe A:");
				System.out.println("\t"+ ((A) a).getMessage());
			}
			else if (a instanceof B) {
				System.out.println("Classe B:");
				System.out.println("\t"+ ((B) a).getMessage());
			}
		}
	}
 
	public abstract class Abstraite {
		public abstract void setMessage(String s);
		public abstract String getMessage();
	}
 
	public class A extends Abstraite {
 
		private String message;
 
		public A(String s) {
			setMessage(s);
		}
 
		@Override
		public String getMessage() {
			return message;
		}
 
		@Override
		public void setMessage(String s) {
			message = s;			
		}
 
	}
 
	public class B extends Abstraite {
 
		private String message;
 
		public B(String s) {
			setMessage(s);
		}
 
		@Override
		public String getMessage() {
			return message;
		}
 
		@Override
		public void setMessage(String s) {
			message = s;			
		}
 
	}
}

[fabszn]

Hello,

Je pense que si tu dois identifier le type concret de l'objet courant, c'est qu'il doit y avoir une erreur de conception. En règle générale, l'utilisation de l'opérateur instanceof ne relève pas d'une bonne pratique!
En testant le type concret de la classe tu casses tout l'intérêt du polymorphisme.

Que veux tu faire exactement en fonction du type concret de la classe?

Est que tu ne peux pas définir une méthode abstraite dans la classe Entree, que tu redéfinirais de manière différente selon le type de la classe fille. De cette manière tu n'aurais plus besoin de te poser la question de savoir quel type tu manipule à l'instant t, tu aurais juste à invoquer cette méthode qui exécutera le bon code de manière transparente selon le type concret.