Bonjour,

Dans le cadre de mon enseignement, je dois réaliser un projet qui demande la réalisation d'un système ouvert (type smalltalk) implémenté sur le langage java.
Voici les aspects qu'on nous a proposé :
Aspects réflexifs possibles :

Meta-Operation : Des objets comme des meta-objets
Structure : Les classes comme des objets
Semantics : Le compilateur est un objet
Message-Sending : Les messages sont des objets
Control State : Les processus comme des objets
Voulant faire quelque chose d'assez simple, je suis partie sur la Meta-Operation et Structure. Et aussi parce que je ne vois pas comment implémenter le reste :s

Dans mon diagramme de classe je suis partie avec la classe représentant mes objets ST_Object_Class comme la racine et source de toutes les autres classes.

De cette classes hérite ST_Class_Class puis ST_MetaClass_Class.


Pour la modélisation d'un objet dans la classe ST_Object_Class, je suis partie du principe qu'un objet avait une liste de propriété et appartiens à une classe :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
private HashMap<String, ST_Object_Class> ST_propertys = new HashMap<String, ST_Object_Class>();
    private ST_Class_Class ST_class;
En ce qui concerne la modélisation d'une classe ST_Class_Class, elle dispose d'une liste de méthode et d'une liste de propriétés des objets de celle-ci. Ainsi que d'un nom.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
private String ST_name;
    private HashMap<String, ST_Method_Class> ST_methods = new HashMap<String, ST_Method_Class>();
    private HashMap<String, ST_Object_Class> ST_object_properties = new HashMap<String, ST_Object_Class>();
Je boucle sur moi-même avec la classe ST_MetaClass_Class qui est sa propre méta-classe.

Vient ensuite la partie la plus compliqué...
Et qui selon moi, c'est pas très au point.
Un méthode est modélisé par la classe ST_Method_Class qui dispose d'une liste de commandes et d'une méthode run() pour les lancer.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
private List<ST_Command_Class> ST_bodys= new ArrayList<ST_Command_Class>();
 
    public List<ST_Object_Class> run(ST_Object_Class st_object_class, List<ST_Object_Class> parameters)throws Exception {
        List<ST_Object_Class> args=new ArrayList<ST_Object_Class>();
        args.add(st_object_class);
        args.addAll(parameters);
        return ST_bodys.get(0).run(args);
    }
La classe ST_Command_Class disposant héritières spécifique implémentant List/If/... pour poser les bases du langage.

N'étant pas très convaincu que la méta-classe d'une méthode ou d'une commande était mon ST_MetaClass_Class, j'ai crée deux entités ST_MetaMethod_Class et ST_MetaCommand_Class.

J'espère que mon explication de ma démarche est assez claire.

Je vous laisse le lien vers le projet sourceForge correspondant :
http://pseudosmalltalk.sourceforge.net

J'aimerai votre avis ou remarque sur ma structure ou mon code. Je reste près à répondre à la moindre question sur ce projet.

Cordialement,
Patrick Kolodziejczyk.