Je cherche à produire un diagramme UML de la structure des classes méthodes etc...
Donc une classe contient des méthodes, lesquels contiennent des variables etc...
Ca existe déjà ?
Version imprimable
Je cherche à produire un diagramme UML de la structure des classes méthodes etc...
Donc une classe contient des méthodes, lesquels contiennent des variables etc...
Ca existe déjà ?
:google: Reverse engineering ?
oui ca doit exister, non ca ne fait pas de miracle.
Eclipse aussi, ca répond a ta question....
Mais ne t'attend pas à avoir un UML digne d'un concepteur : ce sera une "bête" vue de ton code !
Merci pour ta réponse mais je vais reformuler:
je cherche à avoir un diagramme UML générique du langage JAVA, non de mon code.
Quand je parle du langage JAVA je ne parle pas non plus de l'API java.
Tu veux le méta modèle de java ?
Genre un diagramme sur lequel tu as une classe "Classe" associée à une classe "Attribut" et une classe "Méthodes" ?
voilà c'est ca.
il suffit de reverser la version Java de JavaCitation:
Envoyé par Alec6
La chose est possible avec http://bouml.fr, je m'en sers pour les benchmarks
Cependant un diagramme UML générique ne sera pas assez, le reverse de Java version 6 (update 1) produit 9425 classes, 48506 attributs / relations, et 85939 opérations, il faudrait un très gros diagramme pour tout placer :lol:
bon reverse
:mrgreen:
A mon avis, il veut plus simple que cela :D car il précise : 'je ne veux pas le diagramme de l'api Java'
A mon avis, le mieux est que tu le fasse et que tu nous le présente pour le soumettre à notre avis.
alors il suffit de reverser java/lang où on trouve Class, Enum, Method ...
cela prend 10 secondes avec Bouml et produit 203 classes , 441 attributes, 393 relations et 2079 operations
Dis donc, j'hésitais à utiliser ton outil (parceque au boulot ca va être dur de l'instaurer comme standard...) mais la, je sens qu'il me plait de plus en plus :king:
si je fais un rapide diagramme avec les éléments de base, cela donne :
http://bouml.fr/javamod.png
Note : arg, j'ai introduit un bug dans le reverse, il crée des réalisations stéréotypées bind au lieu de simple héritages (j'ai corrigé dans le diagramme) :oops:
Mon modèle commence comme cela.
A l'arrivé je devrais pouvoir avoir une sorte d'interpréteur sur lequel travaillé.
C'est à dire que je voudrais dans mon programme crée l'objet classe avec des méthodes et du code dedans et lui dire vas y execute, le code.
Ou par exemple demander à une méthode d'analyser sa propre complexité.
il y a plusieurs choses bizarres dans ton diagramme :
- classe hérite de section
- section possède des attributs (se serait plutôt des variables d'après ce que je peux comprendre)
- condition hérite de section
- la remonteée des conditions au niveau section
- etc...
A mon avis, tu n devrais pas te centrer sur "Section".
Tu devrais avoir une interface comme point central, avec une/des méthodes (comme "execute()" notamment)
Et tu applique le pattern stratégie pour différentier l'execution du code.
Si c'est une sorte d'interpréteur que tu veux faire, tu as le patron "Chaine de responsabilité" qui peut t'aider (attention : difficile de détecter certaines erreurs et présenter de beaux messages au user)
j'irai même plus loin : ce n'est pas une 'bonne' classeCitation:
Envoyé par hed62
oui, il te faut une interface Instruction ayant, entre, autre une opération evalCitation:
Tu devrais avoir une interface comme point central, avec une/des méthodes (comme "execute()" notamment)
il suffit de redefinir eval sur chacunes des sous classes, chaque structure de controle (while, if ... affectation ...) étant une de ces sous classes, de même que les déclarations de variables locales, par exemple :Citation:
Et tu applique le pattern stratégie pour différentier l'execution du code.
http://bouml.fr/while.png
tout cela me rappelle ma principale contribution dans Xcoral, c'est à dire smac, un mini interpréteur C. La chose était écrite en C mais avec l'équivalent manuel des héritages et opérations virtuelles. Je ne l'avais pas fait en C++ car à cette époque C++ n'existait pas encore vraiment, c'était juste un pré-processeur produisant du C ... c'était il y a longtemps ;)
En faite je sais pas trop ou je vais au final.
Quand on regarde du code en Java on voit nettement des blocs qui sont encadrés par des singletons (j'appel ces blocs des sections, mais un nom plus appropriés est nécessaire je pense).
Le roles des singletons est avant tout de délimité la portée des variables.
Dans une méthode par exemple on peut mettre des singletons (ca m'arrive lorsque je fais des constructions d'IHM compliquées et que l'utilisation de méthode n'apporte rien sur un plan sémantique).
Ces blocs peuvent avoir un nom (le nom de la méthode, de la classe ou encore un nom du genre monNom:{} .
Les classes, et méthodes, les conditions et les boucles (do while, for) sont des sections également puisqu'ils contiennent du code entre singleton.
Mais je pense que ce sont des sections particulières qui différent par:
- des conditions d'entrée dans le bloc (c'est particulièrement vrai pour les condition: si blabla alor faire { }, mais aussi pour les boucles
- des conditions de sortie du bloc=problème de l'itération pour les boucles
Je ne sais pas encore comment envisager les arguments des méthodes et les retour des fonctions.
Donc je commence à élucider un pattern qui est composé du trio: la section (un process serait peut etre plus approprié) avec son droit d'entrée, et son droit de sortie (ou règle d'itération). J'ai des problèmes avec le glossaire donc rectifiez moi si possible.
Ce pattern je pense le dérivé donc pour la condition je me retrouve avec un condition qui étend section et comporte une régle d'entree qui étend entrance condition (si besoin) et une règle de sortie qui laisse toujours sortir.
En effet, Stratégie n'est pas nécessaire, puisque la focntion ne changera pas à l'execution.
A mon avis :
transforme Section en IInstruction (il y a bien 2 I : Interface Instruction ;) )
Met y une fonction eval/execute
Method devient une IInstruction composée de IInstruction et délègue le travail pour la fonction eval.
Ajoute un "référenciel" : sorte de repository d'information pour tes variables, globles ou locales (en fait c'est ta classe Variables je pense... Mais le lien me parait étrange)
Place des cardinalités , j'ai du mal à suivre/savoir si tu agrège/compose vraiment ou juste hérite en te trompant de flèche (notamment la relation Section<*>-->Affectation )
cela se voit ...Citation:
Envoyé par Alec6
ce n'est pas ce que vois, moi je vois des classes, des attribut/relation et des operationsCitation:
Quand on regarde du code en Java on voit nettement des blocs qui sont encadrés par des singletons (j'appel ces blocs des sections, mais un nom plus appropriés est nécessaire je pense)
puis dans une operation il y a une liste d'instructions, dont certaines sont des declarations de var, mais on est deja tres bas
encore une fois une decla de var n'est pas un cas a ce point spécial qu'il conditionne tout le resteCitation:
Le roles des singletons est avant tout de délimité la portée des variables
oh lala, quel mélange, une classe est une chose, une opération une autre et une suite d'instruction encore une autre, rien de commun entre eux, et certainement pas l'utilisation d'une classe commune 'fourre tout'Citation:
Ces blocs peuvent avoir un nom (le nom de la méthode, de la classe ou encore un nom du genre monNom:{} .
penses sémantique et non syntaxe, cela ira nettement mieuxCitation:
Les classes, et méthodes, les conditions et les boucles (do while, for) sont des sections également puisqu'ils contiennent du code entre singleton. ...
tu as vu ma proposition pour while ?Citation:
Mais je pense que ce sont des sections particulières qui différent par:
- des conditions d'entrée dans le bloc (c'est particulièrement vrai pour les condition: si blabla alor faire { }, mais aussi pour les boucles
- des conditions de sortie du bloc=problème de l'itération pour les boucles
8O tu n'as rien de plus compliqué a proposer ?Citation:
Donc je commence à élucider un pattern qui est composé du trio: la section (un process serait peut etre plus approprié) avec son droit d'entrée, et son droit de sortie (ou règle d'itération). J'ai des problèmes avec le glossaire donc rectifiez moi si possible.
Ce pattern je pense le dérivé donc pour la condition je me retrouve avec un condition qui étend section et comporte une régle d'entree qui étend entrance condition (si besoin) et une règle de sortie qui laisse toujours sortir.
franchement faire un interpréteur comme ma propal avec While est simple, clair, et en plus très performant (je le sais, c'est comme cela que cela marche dans Xcoral, et l'interpreteur est utilisé pour calculer les indentations, colorisation etc ... et le tout est immédiat, personne ne remarque que cela agite du C interprété)
Oui mais je fais pas uniquement un interpréteur.
Je veux parser du code java pour produire en gros un AST.
L'AST doit me permettre de facilement travailler sur le code, donc je veux avoir des briques intelligentes capables de me renvoyer des informations sur le couplage, la complexité etc...
Et l'AST doit également etre capable de se réécrire en Java pour finir en comilation et reload à chaud.
Dans vos approches tout est instruction, tandis que dans la mienne tout est process (j'aimerai aussi expérimenter une approche systémique).
Je comprends bien l'utilisation d'une interface générique avec un fonction exec.
Je ne sais pas par contre qu'elles sont les limites des deux approches.
Je pense que mon approche est logique aussi.
Apparemment tu ne t'intéresses pas aux aspects "traditionnels" du langage Java. En effet, un exemple bien admis de méta-modèle Java est visible sur le slide n°9 du document ci-après :
http://dawis2.icb.uni-due.de/events/...SLIDES/Han.pdf
La modélisation du contenu du corps des méthodes (déclaration, invocations, structure de contrôles, etc) est bien plus bas niveau.
Ton slide me parait être exactement ce qu'il cherche ;)
et j'avoue qu'il est bien interressant pour moi! Merci :king: