Discussion :

[menzlitsh]

bonjour tous le monde,
Je vais savoir dans quel cas on doit utiliser l'instruction instanceof et quel est son utilité
par exemple :

Code :

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

1
2
3
if(français instanceof européen){
faireQulequechoz();
}

Merci

[zekey]

Cela permet de savoir si un objet est d'une instance donnée.

Par exemple dans le cas de l'héritage tu pourrais avoir quelque chose du type:

Vehicule
aller_a

^
|

Avion Voiture
voler rouler

Regardes le bout de code suivant (il ne compile sans doute pas):

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
 
class Vehicule { public void allerA(){} }
class Voiture extends Vehicule { public void rouler(){} }
class Avion extends Vehicule { public void voler(){} }
 
static void main (String[] args) {
   Vehicule v1 = new Avion();
   Vehicule v2 = new Voiture();
   //La ligne suivant marche toujours
   v1.allerA();
 
   //Mais la ligne suivante ne marche que dans le cas d'une Voiture
   v2.rouler();
   //Pour être sur
   if (v1 instanceof Avion) {
      v1.voler();
   }
   //Pour être sur-->Faux
   if (v2 instanceof Voiture {
      v2.rouler();
   }
}

[Kh4iN3]

Salut,

Je ne pense pas que cet exemple soit bon, dans ce cas la il vaut mieu créer une méthode abstraite 'allerA' et la redéfinir dans chacune des classes filles.

a+

[CyberChouan]

Effectivement, mais il y a peu de "bons" exemples d'utilisation de instanceof.

Si on a un code qui a besoin de l'utiliser, le réflexe est de vérifier la conception de son application car dans la majorité des cas, on peut contourner le problème d'une jolie façon en utilisant l'héritage et le polymorphisme

[Hikage]

Un exemple plus concret si tu veux :

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
 
public class MonObject {
public boolean equals(Object o){
 
// vérification que l'object passé en parametre est du meme type que MonObject
 
 
    if(!(o instanceof MonObject)) return false;
 
// On est sur que o est de type MonObject 
 
     MonObject obj = (MonObject) o;
 
// Serie de if sur les differentes propriete 
// pour vérifier que tout est le même
     if(!obj.getNom().equals(.getNom())) return false;
     if(!obj.getDescription().equals(.getDescription())) return false;
 
    // Si tout les test on réussi, alors c'est le meme object
    return true;
 
 
  }
 
}

Voila un exemple de l'utilisation de instance of

[OButterlin]

On peut imaginer une multitude d'utilisations...
Supposons :

Une classe abstraite Champ représentant des méthodes et propriétés communes à un champ DB

Une classe ChampInteger étendant Champ
Une classe ChampDate étendant Champ
etc...

Dans un traitement donné, tu récupères un objet Champ et tu veux en fonction du type afficher un message... (genre "La valeur de l'entier est " + laValeur)
Là, instanceof va te permettre de savoir de quel type est l'instance de l'objet

Code :

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

1
2
3
4
5
6
7
8
 
 
Champ unChamp = maTable.mesChamps.get(i);
if ( unChamp instanceof ChampInteger )
{
   msgType = " de l'entier ";
}
else ...

(ça n'est qu'un exemple...)

A+

[Kh4iN3]

Salut,

+1 avec l'exemple de Hikage,
Je l'utilise à tout les coups pour le equals

a+

[bouye]

D'autres cas typiques d'utilisation : dans le code des cell renderer/editor des composants Swing lorsque le composant complexe (JComboBox, JList, JTree, ...) contient des donnees heterogenes (la JTable permet elle de specifier un renderer/editor par classe, ce qui permet en general d'eviter le probleme).

Dans des cas plus complexe, l'heritage ne resoud pas toujours tous les problemes et va parfois a l'encontre d'une conception/modelisation correcte avec separation des tiers/taches/couches de conception.

[kossistus]

Salut,
Puisque la discussion est encore ouverte j'aimerais apportté ma contribution sur l'utilisation de instance of (un operateur de transtypage).

J'ai remarqué que dans bien des cas on est bien forcé de l'utiliser.
La morale en est que si on l'utilise plusieurs fois dans son code alors il faut croire que il y a un problème de conception.
C'est l'occasion alors de remettre sa conception à jour.

[if_zen]

Bonjour,

Je me permets de remonter le sujet pour demander s'il y a une différence notable en terme de temps d'exécution/calcul, entre le fait de faire un joli polymorphisme et l'utilisation du instanceof tout moche.

Merci !

[nikles007]

Pour ma part, je banni l'instanceOf dans le cas où le nombre de traitement est superieur à 1.
Je m'explique:

si le code s'apparente à

Code :

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

1
2
3
4
 
if ( monObjet instanceOf MonType){
   ...
}

je considère dans ce cas que le instanceOf a sa place, en revanche,
pour les cas :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
if ( monObjet instanceOf MonType1){
   ...
} else {
if ( monObjet instanceOf MonType2){
   ...
} else {
if ( monObjet instanceOf MonType3){
   ...
} else {
 
} }  }

je préconise largement l'utilisation des visiteurs.