Simplifier fonctions en Java

Version imprimable

Bonjour,

Voilà se que je souhaite faire : j'ai un objet en java 'mon_objet' et je souhaite le tester avec des fonctions :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class mainClass {
    public static void main() {
        mon_objet A = new mon_objet("X");
        test(A);
    }
 
    public Boolean test(mon_objet A) {
        Boolean res_of_test = false;
        if (test_001(A)) {
            if (test_002(A)) {
                if (test_003(A)) {
                    [...]
                        if (test_00n(A)) {
                            res_of_test = true;
                        }
                }
            }
        }
        return res_of_test;
    }
}

j'aimerais simplifier mon code avec un truc du genre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class mainClass {
    public static void main() {
        mon_objet A = new mon_objet("X");
        test(A);
    }
 
    public Boolean test(mon_objet A) {
        list_of_test list_of_test = new list_of_test();
        while (list_of_test(A))
           list_of_test.next();
        return list_of_test.isFinished();
    }
}

comment faire svp ?
Merci.

21/04/2015, 15h03
Monolulu

Bonjour,

Ce que tu cherches à faire me semble assez tordu... Tu voudrais faire une liste de fonction?
À ma connaissance, ce n'est pas possible. En revanche, tu peux te tourner vers les tests unitaires avec JUnit qui feront ce que tu recherches, ensuite tu ne pourras plus t'en passer :D

Je te conseil donc de te pencher sur divers tutos que tu pourras facilement trouver sur internet.
21/04/2015, 15h45
wax78

Peut être en utilisant l'API Reflection. Mais j'avoue ne pas avoir bien saisi l'idée de base.
21/04/2015, 16h06
CliffeCSTL

L'idée c'est de faire passer une batterie de test à mon objet A.
On doit s'arrête lorsqu'un test échoue.

Je voulais juste faire ça de manière propre et évité de mettre des 'if' tout moche partout :lol:.
21/04/2015, 16h13
wax78

Alors JUnit comme proposé par monolulu.
21/04/2015, 17h24
thelvin

Voui enfin, JUnit ne s'arrête pas quand un test est mauvais.

Et en fait je comprends pas l'intérêt de s'arrêter quand on veut faire des tests unitaires. Du coup j'ai l'impression que le besoin est autre.

Si c'est réellement des tests unitaires, utiliser JUnit eviterai de réinventer la roue.

Mais pour revenir au probleme de base, ce que tu cherches à faire ressemble beaucoup à quelque chose facilement réalisable avec du polymorphisme de base.

Un truc du genre:

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
// Utiliser une classe ou une interface selon ce qui est le plus simple
abstract class Test
{
   // Dans les methodes de executeTest, tu mettrais ce que tu as mis dans test_XXX(A)
   abstract boolean executeTest(mon_objet A);
}
 
class Test1 extends Test
{
   boolean executeTest(mon_objet A)
   {
      return A.getId() == 12;
   }
}
 
 
class Test2 extends Test
{
   boolean executeTest(mon_objet A)
   {
      return A.getValue() == 42;
   }
}
 
// A mettre la ou tu veux faire tes tests
boolean executeTests(mon_objet A)
{
   // Creation de la batterie de tests
   ArrayList<Test> listTests = new ArrayList<Test>();
   listTests.add(new Test1());
   listTests.add(new Test2());
   for(Test test : listTests)
   {
      if(test.executeTest(A) == false)
         return false;
   }
   return true;
}

Note que je n'ai pas testé ce code donc il pourrait ne pas compiler. Mais l'idée est la...

22/04/2015, 09h11
CliffeCSTL

Je précise que ça n'a rien a voir avec des test unitaires :zoubi:
22/04/2015, 10h10
joel.drigo

Salut,

Pourtant ça ressemble pas mal à des tests unitaires. Maintenant de façon plus générale (donc pas obligé que ça soit des tests, ça pourrait être des transformations successives), ce que propose @hwoarang est une solution à ton problème (la méthode s'appelle executeTest, mais elle pourrait s'appeler n'importe comment d'ailleurs - ça pourrait même être une java.util.Function par exemple).

Sinon la solution polymorphique, depuis Java 1.8 ya pas vraiment besoin de créer une classe Test, il y a déjà la classe Predicate.

Du coup définir un ensemble de tests ça ressemble à ça :
Code:

1 2 3 4 5 6 7 8 public static final Predicate<MonObjet> tests = Arrays.<Predicate<MonObjet>>asList( // ici les tests, là j'en mets 3 o -> o != null, o -> o.hashCode() != 0, o -> o.toString().length() < 10 ).stream().reduce(o -> true, (p1, p2) -> p1.and(p2));
et ça s'utilise comme ça (dans la même classe) :
Code:

1 2 3 4 5 6 MonObjet a = obtenirMonObjet(); if(tests.test(a)) { // ... } else { // ... }
Évidemment, une fois qu'on en arrive là, il faut savoir se demander pourquoi on a pas fait tout simplement :
Code:

1 2 3 4 5 6 7 8 9 if( a != null && a.hashCode() != 0 && a.toString().lenght() < 10 ) { // ... } else { // ... }
ou pour reprendre l'exemple de la question initiale :
Code:

1 2 3 4 5 6 7 8 9 10 if( test_001(a) && test_002(a) && test_003(a) && test_004(a) ) { // ... } else { // ... }
Suivant les cas l'un ou l'autre peut être plus simple. Mais il faut pas trop chercher la complexité non plus.