Discussion :

[BlackWood]

Bonjour à tous,

J'aurai besoin de quelques conseils afin de choisir la meilleure ossature de base d'un projet. Je vais essayer d'être le plus clair et simple possible :

Pour commencer, j'ai une classe trés généraliste symbolisant un élément de mon appli, quel qu'il soit :

AbstractElement.java

Code :

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

1
2
3
4
5
6
7
8
9
10
public abstract class AbstractElement {
 
	private final int id;
 
	public AbstractElement(int id) {
		this.id = id;
	}
 
	public final int getId() { return id;}
}

De cette classe vont découlées d'autres classes de base :

SimpleElement.java

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class SimpleElement extends AbstractElement {
 
	private String name;
 
	SimpleElement(int id,String name) {
		super(id);
		this.name = name;
	}
 
	public String getName()		{ return name;}
	public void setName(String name)	{ this.name = name;}
}

VisualElement.java :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class VisualElement extends AbstractElement {
 
	private Image image;
 
	public VisualElement(int id,Image image) {
		super(id);
		this.image = image;
	}
 
	public Image getImage()		{ return image;}
	public void setImage(Image image)	{ this.image = image;}
}

1) Je souhaite que, si nécessaire, un éditeur soit définit pour l'élément en question. C'est à dire qu'une méthode getEditor() me renverrai une JDialog ou null selon qu'il existe ou non un éditeur pour cet élément. Quelle méthode choisir ?
- Définition abstraite ou par défaut de la méthode dans AbstractElement ?
- Une interface Editable contenant getEditor() ?
- Autre ?

2) De la même manière, je souhaite pouvoir ajouter, sur n'importe quel élément, une description par exemple. Mais attention, pas une simple String pour ce cas, mais bien une class Description avec plusieurs attributs, méthodes, etc.
Comment ajouter, en quelque sorte, un tel attribut (Description) à un (AbstractElement) ?

3) Je souhaite récupérer l'id d'un élément quel qu'il soit. Je ne connais pas sa classe, je sais juste que c'est un élément. N'est-ce pas gênant de caster l'object en AbstractElement ? Je préférerai utiliser une classe non absraite, mais non utilisable telle qu'elle non plus. Est-ce possible ? Une autre solution ?

Voilà.
Je vous remercie d'avance de l'intérêt que vous porterez à mon problème.

[®om]

1) Je souhaite que, si nécessaire, un éditeur soit définit pour l'élément en question. C'est à dire qu'une méthode getEditor() me renverrai une JDialog ou null selon qu'il existe ou non un éditeur pour cet élément. Quelle méthode choisir ?
- Définition abstraite ou par défaut de la méthode dans AbstractElement ?
- Une interface Editable contenant getEditor() ?
- Autre ?

Ca n'est pas très "model-view-controlleur" ça... Autant d'étiteurs que tu veux peuvent potentiellement éditer un élément...

2) De la même manière, je souhaite pouvoir ajouter, sur n'importe quel élément, une description par exemple. Mais attention, pas une simple String pour ce cas, mais bien une class Description avec plusieurs attributs, méthodes, etc.
Comment ajouter, en quelque sorte, un tel attribut (Description) à un (AbstractElement) ?

Tu mets juste un accesseur dans AbstractElement, public Description getDescription()...

3) Je souhaite récupérer l'id d'un élément quel qu'il soit. Je ne connais pas sa classe, je sais juste que c'est un élément. N'est-ce pas gênant de caster l'object en AbstractElement ? Je préférerai utiliser une classe non absraite, mais non utilisable telle qu'elle non plus. Est-ce possible ? Une autre solution ?

Tu as juste à te faire une interface Element qui définit une méthode getId()... et qui est implémentée par AbstractElement...
C'est d'ailleurs pour cela que les interfaces existent

[spekal]

Il est toujours très difficile de répondre sur des architectures non corrélées avec des domaines applicatifs. Pourrais-tu nous dire à quoi cela va te servir, et dans quel contexte ?

D'abord, connais-tu les beans ? Ils possèdent certaines des fonctions que tu cherches. Qu'en penses-tu ?

Pour 1), en ce genre de cas, j'ai toujours choisi Une interface Editable contenant getEditor(). Mais ne me demande pas pourquoi.

Pour 2), je pense qu'il faudrait savoir si un même objet (l'instance) peut avoir plusieurs descriptions.

Pour 3) je ne comprends pas très bien où est le problème. Si tu as un AbstractElement, tu as forcément la méthode getId... Pourquoi veux-tu caster ?

[BlackWood]

Merci pour vos réponses.

