java.lang.NullPointerException sur Fonction

Version imprimable

Bjr à tous,
J'ai un problème de java.lang.NullPointerException que je n'arrive pas à résoudre :
J'ai une classe Personne dans laquelle figure une fonction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public static Personne recherchePersonne(Personne[] tablo, ComparateurPersonne cp) { for(Personne p:tablo) { if (cp.isIdentique(p)) { return p; } } return null; }
Où tablo est : Personne[]
et cp identifie l'interface :
Code:

1 2 3 4 5 6 public interface ComparateurPersonne { boolean isIdentique(Personne p); }
J'exécute depuis une classe Exec :
Code:

1 2 3 ComparateurPersonne cp0 = null; Personne.recherchePersonne(tab1,cp0);
et l'erreur se déclenche sur la fonction recherchePersonne sur la ligne en gras
Code:

1 2 if (cp.isIdentique(p))
A noter j'ai été "obligé" d'initialiser cp0 à null sinon erreur à la compil :"The method recherchePersonne(Personne[], ComparateurPersonne) in the type Personne is not applicable for the arguments (Personne[], Comparateur)"

Si quelqu'un a une idée.
Merci

15/01/2020, 19h56
joel.drigo

Salut,

Citation:

Envoyé par xeron33

A noter j'ai été "obligé" d'initialiser cp0 à null sinon erreur à la compil :"The method recherchePersonne(Personne[], ComparateurPersonne) in the type Personne is not applicable for the arguments (Personne[], Comparateur)"

Si cp0 vaut null, alors le paramètre de recherchePersonne, vaut null, donc cp dans recherchePersonne() est null, donc comment peux-tu attendre autre chose qu'un NullPointerException lors que tu exécute if (cp.isIdentique(p)) !

L'erreur c'était :

Citation:

"The method recherchePersonne(Personne[], ComparateurPersonne) in the type Personne is not applicable for the arguments (Personne[], Comparateur)"

Tu ne peux pas passer une instance de Comparateur dans un paramètre d'une méthode qui attend ComparateurPersonne qui probablement étend Comparateur ! Le message d'erreur te dit que cp0 doit être du type ComparateurPersonne.
15/01/2020, 20h32
xeron33
Citation:

Envoyé par joel.drigo

Salut,

Le message d'erreur te dit que cp0 doit être du type ComparateurPersonne.

*********************************************************************
Merci
Oui mais quand je l'avais typé "ComparateurPersonne" :
Code:

1 2 ComparateurPersonne cp0;
J'avais l'erreur sur la ligne :
Code:

1 2 Personne.recherchePersonne(tab1,cp0);
"The local variable cp0 may not have been initialized" il me propose de l'initialiser et le met à null...
Code:

1 2 ComparateurPersonne cp0 = null;
MErci encore
15/01/2020, 20h57
joel.drigo

Tu vais l'erreur "The local variable cp0 may not have been initialized" parce qu'une variable doit avoir une valeur pour être utilisée comme paramètre.

Si ton IDE te propose de l'initialiser et le met à null, c'est qu'il n'a pas moyen deviner ce qu'il faut mettre, et que null est la seule possibilité qu'il est capable de proposer. Cela ne veut pas dire que c'est la seule chose possible à faire, et encore moins que c'est ce qu'il faut faire pour que ton programme fonctionne. Il faut bien sûr qu'il y ait une instance d'objet, de classe qui implémente ComparateurPersonne pour trier les personnes, donc il faut que tu initialises cp0 avec une telle instance d'objet et que tu implémentes l'interface.
18/01/2020, 09h18
xeron33
Citation:

Envoyé par joel.drigo

Il faut bien sûr qu'il y ait une instance d'objet, de classe qui implémente ComparateurPersonne pour trier les personnes, donc il faut que tu initialises cp0 avec une telle instance d'objet et que tu implémentes l'interface.

***************************************************************************
Bonjour et merci pour ton aide,
J'ai donc créer une variable de classe : cp et implémenté l'Interface ComparateurPersonne
Code:

