Discussion :

[samplaid]

Imaginons que (ObjetA instanceof C == true) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Class A {
     A gauche;
     A droite;
     public void simplifier() {
          if ( gauche instanceof B && droite instanceof B)
//               j'aimerais changer l'instance en B par exemple
     }
}
 
Class B extends A {}
Class C extends A {}
Class D extends A {}

[natha]

Code :

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

1
2
3
4
5
6
7
8
     public void simplifier() {
          if ( gauche instanceof B && droite instanceof B) {
//               j'aimerais changer l'instance en B par exemple
                 B gaucheB = (B) gauche;
                 B droiteB = (B) droite;
                 // code utilisant ces instances...
          }
     }

Par contre tu ne pourras pas modifier les variables d'instance elles-même.

En Java5 et + c'est possible en utilisant les génériques :

Code :

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

1
2
3
4
5
6
7
8
Class A<T extends A> {
     T gauche;
     T droite;
}
 
Class B extends A<B> {}
Class C extends A<C> {}
Class D extends A<D> {}

Tu pourras faire ça directement sans caster ni tester les types :

Code :

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

B gaucheB = B.gauche;

[herve91]

Tu ne peux pas changer le type d'un objet une fois celui-ci construit.
Tu pourrais utiliser un attribut qui contiendrait le type de l'objet :

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
23
24
25
26
Class A {
     A gauche;
     A droite;
     Type type = Type.TypeA;
 
     public void simplifier() {
          if ( gauche.getType() == TypeB && droite.getType() == TypeB)
            setType(TypeB);
     }
 
     public Type getType() {
       return type;
     }
 
     public setType(Type type) {
       this.type = type;
     }
}
 
enum Type { TypeA, TypeB, TypeC, TypeD;
 // méthodes...
};
 
Class B extends A {}
Class C extends A {}
Class D extends A {}

[natha]

Tu ne peux pas changer le type d'un objet une fois celui-ci construit.
Tu pourrais utiliser un attribut qui contiendrait le type de l'objet :

Ca s'est dangereux car on peut quand même affecter un type A même si on type Type.B
Ou alors il faut des getters/setters qui incluent des contrôles.

Les génériques ou des instanceof dans ce genre de cas, c'est quand même le plus clair.

[merill]

on peut utiliser un design pattern state pour gerer le changement d'etat (ici l'etat c'est le "type")

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
 
class Node{
  A moi
  Node gauche;
  Node droite;
 
  void simplifier(){
    if(gauche.moi instanceof B && droite.moi instanceof B){
      moi=new B();
    }
  }
}
 
class A{
 traitement(){...}
}
 
class B extends A{
  traitement(){...}
}