Pour illustrer mon projet (un peu compliqué), c'est une sorte de "jeu" d'aventure qui ressemblera plus à un logiciel...
Disons que chaque élément du jeu, que ce soit un objet, un dialogue, une info, une image, etc. héritera d'AbsractElement.
Le but est trés simple : Je veux pouvoir associer n'importe quel élément à un autre, tout en gardant un hiérarchie. Je ne me suis pas encore penché sur la structure de données que je vais utiliser, mais ca ressemblera à ceci :
Lieu contient :
> Batiment 1
> Batiment 2 qui contient
> Salle qui contient
> Personne
> Dialogue
> Phrase
(en gros)
Tous sont des Element.

1)

Ca n'est pas très "model-view-controlleur" ça... Autant d'étiteurs que tu veux peuvent potentiellement éditer un élément...

Heu... Que veux-tu dire ?

Pour 1), en ce genre de cas, j'ai toujours choisi Une interface Editable contenant getEditor(). Mais ne me demande pas pourquoi.

Oui. Je pense aussi.

2)

Tu mets juste un accesseur dans AbstractElement, public Description getDescription()

Justement non : je voudrais ajouter n'importe quel attribut ! Pas forcément Description !

Pour 2), je pense qu'il faudrait savoir si un même objet (l'instance) peut avoir plusieurs descriptions.

Plusieurs Descriptions, non. Ca c'est sur. Mais d'autres attributs, oui.

Je pense créer un getElements() dans Element pour la hiérarchie et getAttributs() pour les attributs supplémentaire ? Pas terrible...

Je suis malheureusement préssé par le temps. Je ne peux même pas finir de répondre ! Je dois y aller, je reviens lundi.
Merci encore.

[spekal]

Disons que chaque élément du jeu, que ce soit un objet, un dialogue, une info, une image, etc. héritera d'AbsractElement.
Le but est trés simple : Je veux pouvoir associer n'importe quel élément à un autre, tout en gardant un hiérarchie.

Méfie toi que, si le but est louable, il revient en l'état à ré-inventer la roue. Les simples références de variables remplissent parfaitement ton but, hormis la hierarchie ; mais rien dans ton getId() ne permet d'établir une hiérarchie.

Donc je te suggèrerai d'approfondir ce qu'est cette hierarchie dans le cadre de ton domaine d'applicaton ; si, par hasard, elle colle à la notion de classe et de classe fille... tu peux jeter à la poubelle ton AbstractElement.

Plusieurs Descriptions, non. Ca c'est sur. Mais d'autres attributs, oui.

Alors je verrais un set/getDescription dans ton AbstractElement. Si tu veux être très générique, alors... emploie les génériques (mais sur ce coup là je pense que tu aurais meilleur compte à approfondir aussi ta notion de description).

Je suis malheureusement préssé par le temps. Je ne peux même pas finir de répondre ! Je dois y aller, je reviens lundi.
Merci encore.

À lundi.

[BlackWood]

Re-bonjour !

Je continue d'essayer d'être le plus clair possible. Je m'embrouille moi-même énormément dans mes réflexions, c'est vous dire...

Je reprends :
Imaginez un monde virtuel Monde où toute matière, quelle qu'elle soit, hériterait d'Element, ce qui permet d'obtenir son ID unique et de vérifier qu'elle appartienne bien au Monde. Cette matière a des propriétés, définissant sa nature, sa fonctionnalité, etc. Selon sa nature, elle contiendra d'autres matières.
Ex :
Prenons un élément de base, dans le Monde : une Personne.
Une Personne est un Element "avancé" avec des attributs bien spécifiques : nom, prénom, etc... que TOUTE les Personne possèdent directement.
Mais elle contient ou contiendra également des Elements "facultatifs", encore inconnus à la création, que l'on peut un peu comparer à des "plug-in". Exemple : un Dialogue. Un Dialogue est un Element avancé contenant des Question et leur réponse, qui sont des BasicElement, Elements sans "plug-in ajoutables". (J'espère que vous me suivez... ).
On aura donc :

Personne1 (id=P0001) :
> Attributs
> []Plugins : {01 : type "Dialogue" (id=D0001);}

Dialogue1 (id=D0001) :
> Attributs
> []Plugins :
{ 01 : type "Question" (id=Q0001);
02 : type "Question" (id=Q0002);
03 : ... }

Question1 (id=Q0001) :
> Attributs (= String question, String réponse)

Précisions concernant getEditor() :
- Personne est Editable. Par getEditor(), on obtiendra une JDialog permettant de créer une personne et de lui ajouter des Element, comme un Dialogue.
- Dialogue est également Editable, getEditor() permettra de créer ce Dialogue en y ajoutant des Question.
- Question n'est pas éditable : il est géré par Dialogue.

Voilà ce que je cherche à faire.
Je cherche donc à la fois :
- Comment créer un tel système d'éléments ?
- Instaurer une hiérarchie à travers ces éléments (je parle de hiérarchie dans le Monde, non dans les classes).
- Etc. Bref, je pense que vous avez compris ce que je voulais dire...

Merci.

[BlackWood]

