IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

avec Java Discussion :

Suppression en cascade de LinkedList - Comparaison de classes


Sujet :

avec Java

  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Novembre 2009
    Messages
    34
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2009
    Messages : 34
    Par défaut Suppression en cascade de LinkedList - Comparaison de classes
    Re-bonjour, j'ai dans mon application, un objet A composé d'objet B, qui lui meme est composé d'objet C ( et compose donc A), composé de D qui lui est composé de E, pour cela j'utilise les LinkedList.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public class Compose<T> {
        protected T c; // C l'objet composé
    (..)
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class ComposéDe<T extends Compose> {
        protected LinkedList<T> cde;
    
    ComposéDe()
        {
            cde=new LinkedList<T>();
        }
    (...)
        public void effacer()
        {
             // Cf. plus bas
        }
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class ComposéDeCompose<T1 extends Compose,T2> extends Compose<T2> implements IntComposéDe<T1> {
        protected ComposéDe C;
     
        ComposéDeCompose()
        {
            super();
            C=new ComposéDe();
        }
    (...)
     
    }
    A hérite de ComposéDe<B>, E de Compose<D>, le reste du type :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public class B extends ComposéDeCompose<C,A>
    {
    ..
    }
    Je cherche a faire une suppression en cascade, supprimer A reviendrais a supprimer tous ses Objet B, pour lesquels on supprimerais tous leurs Objet C etc
    La méthode que je cherche a écrire est la suivante :

    Je teste si ma liste est composé d'objet composé d'autres objets, si oui, suppression en cascade, sinon, je supprime les éléments de la liste.

    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
    public void effacer()
        {
            ListIterator iter=this.cde.listIterator();
            Class cls=this.cde.getClass().getComponentType();
            if(cls instanceof ComposéDeCompose)
            {
               // Suppression 
            }
            else
            {
                 while(iter.hasNext())
                 {
                     iter.next();
                     iter.remove();
                 }
            }
        }
    C'est ce qui est en gras qui pose problème, lorsque je fais un essai avec un document par exemple, cette ligne
    return this.cde.getClass().getComponentType();
    me renvoie null au lieu de page, je comprend pas.
    Cette ligne aussi pose problème
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if(cls instanceof ComposéDeCompose)
    Cela me dit
    inconvertible types
    required: document.ComposéDeCompose
    found: java.lang.Class

    Really need help, ne serait-ce qu'une indication

    Merci d'avance

  2. #2
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 582
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 582
    Par défaut
    getComponentType() ne s'applique qu'aux tableaux.

    Les génériques n'existent que compile-time, ils disparaissent à la compilation et n'existent pas au runtime. Par conséquent, on ne peut pas faire d'introspection sur le type véritable d'un paramètre générique.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  3. #3
    Membre averti
    Profil pro
    Inscrit en
    Novembre 2009
    Messages
    34
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2009
    Messages : 34
    Par défaut
    Pour supprimer en cascade je dois vérifier si la liste est composé d'objet qui eux meme sont composé, cela doit forcément passer par une comparaison pour qu'une fois arriver au dernier objet composé cela ne pose pas de problème.

    Comment je pourrais récuperer le type d'une Liste et le comparer avec la classe "ComposéDeCompose" ?

  4. #4
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 582
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 582
    Par défaut
    Citation Envoyé par Bakouz Voir le message
    Comment je pourrais récuperer le type d'une Liste et le comparer avec la classe "ComposéDeCompose" ?
    Tu ne peux pas, tu dois te débrouiller autrement.

    Une idée serait d'avoir une classe dédiée à contenir des ComposéDeCompose, et que cette classe-là, dans sa méthode effacer(), fasse la suppression en chaîne. Les autres, étant de classe différente, ne sont pas censées contenir des ComposéDeCompose, et donc n'ont pas de suppression en chaîne à faire.

    Ah, au fait : pour vider une collection c'est pas la peine de la parcourir : clear() c'est très bien.
    Et je rappelle que Java est garbage-collecté : la suppression en chaîne, elle se fait toute seule.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  5. #5
    Membre averti
    Profil pro
    Inscrit en
    Novembre 2009
    Messages
    34
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2009
    Messages : 34
    Par défaut
    Je serais toujours bloqué au moment ou j'arriverais au dernier objet composé non ?

    Edit : Je crois avoir trouvé, avec la comparaison d'instance sur les Iteration et non sur la LinkedList elle meme
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public void effacer()
        {
            ListIterator iter=this.cde.listIterator();
            while(iter.hasNext())
            {
              T t=(T)iter.next();
              if(t instanceof ComposéDeCompose)
              {
                  ComposéDeCompose t2=(ComposéDeCompose)t;
                  t2.effacer();
              }
              iter.remove();
            }
        }
    Je sais pas pourquoi j'y ai pas pensé avant, ca oblige a comparer tous les derniers objets mais s'il y a pas d'autre moyens.

  6. #6
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 582
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 582
    Par défaut
    Il y a au moins deux moyens plus courts, dont celui que je t'ai donné, mais bon, tu y reviendras quand tu auras un peu l'habitude des design patterns et du polymorphisme.

    Si je te donne un truc tout cuit ça servira à rien, et j'aurai perdu pas mal de mon temps.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

Discussions similaires

  1. Requetes de suppression en cascade
    Par log2n dans le forum Décisions SGBD
    Réponses: 1
    Dernier message: 20/05/2005, 10h07
  2. Suppression en cascade
    Par log2n dans le forum Langage SQL
    Réponses: 2
    Dernier message: 19/05/2005, 20h33
  3. [debutant]suppression en cascade
    Par christophebmx dans le forum MS SQL Server
    Réponses: 12
    Dernier message: 03/05/2005, 09h51

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo