problème if else

Version imprimable

problème if else

Bonjour à tous;
J'ai besoin de créer une méthode qui compare 2 objets :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
 public static int comparePersonne(Object o1,Object o2) 
      { 
             Personne p1 = null,p2 = null; 
             Article a = null;
             Livre l = null;
              if (o1 instanceof Personne & o2 instanceof Personne) 
              { 
                      p1=(Personne)o1; 
                      p2=(Personne)o2; 
              } 
              else 
            	  if (o1 instanceof Article & o2 instanceof Livre) 
            	  {
            		  a=(Article)o1; 
                      l=(Livre)o2; 
            	  }
               else
               {
                      return Classable.ERREUR; 
              } 
              if (p1.getNom().compareTo(p2.getNom())<0) 
              { 
            	  return Classable.INFERIEUR; 
              } 
              if (p1.getNom().compareTo(p2.getNom())>0) 
              { 
                      return Classable.SUPERIEUR; 
              }
   X             else
   X           {
   X           return Classable.EGAL;
   X           }
 
              if (a.getref().compareTo(l.getref())<0)
              {
            	  return Classable.INFERIEUR; 
              }
              if (a.getref().compareTo(l.getref())>0)
              {
            	  return Classable.SUPERIEUR; 
              }
              else
              {
                return Classable.EGAL;
              }  
 
 
}

Cette méthode telle qu'elle est écrite renvoie une erreur de compilation :"Unreachable code"
En supprimant les lignes ou j'ai mis X l'erreur disparait et je n'arrive pas à comprendre pourquoi
Si quelqu'un a une idée
MERCI

13/04/2020, 21h03
OButterlin

Vu du point de vue du compilateur, p1 est soit supérieur à p2, soit inférieur à p2 soit égal... pourquoi voudrais-tu qu'il considère ce qui suit ?
Tes tests sont mal placés, tu devrait remonter les tests dans les conditions sur les types correspondants.
Autre chose, ce n'est pas & mais && pour une condition (le & est un ET binaire)

Citation:

Envoyé par OButterlin

Vu du point de vue du compilateur, p1 est soit supérieur à p2, soit inférieur à p2 soit égal... pourquoi voudrais-tu qu'il considère ce qui suit ?
Tes tests sont mal placés, tu devrait remonter les tests dans les conditions sur les types correspondants.
Autre chose, ce n'est pas & mais && pour une condition (le & est un ET binaire)

***************************************************
Merci pour ton aide . OK mais pourquoi ça marche ça ? :

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
26
27
28
29
30
31
32
33
34
 
 public static int comparePersonne(Object o1,Object o2) 
      { 
             Personne p1 = null,p2 = null; 
             Article a = null;
             Livre l = null;
              if (o1 instanceof Personne && o2 instanceof Personne) 
              { 
                      p1=(Personne)o1; 
                      p2=(Personne)o2; 
              } 
              else 
            	  if (o1 instanceof Article && o2 instanceof Livre) 
            	  {
            		  a=(Article)o1; 
                      l=(Livre)o2; 
            	  }
               else
               {
                      return Classable.ERREUR; 
              } 
              if (p1.getNom().compareTo(p2.getNom())<0) 
              { 
            	  return Classable.INFERIEUR; 
              } 
              if (p1.getNom().compareTo(p2.getNom())>0) 
              { 
                      return Classable.SUPERIEUR; 
              }
              else
              {
              return Classable.EGAL;
              }
}

Merci A+

14/04/2020, 20h46
OButterlin

et bien parce que p1 est soit supérieur à p2, soit il est inférieur, et en dernier ressort, il est égal... au-delà de ça, il n'y a plus de possibilité.

Comme dit, le problème vient du fait que tu n'as pas associé tes tests dans les conditions sur les types. Du coup, pour le compilateur, il se fiche (à ce niveau) de savoir que p1 et p2 sont null (ou peuvent l'être), ça ce sera un plantage à l'exécution...

Citation:

Envoyé par OButterlin

et bien parce que p1 est soit supérieur à p2, soit il est inférieur, et en dernier ressort, il est égal... au-delà de ça, il n'y a plus de possibilité.

Comme dit, le problème vient du fait que tu n'as pas associé tes tests dans les conditions sur les types. Du coup, pour le compilateur, il se fiche (à ce niveau) de savoir que p1 et p2 sont null (ou peuvent l'être), ça ce sera un plantage à l'exécution...