1 2 3 public class Exec implements Comparateur,ComparateurPersonne { static ComparateurPersonne cp;
Et là je n'arrive pas à instancier la variable de classe cp donc toujours à null : "Cannot instantiate the type ComparateurPersonne"
Code:

1 2 3 public static void main(String[] args) throws CloneNotSupportedException { cp=new ComparateurPersonne();
Si tu peux m'apporter ton aide Merci

Implémenter une interface, ça veut dire implémenter ses méthodes. C'est quoi les méthodes de ComparateurPersonne ?

Si tu dis qu'une classe implémente 2 interfaces comme ça :

Code:

public class Exec implements Comparateur,ComparateurPersonne {

ça veut dire qu'elle doit implémenter les méthode des deux interfaces, Comparateur et ComparateurPersonne.

Par exemple avec ton ComparareurPersonne comme ça :

Code:

1
2
3
4
public interface ComparateurPersonne  { 
    boolean isIdentique(Personne p); 
 
}

On peut faire :

Code:

1
2
3
4
5
6
7
public class ComparateurPersonneNomIdentiqueAToto implements ComparateurPersonne {
 
     public boolean compare(Personne personne) {
         return "toto".equalsIgnoreCase(personne.getNom());
     }
 
}

C'est un exemple bidon parce que l'interface est comme même un peu étrange... la notion d'être identique avec un seul paramètre est absurde. Il faut au moins deux choses, pour qu'on puisse d'être qu'elles sont identiques. A part dans la blague "Quelle est la différence entre un pigeon ?" ;)

Si on prend l'exemple de java.util.Comparator :

Code:

1
2
3
public interface ComparateurPersonne extends Comparator<Personne> {
 
}

On aurait par exemple :

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
public class ComparateurPersonneParNom implements ComparateurPersonne {
     private final boolean nullBefore;
     public ComparateurPersonneParNom(boolean nullBefore) {
          this.nullBefore=nullBefore;
     }
 
     public int compare(Personne personne1, Personne personne2) {
           String nomPersonne1 = personne1==null?null:personne1.getNom();
           String nomPersonne2 = personne2==null?null:personne2.getNom();
           int compare;
           if ( nomPersonne1==null ) {
               if ( nomPersonne2==null ) {
                    compare==0;
               }
               else {
                    compare=nullBefore?-1:1;
               }
           }
           else if ( nomPersonne==null ) {
                    compare=nullBefore?1:-1;
           }
           else {
                    compare=nomPersonne1.compareTo(nomPersonne2);
           }
           return compare;
     }
}

Citation:

Envoyé par joel.drigo

Implémenter une interface, ça veut dire implémenter ses méthodes. C'est quoi les méthodes de ComparateurPersonne ?

Si tu dis qu'une classe implémente 2 interfaces comme ça :

Code:

public class Exec implements Comparateur,ComparateurPersonne {

ça veut dire qu'elle doit implémenter les méthode des deux interfaces, Comparateur et ComparateurPersonne.

******************************************************
Les méthodes des Interfaces sont implémentées comme ça (// TODO Auto-generated method stub)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		return 0;
	}
 
	@Override
	public boolean isIdentique(Personne p) {
		// TODO Auto-generated method stub
		return false;
	}

A noter aussi que le but de cette Interface est de factoriser ces méthodes qui se ressemblent toutes, en effet seul la ligne de code effectuant la comparaison change d'une version à l'autre :

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
50
 
 Nous devons donc créer quatre fonctions permettant d’effectuer ces recherches.*/
       public static Personne rechercheParNom(Personne[] tablo,String nom) 
       { 
           for(Personne p:tablo) 
           { 
               if (p.getNom().equals(nom)) 
               { 
                   return p; 
               } 
           } 
           return null; 
 
       } 
       public static Personne rechercheParPrenom(Personne[] tablo,String prenom) 
       { 
           for(Personne p:tablo) 
           { 
               if (p.getPrenom().equals(prenom)) 
               { 
                   return p; 
               } 
           } 
           return null; 
       } 
       public static Personne rechercheParAge(Personne[] tablo,int age) 
       { 
           for(Personne p:tablo) 
           { 
               if (p.calculAge()==age)  
               { 
                   return p; 
               } 
           } 
           return null; 
 
       } 
       public static Personne rechercheParNomPrenom(Personne[] 
    		   tablo,String nom,String prenom) 
    		   { 
    		       for(Personne p:tablo) 
    		       { 
    		           if (p.getNom().equals(nom)&& p.getPrenom().equals(prenom)) 
    		           { 
    		               return p; 
    		           } 
    		       } 
    		       return null; 
 
    		   }

Merci encore

Citation:
Envoyé par xeron33
Les méthodes des Interfaces sont implémentées comme ça (// TODO Auto-generated method stub)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 @Override public int compare(Object o1, Object o2) { // TODO Auto-generated method stub return 0; } @Override public boolean isIdentique(Personne p) { // TODO Auto-generated method stub return false; }
Je crois que tu confonds les méthodes d'une interface (vides, ou éventuellement avec une implémentation par défaut), les implémentations de ces méthodes dans une classe (concrète ou abstraite) implémentant l'interface, et le code auto généré par un IDE, un code compilable, mais en général ne faisant rien de cohérent ou correspondant à un besoin concret (ce que tu montres).

Citation:

Envoyé par xeron33

A noter aussi que le but de cette Interface est de factoriser ces méthodes qui se ressemblent toutes, en effet seul la ligne de code effectuant la comparaison change d'une version à l'autre :

Le but d'une interface est uniquement de définir un contrat pour des classes qu'on veut pouvoir manipuler. La notion de factorisation n'est pas vraiment en rapport avec la notion d'interface : cela consiste juste à isoler des codes pour éviter de les répéter. Ce qui permet parfois de regrouper plusieurs méthodes en une seule.

Citation:

Envoyé par xeron33

Nous devons donc créer quatre fonctions permettant d’effectuer ces recherches.*/

La notion de comparateur est plutôt associé à la notion de tri, sous-entendu, la notion d'ordre. La notion de recherche est plutôt associé à la notion de d'ensemble de conditions.

Une interface d'un filtre de recherche pourrait être :
Code:

1 2 3 4 5 6 7 8 public interface FiltreDeRechercheDePersonne { /** * teste si la personne spécifiée en argument a les conditions requises * return true si les conditions sont vérifiées, false sinon */ boolean aLesConditonsRequises(Personne p); }
Cela correspond à l'interface java.util.function.Predicate (à ne pas confondre avec le faux ami Prédicat en français).
Code:

1 2 3 4 5 6 7 8 9 public static Personne[] extraireLesPersonnesQuiCorrespondentA(Personne[] personnes, FiltreDeRechercheDePersonne filtre) { List<Personne> personnesTrouvees = new ArrayList<>(); for(Personne p : personnes) { if (filtre.aLesConditionsRequises(p)) { personnesTrouvees.add(p); } } return personnesTrouvees.toArray(new Personne[personnesTrouvees.size()]); }
ou
Code:

1 2 3 4 5 6 7 8 public static Personne recherche(FiltreDeRechercheDePersonne filtre, Personne...personnes) { for(Personne p : personnes) { if (filtre.aLesConditionsRequises(p)) { return p; } } return null; // pas trouvé }
On peut donc invoquer la recherche :
Code:

1 2 3 4 5 6 7 8 Personne[] desPersonnes = ... // on définit un filtre qui sélectionne les personnes dont l'age est inférieur à 20 FiltreDeRechercheDePersonne plusJeuneQue20Ans = new FiltreDeRechercheDePersonne() { public boolean aLesCondtionsRequises(Personne personne) { return personne.getAge()<20; } }; Personne[] personnesDeMoinsDe20Ans = RechercheDePersonnesUtils.extraireLesPersonnesQuiCorrespondentA(desPersonnes, plusJeuneQue20Ans);

Bjr et merci pour ton aide,
Tout ça m'est assez difficile...je me suis inspiré de ta dernière réponse

Citation:

Envoyé par joel.drigo

Code:

1
2
3
4
5
6
7
8
public interface FiltreDeRechercheDePersonne {
     /**
       * teste si la personne spécifiée en argument a les conditions requises
       * return true si les conditions sont vérifiées, false sinon
       */
     boolean aLesConditonsRequises(Personne p);
 
}

Cela correspond à l'interface java.util.function.Predicate (à ne pas confondre avec le faux ami Prédicat en français).

Code:

1
2
3
4
5
6
7
8
9
public static Personne[] extraireLesPersonnesQuiCorrespondentA(Personne[] personnes, FiltreDeRechercheDePersonne filtre) {
        List<Personne> personnesTrouvees = new ArrayList<>();
        for(Personne p : personnes) {
              if  (filtre.aLesConditionsRequises(p)) {
                   personnesTrouvees.add(p);
              }
        }
        return personnesTrouvees.toArray(new Personne[personnesTrouvees.size()]);
}

et j'ai modifié une fonction dans la classe Personne :

Code:

1
2
3
4
5
6
7
8
9
10
 
  public static Personne[] recherchePersonne(Personne[] tablo, ComparateurPersonne cpp) {
           List<Personne> personnesTrouvees = new ArrayList<>();
           for(Personne p : tablo) {
                 if  (cpp.isIdentique(p)) {
                      personnesTrouvees.add(p);
                 }
           }
           return personnesTrouvees.toArray(new Personne[personnesTrouvees.size()]);
   }

Depuis la classe Exec je voudrais lancer la recherche comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Personne[] tab1; 
	   tab1=new Personne[2];
	   Personne[] tabRech; 
	   tabRech=new Personne[2];
ComparateurPersonne cp0=cp;
	   tab1[0] = new Personne("toto2", "prenom2",new 
	   GregorianCalendar(1911,2,15)); //1922,2,15));
	   tab1[1] = new Personne("toto1", "prenom1 ",new 
	   GregorianCalendar(1922,1,15)); //(1911,1,15)*/
	   tabRech[0] = new Personne("toto1", "prenom1 ",new 
			   GregorianCalendar(1922,1,15)); //(1911,1,15)
	   tabRech[0]=Personne.rechercheParNom(tab1,"toto");

tabRech[0]=Personne.recherchePersonne(tab1[0], cp0);

et j'ai l'erreur : "The method recherchePersonne(Personne[], ComparateurPersonne) in the type Personne is not applicable for the arguments (Personne, ComparateurPersonne)" alors que tab[0] est un tableau de la classe Personne et cp0 est une variable représentant l'interface ComparateurPersonne...
Si tu pouvais m'aider sur ce point Merci

19/01/2020, 11h10
joel.drigo

Bah non, tab1[0] n'est pas un tableau ! C'est tab1 qui est un tableau, tab1[0] étant un Personne de ce tableau...

Citation:

Envoyé par joel.drigo

Bah non, tab1[0] n'est pas un tableau ! C'est tab1 qui est un tableau, tab1[0] étant un Personne de ce tableau...

***************************************
oui Ok erreur de ma part...

Par contre je ne comprends pas ton code :
Code:

1 2 3 4 5 6 7 8 9 Personne[] desPersonnes = ... // on définit un filtre qui sélectionne les personnes dont l'age est inférieur à 20 FiltreDeRechercheDePersonne plusJeuneQue20Ans = new FiltreDeRechercheDePersonne() { public boolean aLesCondtionsRequises(Personne personne) { return personne.getAge()<20; } }; Personne[] personnesDeMoinsDe20Ans = RechercheDePersonnesUtils.extraireLesPersonnesQuiCorrespondentA(desPersonnes, plusJeuneQue20Ans);
C'est quoi RechercheDePersonnesUtils ?

Merci encore

Citation:

Envoyé par xeron33

C'est quoi RechercheDePersonnesUtils ?

Merci encore

C'est juste une classe où serait définie la méthode extraireLesPersonnesQuiCorrespondentA(), entre autres.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public class RechercheDePersonnesUtils { public static Personne[] extraireLesPersonnesQuiCorrespondentA(Personne[] personnes, FiltreDeRechercheDePersonne filtre) { /*...*/ } public static Personne recherche(FiltreDeRechercheDePersonne filtre, Personne...personnes) { /*...*/ } /*...*/ }

Citation:

Envoyé par joel.drigo

C'est juste une classe où serait définie la méthode extraireLesPersonnesQuiCorrespondentA(), entre autres.

OK et merci encore, m'inspirant de tes exemples j'ai créé dans la classe Personne cette méthode qui renvoit une variable Interface :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public static ComparateurPersonne FiltreSup20Ans(ComparateurPersonne cpp0) {
          	// on définit un filtre qui sélectionne les personnes dont l'age est supérieur à 20 
       	   ComparateurPersonne plusQue20Ans = new ComparateurPersonne() {
       	         public boolean aLesCondtionsRequises(Personne personne) {
       	                return personne.calculAge()>20;
       	         }
 
   				@Override
   				public boolean isIdentique(Personne p) {
   					// TODO Auto-generated method stub
   					return false;
   				}								
       	   };  
       	return plusQue20Ans;
          }

Du coup la méthode recherchePersonne fonctionne

Code:

1
2
3
4
5
6
7
8
9
10
 
 public static Personne[] recherchePersonne(Personne[] tablo, ComparateurPersonne cpp) {
           List<Personne> personnesTrouvees = new ArrayList<>();
           for(Personne p : tablo) {
                 if  (cpp.isIdentique(p)) {
                      personnesTrouvees.add(p);
                 }
           }
           return personnesTrouvees.toArray(new Personne[personnesTrouvees.size()]);
       																						}

Mais ne renvoie rien ; voilà ce qu'affiche la console :

Recherche Personne [LCours.Personne;@5b275dab

alors que j'ai dans ma classa Exec :

Code:

1
2
3
 
  ComparateurPersonne cp0=cp; //cp variable de classe 
  cp0=Personne.FiltreSup20Ans(cp0);

Puis :

Code:

1
2
3
4
5
 
tab1[0] = new Personne("tab1[0]", "prenom2",new 
	   GregorianCalendar(1911,12,15)); 
	   tab1[1] = new Personne("tab1[1]", "prenom1 ",new 
	   GregorianCalendar(1922,4,15));

donc plus de 20 ans !
Puis :

Code:

1
2
3
 
 tabRech=Personne.recherchePersonne(tab1, cp0);
	   System.out.println("Recherche Personne " + tabRech);

Voici la méthode CAlculAge

Code:

1
2
3
4
5
 
 public long calculAge() 
     { 
        return date_nais.until(LocalDate.now(),ChronoUnit.YEARS); 
     }

Si tu a s une idée merci

Citation:

Envoyé par xeron33

Mais ne renvoie rien ;
[...]
Si tu a s une idée merci

Bah j'ai plus qu'une idée, j'ai même une certitude :
Code:

1 2 3 4 5 6 7 8 public static Personne[] recherchePersonne(Personne[] tablo, ComparateurPersonne cpp) { List<Personne> personnesTrouvees = new ArrayList<>(); for(Personne p : tablo) { if (cpp.isIdentique(p)) { personnesTrouvees.add(p); } } return personnesTrouvees.toArray(new Personne[personnesTrouvees.size()]);
Or l'implémentation de isIdentique(Personne) dans l'instance de ComparateurPersonne que tu utilises, c'est
Code:

1 2 3 4 5 @Override public boolean isIdentique(Personne p) { // TODO Auto-generated method stub return false; }
Ça devrait pourtant te sauter aux yeux : si isIdentique() retourne toujours false, aucune instance de Personne n'est jamais ajoutée à personnesTrouvees.

Si tu implémentes la sélection (par rapport à l'age) dans la méthode aLesCondtionsRequises, pourquoi appeler isIdentique ?

Par ailleurs, l'idée que je voulais faire passer avec aLesCondtionsRequises, c'était qu'elle remplaçait isIdentique() (dont le nom est absurde par rapport à ce qu'elle est censé faire).
Citation:

Envoyé par xeron33

[...]
voilà ce qu'affiche la console :

Recherche Personne [LCours.Personne;@5b275dab

Quand on "affiche" un objet via les méthodes de System.out, ça envoie du texte dans un flux, texte qui correspond à une String, qui est produite par la méthode toString() de l'objet. Quand tu fais System.out.println("Recherche Personne " + tabRech); ça utilise le résultat de tabRech.toString(), qui est la chaîne ci-dessus.

Pour afficher un tableau, tu peux faire :

Code:

System.out.println("Recherche Personne " + Arrays.toString(tabRech));

Avec la classe java.util.Arrays.
Par ailleurs, cette méthode Arrays.toString() va boucler sur les éléments du tableau, et utiliser la méthode toString() de chaque élément. Donc il faut que la méthode toString() de Personne soit également implémentée (pour avoir une représentation String d'une instance de Personne).
A quoi sert le paramètre cp0 ? Il n'est utilisé nulle part !
Code:

1 2 public static ComparateurPersonne FiltreSup20Ans(ComparateurPersonne cpp0) {
Sans ce paramètre qui ne sert à rien, tu pourrais écrire directement :
Code:

1 2 ComparateurPersonne cp0=Personne.FiltreSup20Ans();
au lieu de ce "truc" :
Code:

1 2 3 ComparateurPersonne cp0=cp; //cp variable de classe cp0=Personne.FiltreSup20Ans(cp0);
Maintenant, c'est pas très normal d'avoir une méthode aussi spécifique dans une telle classe. Tu imagines si tu devais pouvoir faire n'importe quel recherche ? Il y aurais une infinité de méthodes !

Non seulement on peut faire l'instanciation d'un filtre spécifique avec une classe externe, mais on peut aussi faire une classe anonyme à l'endroit particulier où on a besoin :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 tabRech=Personne.recherchePersonne(tab1, new ComparateurPersonne() { public boolean aLesCondtionsRequises(Personne personne) { return personne.calculAge()>20; } @Override public boolean isIdentique(Personne p) { // TODO Auto-generated method stub return false; } });
En plus si tu débarrasse de isIdentique(), tu te retrouves avec une interface à une seule méthode. Du coup, tu peux faire encore plus simple avec une expression lambda :

Code:

tabRech=Personne.recherchePersonne(tab1, personne-> personne.calculAge()>20);

Citation:

Envoyé par joel.drigo

En plus si tu débarrasse de isIdentique(), tu te retrouves avec une interface à une seule méthode. Du coup, tu peux faire encore plus simple avec une expression lambda :

Code:

tabRech=Personne.recherchePersonne(tab1, personne-> personne.calculAge()>20);

************************************************
Bonsoir et merci pour ton aide.
Ok pour ce que tu dis quant aux expressions Lambdas, mais j'aimerais comprendre car je n'y arrive pas, un extrait d'un cours JAVA qui traite aussi des expressions Lamdas mais avec pour commencer cette Interface "ComparateurPersonne".
Comme je te l'avais dis avant le but est de "factoriser" quatre fonctions de recherche on va parler de seulement 2 pour simplifier par le Nom et par l'Age:
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 public static Personne rechercheParNom(Personne[] tablo,String nom) { for(Personne p:tablo) { if (p.getNom().equals(nom)) { return p; } } return null; } public static Personne rechercheParAge(Personne[] tablo,int age) { for(Personne p:tablo) { if (p.calculAge()==age) { return p; } } return null; }
Te voici un extrait du cours :

"Ces quatre fonctions ont encore une fois énormément de ressemblances. Seule la ligne de code effectuant la comparaison change d’une version à l’autre. Pour nous permettre de « factoriser » notre code, il peut être intéressant d’extraire de la fonction le code de comparaison.

Commençons par définir une interface décrivant la signature que devra respecter la fonction chargée de vérifier l’égalité de deux personnes.

Code:

1 2 3 4 5 public interface ComparateurPersonne { boolean isIdentique(Personne p); }

Il nous faut maintenant concevoir la nouvelle version de la fonction de recherche d’une personne qui utilise l’interface définie précédemment.

Code:

1 2 3 4 5 6 7 8 9 10 11 12 public static Personne recherchePersonne(Personne[] tablo, ComparateurPersonne cp) { for(Personne p:tablo) { if (cp.isIdentique(p)) { return p; } } return null; }

Il n’y a plus aucune trace de critère de comparaison à l’intérieur de cette fonction. Celui-ci sera défini lors de l’appel de la fonction."

Voilà j'ai réussi à créer une instance de l'Interface :
Code:

1 2 3 4 5 6 7 8 9 10 public static ComparateurPersonne Crit() { ComparateurPersonne Crit = new ComparateurPersonne() { @Override public boolean isIdentique(Personne p) { return true; }; }; return Crit; }
et la méthode de recherche :
Code:

1 2 3 4 5 6 7 8 9 10 public static Personne RecherchePersonne (Personne[] tablo,ComparateurPersonne cp) { for(Personne p : tablo) { if(cp.isIdentique(p)) { return p; } } return null; }
Mais bien sûr écrite comme ça ça sert à rien...
Si je rajoute :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public static Personne RecherchePersonne (Personne[] tablo,ComparateurPersonne cp) { for(Personne p : tablo) { long age=p.calculAge(); if(age>20){ (cp.isIdentique(p)) return p;} } } return null; }
ca marche mais ca marche aussi sans "cp.isIdentique(p)" :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public static Personne RecherchePersonne (Personne[] tablo,ComparateurPersonne cp) { for(Personne p : tablo) { long age=p.calculAge(); [B] if(age>20){ return p;} } } return null; }
Donc ma question est comment faire pour faire comme le dis le cours :"Il n’y a plus aucune trace de critère de comparaison à l’intérieur de cette fonction. Celui-ci sera défini lors de l’appel de la fonction"
Voilà j'espère avoir été assez clair si tu pouvais m'aider sur ce point précis . MERCI

On t'indique explicitement comment factoriser les 4 méthodes de recherche :
En utilisant une interface pour externaliser l'expression de comparaison utilisée dans chacune des quatre méthodes
Code:

1 2 3 public interface ComparateurPersonne { boolean isIdentique(Personne p); }
Bon les termes sont impropres :

ComparateurPersonne parce qu'il induit une confusion avac java.util.Comparator (et java.lang.Comparable)
isIdentique est un contresens.

Mais si on te dit de faire cette interface comme ça, fais-là comme ça.
Puis on te donne la factorisation :
Code:

1 2 3 4 5 6 7 8 9 public static Personne recherchePersonne(Personne[] tablo, ComparateurPersonne cp) { for(Personne p:tablo) { if (cp.isIdentique(p)) { return p; } } return null; }
Cette méthode remplace les quatre méthodes d'origine, le but étant

Citation:

d’extraire de la fonction le code de comparaison.

extraire, donc externaliser.
Ensuite on te demande :

Citation:

Il nous faut maintenant concevoir la nouvelle version de la fonction de recherche d’une personne qui utilise l’interface définie précédemment.

Donc en quelque sorte d'écrire les codes qui remplaceraient l'appel de chaque méthode qu'on a remplacée par recherchePersonne.
Il est évident qu'il ne faut pas modifier le code des méthodes ci-dessus pour le faire. Le code de test du critère de recherche doit être externe à la méthode recherchePersonne. Pour faire ça, on implémente l'interface.
Soit par une classe :
Code:

1 2 3 4 5 6 7 8 9 public class ComparateurPersonneParNom implements ComparateurPersonne { private final String nom; public ComparateurPersonneParNom(String nom) { this.nom=nom; } public boolean isIdentique(Personne personne) { return personne.getNom().equals(nom); } }
Code:

1 2 3 4 5 6 7 8 9 public class ComparateurPersonneParAge implements ComparateurPersonne { private final int age; public ComparateurPersonneParNom(int age) { this.age=age; } public boolean isIdentique(Personne personne) { return personne.calculAge()==age; } }
On voit qu'il nous a suffit, pour chaque méthode à factoriser :

de faire une classe d'implémentation spécifique
de reporter la condition de la méthode à factoriser dans l'implémentation de la méthode isIdentique
de mettre en attribut de classe le paramètre de la méthode à factoriser

Ainsi les appels deviennent (par exemple pour chercher une personne qui s'appelle Martin ou une personne qui a 20 ans) :

Code:

Personne p1 = recherchePersonne(tab, new ComparateurPersonneParNom("Martin"));

Code:

Personne p2 = recherchePersonne(tab, new ComparateurPersonneParAge(20));
On voit qu'on doit écrire une classe spécifique, dans son fichier .java, pour chaque méthode à factoriser. On pourrait bien sûr ne faire qu'un fichier avec une classe avec la méthode de recherche, et des classes internes pour chaque type de recherche, par exemple RecherchePersonne :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class RecherchePersonne { public static Personne recherchePersonne(Personne[] tablo, ComparateurPersonne cp) { for(Personne p:tablo) { if (cp.isIdentique(p)) { return p; } } return null; } public static class ComparateurPersonneParNom implements ComparateurPersonne { private final String nom; public ComparateurPersonneParNom(String nom) { this.nom=nom; } public boolean isIdentique(Personne personne) { return personne.getNom().equals(nom); } } /*...etc...*/ }
et faire l'appel, pour chercher une personne qui s'appelle "Martin" :

Code:

Personne p1 = RecherchePersonne.recherchePersonne(tab, new RecherchePersonne.ComparateurPersonneParNom("Martin"));
Dans le code précédent, on est limité à quatre types de recherches, donc on va avoir quatre classes qui implémentent ComparateurPersonne, mais tu imagines bien qu'on peut avoir une infinité de recherches possibles. On ne va pas implémenter une infinité de classes qui implémentent ComparateurPersonne !
Pour éviter ça on peut faire la classe spécifique là où on a besoin :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // j'ai une variable tablo de type Personne[]; // j'ai une variable nom de type String, le nom à chercher // je veux faire une recherche par ce nom, je crée une classe locale : class ComparateurPersonneParNom implements ComparateurPersonne { private final String nom; public ComparateurPersonneParNom(String nom) { this.nom=nom; } public boolean isIdentique(Personne personne) { return personne.getNom().equals(nom); } } // et j'écris le code de recherche Personne personne = recherchePersonne(tablo, new ComparateurPersonneParNom(nom));
Pour écrire un peu moins de code, on peut écrire ce code en utilisant une classe anonyme. Une classe qui n'a pas de nom.
Code:

1 2 3 4 5 6 7 8 9 // j'ai une variable tablo de type Personne[]; // j'ai une variable nom de type String, le nom à chercher // et j'écris le code de recherche Personne personne = recherchePersonne(tablo, new ComparateurPersonne() { public boolean isIdentique(Personne personne) { return personne.getNom().equals(nom); } });
On voit en plus qu'on est pas obligé d'avoir un attribut nom dans la classe anonyme avec un paramètre. On peut utiliser directement la variable nom de notre code d'appel. La seule condition est que cette classe soit finale, ou dite "effectivement finale", ce qui signifie simplement qu'elle ne change pas de valeur dans la méthode (elle est initialisée, une fois, éventuellement sous forme de paramètre, et c'est tout).
Les expressions lambda sont simplement un moyen d'écrire encore moins de code :
Code:

1 2 3 4 5 6 7 // j'ai une variable tablo de type Personne[]; // j'ai une variable nom de type String, le nom à chercher // et j'écris le code de recherche Personne personne = recherchePersonne(tablo, p-> p.getNom().equals(nom) );

Citation:
Envoyé par joel.drigo
[*]On voit qu'on doit écrire une classe spécifique, dans son fichier .java, pour chaque méthode à factoriser. On pourrait bien sûr ne faire qu'un fichier avec une classe avec la méthode de recherche, et des classes internes pour chaque type de recherche, par exemple RecherchePersonne :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class RecherchePersonne { public static Personne recherchePersonne(Personne[] tablo, ComparateurPersonne cp) { for(Personne p:tablo) { if (cp.isIdentique(p)) { return p; } } return null; } public static class ComparateurPersonneParNom implements ComparateurPersonne { private final String nom; public ComparateurPersonneParNom(String nom) { this.nom=nom; } public boolean isIdentique(Personne personne) { return personne.getNom().equals(nom); } } /*...etc...*/ }
et faire l'appel, pour chercher une personne qui s'appelle "Martin" :

Code:

Personne p1 = RecherchePersonne.recherchePersonne(tab, new RecherchePersonne.ComparateurPersonneParNom("Martin"));
*********************************************
Bsr et merci pour ton aide, c'est la solution de la classe interne que j'ai gardé je l'ai un peu modifié en créant la méthode de Recherche dans la classe Personne :
Code:

1 2 3 4 5 6 7 8 9 public static Personne RecherchePersonne (Personne[] tablo,ComparateurPersonne cp) { for(Personne p : tablo) { if(cp.isIdentique(p)) { return p; } } return null; }
Tout ça pour ça j'ai envie de dire car la méthode d'origine fonctionnait elle aussi très bien :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public static Personne rechercheParNom(Personne[] tablo,String nom) { for(Personne p:tablo) { if (p.getNom().equals(nom)) { return p; } } return null; }
En effet je vois pas trop l'intérêt de tout ça car le but était de factoriser donc d'alléger le code et je vois pas d'allègement de code si je peux m'exprimer ainsi...en tout cas grâce à ton intervention j'ai compris le fonctionnement de l'interface ComparateurPersonne en fait ComparateurPersonne transmet la variable recherchée soit le nom soit l'âge; c'est peut être là l’intérêt de cette partie du cours qui traite ensuite des Expressions Lamdas car j'ai un peu regardé et il parle de paramètres.
J'ai une question quant à :
Code:

1 2 GregorianCalendar(1999,12,15))
qui me renvoit "2000,1,15" un mois de plus...
Si tu as des infos sur ça Merci
MErci pour ton aide
A+

31/01/2020, 00h27
joel.drigo
Citation:

Envoyé par xeron33

En effet je vois pas trop l'intérêt de tout ça car le but était de factoriser donc d'alléger le code et je vois pas d'allègement de code si je peux m'exprimer ainsi...

La factorisation sert à éviter la duplication de code pas tant pour alléger que pour éviter la duplication en elle-même. Un même code écrit plusieurs fois dans un programme, ou des variantes similaires, implique que si on doit faire une modification (évolution, correction de bug), on doit la faire plusieurs fois. Le risque d'oublier un endroit se multiplie d'autant plus qu'on a plusieurs fois le même code.
Ici, dans l'exercice, la factorisation est plus un prétexte. Parce que le vrai problème sous-jacent, celui qu'on résout par des interfaces, c'est la généricité du code. Si on a une seule méthode générique qui passe par une interface pour implémenter la fonction de recherche, on n'est pas obligé à chaque fois qu'on a un nouveau type de recherche d'écrire une nouvelle méthode spécifique avec la fonction de recherche en dur à l'intérieur.

Regarde par exemple les Stream en Java. Ils permettent d'enchaîner filtre, transformation ("conversion", réductions, partitionnement, groupement...), et d'autres choses. La classe est dans le JDK et s'appuie sur des interfaces fonctionnelles. Elles permettent d'écrire tous types de recherche de façon simple et synthétique sans avoir à réécrire à chaque fois une nouvelle méthode spécifique, ce qu'on faisait avant leur apparition, par des séries de boucles imbriquées et de tests dans tous les sens. C'est là l'intérêt.

Dans le cas précis de ton exercice, le but est que tu mettes en œuvre des principes. Factorisation, interface, généricité, entre autres.

Citation:

Envoyé par xeron33

en tout cas grâce à ton intervention j'ai compris le fonctionnement de l'interface ComparateurPersonne en fait ComparateurPersonne transmet la variable recherchée soit le nom soit l'âge; c'est peut être là l’intérêt de cette partie du cours qui traite ensuite des Expressions Lamdas car j'ai un peu regardé et il parle de paramètres.

Lorsque l'interface est dite fonctionnelle, donc à une seule méthode, les codes sont encore plus synthétiques et flexibles. Les lamba permettent en quelque sorte de contourner l'impossibilité de passer une fonction en paramètre.

Regarde par exemple le cas pratique mis en œuvre ici. Essaye de résoudre le problème avec des moyens classiques (boucles, if, etc) : tu verras le gain. Essaye de changer un critère, comme l'ordre des dates, ou autre. Ou en ajouter un.
Citation:
Envoyé par xeron33

J'ai une question quant à :

Code:

1 2 GregorianCalendar(1999,12,15))

qui me renvoit "2000,1,15" un mois de plus...
Si tu as des infos sur ça Merci
1. Si tu regardes la JavaDoc de GregorianCalendar, tu verras que le paramètre "mois" est une valeur qui va de 0 à 11. Donc le mois 12, c'est le mois 0 de l'année suivante de 1999, donc le mois de janvier 2000.
2. GregorianCalendar, Calendar et java.util.Date sont des vieilles classes qui utilisent une sorte d'astuce inadaptée (un long, un nombre d'unité de temps depuis une base) pour gérer les dates. Astuce qui implique certains problèmes de gestion, en particulier pour les périodes, les différences, entre autres.
  
  On n'utilise plus ça depuis l'apparition de l'API java.time en Java 8. Avant, même, quand on voulait gérer correctement des dates, on s'orienté vers l'API tierce JODA Time.