J'ai peut-être omis d'ajouter un point important au but de ce système :
Créer une application trés "amovible", dans le sens où, une fois programmé, des Elements pourront enrichir le Monde, en utilisant les plug-in, justement.
L'exemple de Dialogue est parfait :
On a au départ un Monde dans lequel existent des Personnes.
On veut développer un nouvel attribut pour ces personnes : le Dialogue.
On aura donc un plug-in qui contiendra :
Dialogue
DialogueViewer, pour utiliser (visualiser...) le Dialogue
DialogueEditor, pour créer un Dialogue
+ Quelques classes spécifiques (Question)

Autre exemple :
Je souhaite par la suite approfondir l'identité d'une personne en lui ajoutant une taille, un poids, etc.
Un autre plug-in sera donc développé (Identite) et ajouté aux Elements de Personne :
Personne1 (id=P0001)
> Attributs (de base)
> Plug-ins : ( 01 : "Identité", 02 : "Dialogue" )

Note : ces plug-ins sont unique par Personne : une seule identité, un seul dialogue >>> Une seule Description pour un Element de type Lieu, par exemple...
Ils sont ajouté dans l'éditeur de monde, et non dans le code !
Le logiciel détectera les plug-ins disponibles pour un élément...

[spekal]

Je suggère :

Code :

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

1
2
 
System.out.println("Hello World");

[BlackWood]

Ton code marche !
Merci !

Bon, c'est vrai, je suis parti loin hier, mais ça m'a permis de (re-re-re-)faire une synthèse... C'était pour vous expliquer le contexte, mais ça m'a plus servi qu'à vous ! En prenant en compte vos conseils, j'ai déjà bien avancé.
Re-merci.

Il reste cependant une question qui me chiffonne pas mal. Oublions tout mon précédent baratin :
En gros, quel système pourrait me permettre d'ajouter des attributs dynamiquement ?
Ex :
Je souhaite ajouter un attribut de type MonAttributSupp à un objet de type MonObject.
- MonObject.class existe et ne peut-être modifié.
- MonAttributSupp.java vient d'être programmé et compilé.
- Un logiciel permettra de faire le lien entre MonObject et MonAttributSupp.

Comment dois-je développer MonObject ?

[spekal]

N'oublie pas de mettre résolu à propos de Hello World

Concernant les attributs que tu voudrais rajouter à n'importe quel objet, ma position est toujours la même : à quoi cela sert-il, et à quoi cela correspond-t-il dans la réalité ?

Il existe quantité de combines informatiques pour le faire ; (une interface avec des propriétés, des hashmaps (ou, du moins, de faux hashmaps) dont la prétendue clef serait l'objet et la valeur les nouveaux attributs, etc, etc, etc.)

Ce que je te suggère, pour avancer, est de te construire ton petit monde, de façon minimaliste, en te donnant une métaphore de quelque chose que tu connais, et qui n'a rien à voir avec Java. Il faut absolument que tu sortes du langage style J'ai un objet avec un identificateur et des attributs, tu n'y arriveras jamais comme ça, tu tourneras toujours en rond.

Cherche une sorte de monde minima, qui comporterait les notions fondamentales de façon très fruste, et code le. À partir de là il est plus facile de voir ce qui est pertinent et ce qui ne l'est pas. Aide-toi aussi de choses comme UML, avec quoi des tas de gens se sont posés ce genre de question, et qui aide beaucoup à réfléchir.

[BlackWood]

Concernant les attributs que tu voudrais rajouter à n'importe quel objet, ma position est toujours la même : à quoi cela sert-il, et à quoi cela correspond-t-il dans la réalité ?

Comment expliquer ? Disons que dans la réalité, cela correspondrait à une meilleure connaissance de l'objet, des détails supplémentaires. On aurait à la base un objet avec juste un nom, par exemple. Et sans modifier cet objet, on lui ajouterai une description.

Il existe quantité de combines informatiques pour le faire ; (une interface avec des propriétés, des hashmaps (ou, du moins, de faux hashmaps) dont la prétendue clef serait l'objet et la valeur les nouveaux attributs, etc, etc, etc.)

Tu tombes pile poil dans l'embarras dans lequel je suis. J'ai essayé les interfaces : pas mal, mais j'ai besoins de variables... HashMap : c'est actuellement la solution que j'essaye...

Ce que je te suggère, [...] Aide-toi aussi de choses comme UML, avec quoi des tas de gens se sont posés ce genre de question, et qui aide beaucoup à réfléchir.

Tout à fait d'accord. Le truc, c'est que j'ai déjà un cahier avec quelques dizaines de pages brouillonnés sur ce projet. Mais c'est vrai que j'aurai peut-être du utiliser une méthode d'analyse (tel qu'UML) pour y réfléchir "proprement" ! Ce cahier se remplit au fur et à mesure, c'est de plus en plus le bordel, c'est de plus en plus dur de réfléchir...