Discussion :

[buscatier]

Je cherche à reprendre des programmes écrits en C++ pour les intégrer à des applis mobiles. J'explore la possibilité de les transposer en java.
Mes programmes (dont certains ont été écrits avant l'avènement de java) utilisent beaucoup le transtypage. Mes données sont structurées en arborescence d'objets chaînés. En parcourant l'arborescence, selon les types d'objets, je peux utiliser les méthodes correspondant au type de chaque objet rencontré.

Mes mécanismes C++ ne peuvent pas être transposés en java puisqu'ils utilisent des pointeurs transtypés.
Je vois qu'en java il existe des tas de possibilités pour lister ou chaîner des objets, mais je n'en discerne aucune qui permette d'appliquer un tel mécanisme polymorphique.

Comment peut-on résoudre ce problème en java ?

[gervais.b]

Java a tout ce qu'il faut pour gérér le polymorphisme. Mais votre question me semble vague..

Auriez-vous une exemple de ce code C++ avec une eventuelle explication de ce que ça fait (les entrées et sorties) pour que l'on puisse mieux vous aiguiller ?

[buscatier]

//Voila l'exemple de mécanisme C++ que je cherche a transposer en java :

Code C++ :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#define T1 1
#define T2 2
 
class obj{
    int typeobj;
public:
    virtual int getType() {return typeobj;}
    obj(int typ):typeobj(typ){}
};
 
class objtype1 : public obj{
public:
    void methodeType1(){//...
        }
    objtype1() : obj(T1){}
};
 
class objtype2 : public obj{
public:
    void methodeType2(){//...
        }
    objtype2() : obj(T2){}
};
 
////////////////////////////////
 
void process(obj * pObj){
    switch (pObj->getType())
    {
	case T1: ((objtype1 *)pObj)-> methodeType1();
            break;
        case T2: ((objtype2 *)pObj)-> methodeType2();
            break;
    }
}
 
void test(){
    obj * pO=new objtype2();
    process(pO);
}

[gervais.b]

Ce qui me semble important c'est le switch et le cast. Ca donnerait donc ceci en Java :

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 TypedObject {
   final int type;
   TypeObject(int type) {
     this.type = type;
   }
}
 
class Type1 extends TypedObject {
  Type1() {
    super(1);
  }
}
 
void process(TypedObject obj) {
  switch (obj.type) {
    case 1:
      ((Type1) obj).methodType1();
    // ...
  }
}

Mais, vous pouvez utiliser du polymorphisme sans le switch :

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
 
abstract class TypedObject {
  void method();
}
 
class Type1 {
  void method() {
    // Comportement pour le type 1
  }
}
 
 
class Type2 {
  void method() {
    // Comportement pour le type 2
  }
}
 
void process(TypedObject obj) {
  obj.method();
}

Si vous voulez "juste" réagir différement en fonction du type, il y à aussi le "double dispatch" avec le pattern "visitor". Il est plus verbeux mais élégant et sur.

[buscatier]

Votre 2eme exemple ne résout pas mon problème puisqu'il nécessite que les méthodes existent de manière virtuelle dans la classe de base.
Par contre dans votre 1er exemple :

Code :

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

   case 1:  ((Type1) obj).methodType1();

c'est ce que j'appelle du transtypage, je ne savais pas qu'on pouvait l'utiliser, a priori ça implique un contrôle à l'exécution, puisque le compilateur ne peut pas vérifier l'usage de la bonne classe.
Ok, je vais essayer ça, merci !

[gervais.b]

Alors en effet, le transtypage/casting ou le double-dispatch est la solution.

Notez que vous pouvez aussi vérifier le type d'une instance

Code :

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

1
2
3
4
 
if ( obj instanceof Type1) {
  ((Type1) obj).methodType1()
}

.Depuis Java 14 vous pouvez même éviter le casting juste après le "if".

Code :

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

1
2
3
4
 
if ( obj instanceof Type1 t1) {
  t1.methodType1()
}

[buscatier]

Parfait, ça fonctionne bien !
A part la 2e syntaxe qui ne veut pas se compiler, mon java doit être un peu vieux !
Merci !