héritage inverse générique

Bonjour,
je cherche un mécanisme générique qui permet de passer d'une instance d'une classe mère à une instance d'une classe fille héritée.
exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class Mere { public Mere() {}   public Mere(String name) { this.name = name; }   public String getName() { return name; }   String name; }

---

Code:

---

1 2 3 4 5 6 7 8 9 10

public class Fille extends Mere { public Fille() { super(); } public static void main(String[] args) { Mere mere = new Mere(); Fille fille = (Fille) mere; // Cast impossible } }

---

Je cherche donc un mécanisme qui permet de convertir un type parent en type hérité de manière générique, sans utiliser de constructeur par recopie:mrgreen:.

Je recherche quelque chose du style.

Code:

---

Object Converter.convert(Object parent, Object hérité)

---

où parent est une instance déjà existante et hérité le type que je souhaite obtenir en retour. Je pense que cela doit être faisable avec la réflexion, et peut-être existe-t-il des API faisant cela.

Merci d'avance.

Salut,

Citation:

---

Envoyé par memedidou

sans utiliser de constructeur par recopie:mrgreen:.

---

C'est la seule solution ! :mrgreen:

a++

houlà, tu cherche à faire des trucs bizzares :)

Tu peux éventuellement, si Mere et Fille ont tous les deux un constructeur générique, passer par PropertyUtils.copyProperties() de commons beanutils (projet jakarta)

En effet, je pense que tu dois pouvoir obtenir quelque chose du genre :

Code:

---

1 2 3

Mere mere = new Mere(); Fille fille = (Fille)Converter.convert(mere, Fille.class);

---

C'est presque ce qu'il me faut, ca avance vite ! :D

J'ai essayé :

Code:

---

PropertyUtils.copyProperties(fille, mere);

---

Par contre, ca ne marche que dans le cas ou la classe mère possède un ensemble de setter.:?
Or ma classe Mere ne possède pas que des couples get/set mais aussi des "put" dans des HashMap et des get de ces HashMap.:evilred:

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

import java.util.HashMap;   public class Mere {   public Mere() { map = new HashMap<String, String>(); }   public void setName(String name) { this.name = name; }   public String getName() { return name; }   public void addElement(String key, String value) { map.put(key, value); }   public HashMap<String, String> getMap() { return map; }   private String name; private HashMap<String, String> map;   }

---

je continue de chercher dans ce que fournit Apache.
Si il y a d'autres idées ?

ben si tu veux que ce soit transférable, va falloir mettre ta hasham avec un setter :)

merci de ce conseil très constructif ;)
mais si je poste ce problème, c'est bien parce que je ne peux pas modifier le code de la classe Mere. :cry:

be va falloir que ton Converter traite le cas particulier de la hashmap pour la trasférer :)

Citation:

---

Envoyé par theyankee76

En effet, je pense que tu dois pouvoir obtenir quelque chose du genre :

Code:

---

1 2 3

Mere mere = new Mere(); Fille fille = (Fille)Converter.convert(mere, Fille.class);

---

---

Utilise quelque chose qui ressemble à cela ;) Très utile la réflection

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

for (Field fieldSource : objectSource.getClass().getDeclaredFields()) { fieldSource.setAccessible(true); Field fieldDest;   try { fieldDest = objectDest.getClass().getSuperclass().getDeclaredField(fieldSource.getName()); fieldDest.setAccessible(true); fieldDest.set(objectDest, fieldSource.get(objectSource)); fieldDest.setAccessible(false); } catch (SecurityException e) { e.printStackTrace(); } catch (NoSuchFieldException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } finally { fieldSource.setAccessible(false); } }

---

Ok, j'ai fait comme ca et ca marche impec ! :D

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