******************************************
Merci pour ta réponse mais je ne vois pas ce que tu veux dire car si tu regardes la fonction il y a deux tests identiques un pour p1 et p2 et l'autre pour a et l :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 if (p1.getNom().compareTo(p2.getNom())<0) { return Classable.INFERIEUR; } if (p1.getNom().compareTo(p2.getNom())>0) { return Classable.SUPERIEUR; } else { return Classable.EGAL; }
et
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 if (a.getref().compareTo(l.getref())<0) { return Classable.INFERIEUR; } if (a.getref().compareTo(l.getref())>0) { // return Classable.SUPERIEUR; } else { return Classable.EGAL; }
et le fait de supprimer le 1er else :
Code:

1 2 3 4 5 /* else { return Classable.EGAL; }*/
permet de corriger l'erreur ... ca veut dire que l'on ne peut pas faire 2 tests identiques sur une meme fonction pour des variables différentes ?
La j e ne comprends pas ...

17/04/2020, 22h04
OButterlin

Je ne sais pas comment te le dire mais bon, un dernier essai :

Tu testes p1 avec p2 en premier donc :

- soit p1 est supérieur à p2
- soit p1 est inférieur à p2
- soit p1 est égal à p2

Quel autre cas selon toi peut-il exister ?

Il n'y en a pas !
==> ce qui suit ne peut pas être atteint

Si tu mettais ce test dans une condition "si p1 et p2 sont différents de NULL" alors on pourrait continuer avec a et l mais comme tu ne l'as pas fait, le compilateur te dit (à juste titre) que les lignes qui suivent ne peuvent être atteintes.

Citation:

Envoyé par OButterlin

Je ne sais pas comment te le dire mais bon, un dernier essai :

Tu testes p1 avec p2 en premier donc :

- soit p1 est supérieur à p2
- soit p1 est inférieur à p2
- soit p1 est égal à p2

Quel autre cas selon toi peut-il exister ?

Il n'y en a pas !
==> ce qui suit ne peut pas être atteint

Si tu mettais ce test dans une condition "si p1 et p2 sont différents de NULL" alors on pourrait continuer avec a et l mais comme tu ne l'as pas fait, le compilateur te dit (à juste titre) que les lignes qui suivent ne peuvent être atteintes.

****************************************************************************
MErci pour ton aide et ta patience
Cela veut dire que tel que c'est écrit si p1 et p2 sont égaux le retour :

Code:

1
2
 
return Classable.EGAL;

ne se fera qu'à la fin de la fonction comme pour a et l :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
public static int comparePersonne(Object o1,Object o2) 
      { 
             Personne p1 = null,p2 = null; 
             Article a = null;
             Livre l = null;
              if (o1 instanceof Personne && o2 instanceof Personne) 
              { 
                      p1=(Personne)o1; 
                      p2=(Personne)o2; 
              } 
              else 
            	  if (o1 instanceof Article && o2 instanceof Livre) 
            	  {
            		  a=(Article)o1; 
                      l=(Livre)o2; 
            	  }
               else
               {
                      return Classable.ERREUR; 
              } 
              if (p1.getNom().compareTo(p2.getNom())<0) 
              { 
            	  return Classable.INFERIEUR; 
              } 
              if (p1.getNom().compareTo(p2.getNom())>0) 
              { 
                      return Classable.SUPERIEUR; 
              }
       if (a.getref().compareTo(l.getref())<0)
              {
            	  return Classable.INFERIEUR; 
              }
              if (a.getref().compareTo(l.getref())>0)
              {
            	  return Classable.SUPERIEUR; 
              }
    X          else
    X          {
    X            return Classable.EGAL;
   X           }  
 
 
}

ou j'ai mis les croix.
Pour moi le problème est résolu, si tu as d'autres remarques je suis preneur.
Merci à toi

19/04/2020, 11h21
OButterlin

Et bien, 2 choses :

- Tu ne sauras jamais si p1 est égal à p2
- Tu auras une belle NullPointerException quand tu passeras un Article et un Livre

Citation:

Envoyé par OButterlin

Et bien, 2 choses :

- Tu ne sauras jamais si p1 est égal à p2
- Tu auras une belle NullPointerException quand tu passeras un Article et un Livre

************************************************************************
Merci pour tes remarques en fait je suis revenu sur le problème et je l'ai écrit différement et au passage je m'étais trompé je n'ai besoin que de deux instances de la Classe Article et pas Article...

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
      public static int comparePersonne(Object o1,Object o2) 
      { 
             Personne p1 = null,p2 = null; 
             Article a1 = null,a2=null;
             if (o1 instanceof Article && o2 instanceof Article)             	  
       	  {
       		  a1=(Article)o1; 
                 a2=(Article)o2; 
                 if (a1.getref().compareTo(a2.getref())<0)
                 {
               	  return Classable.INFERIEUR; 
                 }
                 if (a1.getref().compareTo(a2.getref())>0)
                 {
               	  return Classable.SUPERIEUR; 
                 }
                 else
                 {
                   return Classable.EGAL;
                 }
       	  }
              if (o1 instanceof Personne && o2 instanceof Personne) 
              { 
                      p1=(Personne)o1; 
                      p2=(Personne)o2; 
                      if (p1.getNom().compareTo(p2.getNom())<0) 
                      { 
                    	  return Classable.INFERIEUR; 
                      } 
                      if (p1.getNom().compareTo(p2.getNom())>0) 
                      { 
                              return Classable.SUPERIEUR; 
                      }
                      else
                      {
                      return Classable.EGAL;
                      }
              } 
 
			return nbInstances;
 
 
}

Cette fonction comme cela me permet de tester des classes "Personne" et "Article" ; étant donné que Article dérive de Personne je la teste d'abord car autrement le " instanceof " me prend les variables a1 et a2 en tant que "Personne".
Pour tout dire cette fonction était au départ pour trier des instances de classe Personne.
Par contre je ne comprends pas pourquoi je dois retourner nbInstances :

Code:

1
2
 
return nbInstances;

Sur l'autre version il me le demandait pas .
A noter la Classe Personne implémente l'Interface Classable d'ou ces SUPERIEUR,INFERIEUR,EGAL qui sont bien int

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
26
27
28
29
30
31
 
public interface Classable 
{ 
//cette méthode pourra être appelée pour comparer l’instance 
//courante avec celle reçue en paramètre 
//la méthode retourne un entier dont la valeur dépend 
//des règles suivantes 
//1 si l’instance courante est supérieure à celle reçue 
//en paramètre 
//0 si les deux instances sont égales 
//-1 si l’instance courante est inférieure à celle reçue  
//en paramètre 
//-99 si la comparaison est impossible 
 
  int compare(Object o); 
 
  default boolean isInferieur(Object o) 
  { 
     return false; 
  } 
  default boolean isSuperieur(Object o) 
  { 
     return false; 
  } 
 
  public static final int INFERIEUR=-1; 
  public static final int EGAL=0;
  public static final int SUPERIEUR=1; 
  public static final int ERREUR=-99; 
 
}

Voilà merci pour ton aide, si tu a s une idée pour le return ...
A+

23/04/2020, 21h27
OButterlin

La signature de ta méthode indique qu'elle doit retourner un int.

Maintenant que tu testes les types avec tes instanceof et que la signature de méthode indique 2 paramètres Object, pour le compilateur, Object peut être autre chose que Personne ou Article.
Donc, après tes 2 testes, il y a "autres cas".
Ces autres cas ne t'intéressent pas mais il faut quand même les prendre en compte.

De mon point de vue, ton retour final devrait être ERREUR
Si je comprends bien, tu veux tester soit 2 personnes, soit 2 articles. Donc, si tu passais autre chose que 2 personnes ou 2 articles, tu serais dans un cas d'erreur...
24/04/2020, 19h23
xeron33

Citation:

Envoyé par OButterlin

La signature de ta méthode indique qu'elle doit retourner un int.

Maintenant que tu testes les types avec tes instanceof et que la signature de méthode indique 2 paramètres Object, pour le compilateur, Object peut être autre chose que Personne ou Article.
Donc, après tes 2 testes, il y a "autres cas".
Ces autres cas ne t'intéressent pas mais il faut quand même les prendre en compte.

De mon point de vue, ton retour final devrait être ERREUR
Si je comprends bien, tu veux tester soit 2 personnes, soit 2 articles. Donc, si tu passais autre chose que 2 personnes ou 2 articles, tu serais dans un cas d'erreur...

*************************************
Merci pour ta réponse en effet tu as vu juste ERREUR fonctionne
A+