Utilisation de l'instruction instanceof

Version imprimable

19/07/2007, 10h20
menzlitsh

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

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

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:

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();
   }
}

19/07/2007, 13h38
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+
19/07/2007, 14h07
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

Un exemple plus concret si tu veux :

Code:

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

19/07/2007, 16h03
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:

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+
19/07/2007, 16h46
Kh4iN3

Salut,

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

a+
20/07/2007, 01h00
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.
13/08/2007, 10h46
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.
02/11/2009, 15h08
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 !
02/11/2009, 16h54
nikles007

InstanceOf Vs Visitor
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:

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:

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.