import java.lang.reflect.Field;   public class Converter { /**      * Convert an object to another respecting the choosen class Destination.      * It makes downcasting from parent to child.      *      * @param classDest the class to which you want a new object      * @param objectSource the object to convert      * @return an instance of classDest initialized with objectSource values      */ public static Object convert(Class<?> classDest, Object objectSource) { if (!objectSource.getClass().equals(classDest.getSuperclass())) { System.out.println("Incompatible Class"); return null; }   Object objectDest = null; try { objectDest = classDest.newInstance(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); }   for (Field fieldSource : objectSource.getClass().getDeclaredFields()) { fieldSource.setAccessible(true); Field fieldDest;   try { fieldDest = objectDest.getClass().getSuperclass().getDeclaredField(fieldSource.getName()); fieldDest.setAccessible(true); fieldDest.set(objectDest, fieldSource.get(objectSource)); fieldDest.setAccessible(false); } catch (SecurityException e) { e.printStackTrace(); } catch (NoSuchFieldException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } finally { fieldSource.setAccessible(false); } } return objectDest; } }

---

L'avantage de ce converter est qu'il ne fait pas de recopie car les attributs de l'objet dest et source ont les mêmes "id".
On peut enfin faire du transtypage descendant (downcasting) !!! :yaisse2:

Par contre, un utilisateur peu scrupuleux peut quand à lui obtenir la valeur d'une variable qui est considérée comme "private" de manière très simple. :?

Merci à tous.

Citation:

---

Envoyé par memedidou

On peut enfin faire du transtypage descendant (downcasting) !!! :yaisse2:

---

Ce n'est pas du downcasting, puisque qu'un cast ne change en rien le type réel de l'objet.

Le downcasting correspond tout simplement à ce qu'on appelle généralement un cast :

Code:

---

1 2	Mere mere = new Fille(); Fille fille = (Fille) mere;

---

Citation:

---

Envoyé par memedidou

Par contre, un utilisateur peu scrupuleux peut quand à lui obtenir la valeur d'une variable qui est considérée comme "private" de manière très simple. :?

---

Et en environnement protégé ton code ne pourra fonctionner que si tu as les droits "suppressAccessChecks". Un constructeur par recopie aurait été plus simple à mettre en place...



Par curiosité : quel est la finalité de tout cela ?


a++

J'utilise un grand nombre de classes Mere que j'ai besoin d'étendre avec en plus une ou plusieurs nouvelles implémentations.
Or je ne récupère que des instances de classes Mere et j'ai besoin d'utiliser des instances de classes Fille, d'où mon besoin de "caster" ma classe Mere en Fille.

Code:

---

1 2 3 4 5 6 7 8 9

public class Fille extends Mere implements AutreInterface { public Fille() { super(); } public AutreMethodImplemented() { //code de l'implémentation à utiliser } }

---

Cette façon de faire m'a parue la plus simple à mettre en place. Ca me semble aussi plus propre qu'un constructeur par recopie car si un nouvel attribut et ajouté à la classe Mere, celui ci n'est pas automatiquement recopié (par le constructeur) dans la classe Fille.

un "bon" design dans ce genre de cas serait plutot, je pense:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class Machin implements AutreInterface{ protected Mere mere; public Machin(Mere mere){ this.mere=mere; } public Mere getMere(){ return mere; } public void autreChose(){ //TODO }   }

---

Ca c'est pour le plus propre, mais çà conviens pas nécessairement à tout. Une autre solution c'est le delegate Pattern, un peu plus dur à gérer, mais toujours potable:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public Fille extends Mere implement AutreInterface{   private Mere delegate; public Fille(Mere mere){ this.delegate=mere; } // implement AutreInterface public void autreChose(){ //TODO } // delegate call to truc public void truc(){ delegate.truc(); } // delegate call to setThing public void setThing(Thing thing){ delegate.setThing(thing); } }

---

L'avantage, c'est que pour les appel délégué, tu pose ton curseur sur la déclaration de "Mere delegate" dans eclipse puis tu va dans source -> generate delegate methods, çà va scanner la classe et faire tous les appels délégué.

Avantage:
Si Mere à un lifecycle particulier, géré par un truc extérieur, tu ne l'altère pas (t'ajoute juste une coque sur un objet existant, sans détruire cette objet)
Si Mere est utilisé ailleurs, les Changement sur Fille sont refleté sur l'objet de type Mere, et vice-versa.

J'ai utilisé cette technique quand j'ai du décorer des objets session hibernate, j'avais pas facilement le controle sur leur production -> utilisation d'un Delegate pattern.