Discussion :

[faulk]

Bonjour,
je dois faire un programme contenant 3 classes. La première, la classe composite contient une liste générique d'objet. La deuxième , la classe Composant, est une classe ayant comme attribut, un objet instance de la classe composite. Enfin j'ai une classe composant composite qui hérite de ces deux classes. Je sais qu'il n'y a pas de double héritage en java. Et qu'il faire une interface, mais je ne sais pas trop comment . En fichier joint , je vous met le shéma de ce que je pense faire.

J'ai fait le code de Composant et composite que voici :

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
18
19
20
21
22
23
public class ComposantDeElement<T> implements InterfaceComposant{
 
 
	protected T objet;
 
	//Implémentaiton des méthodes de l'interface
	public void Composant(T objet)
	{
		this.objet=objet;
	}
 
	public T getComposant()
	{
		return this.objet;
	}
 
	public void setComposant(T object)
	{
		this.objet=objet;
	}
 
 
}

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class CompositeDeElement<T> {
 
	protected LinkedList<T> ListeDeComposants;
 
	public CompositeDeElement()
	{
		this.ListeDeComposants=new LinkedList<T>();
	}
 
	public void ajouter(T Composant)
	{
		this.ListeDeComposants.add(Composant);
	}
 
	public T supprimer(int i)
	{
		return this.ListeDeComposants.remove(i);
	}
 
	public int chercher(T Composant)
	{	
		int i=0;
		while ((i < this.ListeDeComposants.size()))
		{
			if (this.ListeDeComposants.get(i).equals(Composant))
				return i;
			i++;
		}
		return -1;
	}
 
	public void afficher()
	{
		System.out.println(this.ListeDeComposants.toString());
	}
 
 
}

Voilà, mais je ne sais pas du tout comment coder l'interface et composant composite. Pouvez vous m'aidez please

[panda31]

Salut !

Alors, si j'ai bien compris :

Classe Composite
Classe Composant
Classe ComposantComposite

avec :

Composite associé à Composant
ComposantComposite qui prend les deux...

Alors ton problème est le suivant : pour "hériter" de 2 classes, en fait tu vas devoir en effet faire une interface qui reprend les propriétés de la classe dont tu veux hériter. Ce qui veut dire que tu vas devoir implémenter les méthodes de cette interface dans ComposantComposte... Pff. C'est lourd.

Précise mieux ton problème et ton contexte et on verra ca plus clairement.

[faulk]

En fait mon projet est le suivant. C'est une application de traitement de texte. Un document est une séquence de page, une page un séquence de paragraphe, un paragraphe une séquence de ligne, et une ligne une séquence de mot. Donc par exemple Mot est un composant de ligne, ligne est donc un composite mais aussi un composant (de paragraphe).

[faulk]

Que pensez vous de ca :

code de l'interface :

Code :

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

1
2
3
4
5
6
7
public interface InterfaceComposant<T> {
 
	public void Composant(T Composant);
	public T getComposant();
	public void setComposant(T Composant);
 
}

code de composantcomposite:

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
18
19
20
21
22
23
24
public class ComposantComposite<T1, T2> extends CompositeDeElement<T2> implements InterfaceComposant<T2>{
 
	protected T1 Composite;
	protected T2 Composant;
 
	//Implémentation des méthodes de l'interface
	public void Composant(T2 Composant)
	{
		this.Composant=Composant;
	}
 
	public T2 getComposant()
	{
		return this.Composant;
	}
 
	public void setComposant(T2 Composant)
	{
		this.Composant=Composant;
	}
 
 
 
}

Mais ca me parait pas super

[panda31]

La logique que j'aurais adopté serait plutôt la suivante:

Code :

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

1
2
3
4
5
6
7
8
 
public class ComposantComposite<T1,T2> implements IComposite<T2>,IComposant<T1>
{
   /*
      tu implémentes les fonctions des interfaces
      et tu complètes avec les spécificités de la classe courante
   */
}

C'est plus joli à mon goût.

[g0up1l]

Conceptuellement parlant, je ne vois pas l'intérêt d'une interface de type Composite ni Composant.



Ce qui nous intéresse ici ( et qui sera le service rendue par l'interface ) est la capacité d'un élément à donner l'adresse des éléments suivants, donc à être parcouru.

Voila ce que je te propose :

Code :

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

1
2
3
4
5
6
7
 
public interface Parcourable {
 
	public List getAll(  );
        public void Add( Parcourable  );
 
}

et

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public class Element implements Parcourable()
{
        //
	private List mesElementsSuivants;
 
       public List getAll( ){ //ramène mesElementsSuivants
}
        public void Add( Parcourable  ){ //ajoute un elt dans la list 
}
 
}

si tu es sur un element feuille, getAll() ramène une liste vide et basta !



hope it helps !