Discussion :

[AntoineCompagnie]

Bonsoir!

Je suis toujours en plein apprentissage du langage Java avec le système LIFO comme exemple de départ:

La classe Maillon c'est la réalisation Java d’un maillon. Elle comprend un attribut element qui est l’élément mis dans la pile et un attribut next qui référence le maillon suivant. La classe Maillon n’est visible que par les classes de son espace de noms. Elle est définie dans le même fichier que la classe Stack. La classe Maillon a deux constructeurs : 1. un constructeur qui admet un élément passé en argument, dans ce cas le maillon suivant est établi à null lors de la déclaration des attributs. 2. un constructeur qui admet un élément passé en argument et le maillon suivant. La classe Maillon a trois méthodes ayant une visibilité par défaut : Object getElement() retourne l'élément associé au maillon courant Object next() retourne le maillon suivant boolean hasNext() retourne true s’il existe un maillon suivant, false sinon Les méthodes de réalisation sont: •void setNext(Maillon next) affecte l’attribut next avec le maillon passée en argument •void setElement(Object o) affecte l’attribut element avec l’objet o passé en argument La classe Stack La classe Stack est publique, elle a un attribut top qui référence le premier maillon. Elle a deux constructeurs: 1.un constructeur vide dans ce cas l’élément sommet est égal à null et la pile est vide et de taille zéro. 2. un constructeur qui admet un élément passé en argument de type Object, dans ce cas, il y a création d’un maillon (instance de la classe Maillon) avec l’élément suivant à null. La classe Stack admet les quatre méthodes publiques suivantes : void push(Object object) place au sommet de la pile l’objet passé en argument Object pop() retourne l’élément qui se trouve au sommet de la pile et place l’élément suivant au sommet de la pile. Object first() accède au premier élément de la pile sans modifier la pile boolean isEmpty() retourne true si la pile est vide Méthodes de réalisation de la classe Stack: •void setTop(Object o) établit le sommet de la pile avec le maillon passé en argument • Maillon getTop() retourne le sommet de la pile • Maillon next() retourne le maillon suivant

je souhaite désormais que ma classe Stack réalise une interface, l'interface StackAbility qui comprend les quatre opérations suivantes:

• voidPush(Object object),
• Object pop(),
• Object first
• et boolean is empty

Je souhaite aussi que ma classe Maillon réalise l'interface non publique MaillonAbility qui comprends les trois opérations suivantes:

• Object getElement()
• Maillon next()
• boolean hasNext()

et modifier le code en conséquence.

J'ai au départ pensé qu'il fallait mettre toutes ses méthodes dans les classes et rajouter implements plus l'interface. Erreur. Seulement certaines des méthodes de l'interface sont ajoutées. Mais pourquoi?
Les codes qui suivent ne sont pas de moi mais de mon professeur.
Par contre j'ai du mal à comprendre comment je dois modifier mon code en conséquence.
Pourquoi est on obligé de reformuler tous les arguments avec le nom de l'interface en plus?

I. Dans la classe Maillon par quoi se traduit l'utilisation d'une interface non publique MaillonAbility?
Seulement deux méthodes sont à changer? pas setElement? Aucune conséquence sur toString?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class Maillon implements maillonAbility{
 
    private MaillonAbility next = null;
 
    Maillon (Object o; MaillonAbility next){
        this(o); //tout seul?
        this.next=next;
    }
 
    private void SetNext(MaillonAbility m){
        next = n;
    }
}

pourtant toString contient element qui est susceptible d'avoir le nom de l'interface ajouté avant?

Code :

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

1
2
3
4
5
6
7
8
9
 
public String toString() {
    if( next==null ) {
       return String.valueOf( element );
    }
    else {
       return element + " -> " + next; // implicement ça va faire String.valueOf(element) + " -> " + String.valueOf(next);
    }
}

II. dans la classe Stack, lorsqu'on implémente l'interface, seulement une seule des méthode est ajoutée...

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
 
public class Stack implements Maillon {
    private MaillonAbility top;
    public Stack(){}
 
    public Stack(Object element){
        setTop(new MaillionAbility(element));
    }
 
   private void setTop(Object o){
       this.top = (maillonAbility); //tout seul?
   }
 
   private MaillonAbility getTop(){
        return top;
   }
 
  private void push(Object o){
        MaillonAbility m =new Maillon (o,getTop()){
            setTop(m);
        }
 
  private MaillonAbility next(){
      return setTop.next()
  }
   }
}

[tchize_]

J'ai au départ pensé qu'il fallait mettre toutes ses méthodes dans les classes et rajouter implements plus l'interface. Erreur. Seulement certaines des méthodes de l'interface sont ajoutées. Mais pourquoi?

Quand tu rajoute une interface implements sur une classe existante, la classe doit implémenter en public toutes les méthodes de ton interface. Si des méthodes existent déjà, tant mieux, pas besoin de les écrire. Pour reprendre ton exemple, les 4 méthodes dans la classe Maillon doivent devenir publiques, la méthode manquante hasNext dans stack() doit être créée.

Pourquoi est on obligé de reformuler tous les arguments avec le nom de l'interface en plus?

Là on est plus dans le refactoring que dans l'interface même. L'idée ici, c'est qu'on part d'une Stack stockant des instances de Maillon. Puis plus tard on se dit, je voudrait bien plusieurs type de maillons possibles pour ma Stack. Alors on crée un interface qui correspond à un Maillon quelconque (MaillonAbility), pour récupérer le code, ben on dit que Maillon, c'est bien un maillon (via Maillon implements MaillonAbility), et on revois la Stack pour qu'elle n'utilise plus que des MaillonAbility, qui sont plus généraux que des Maillon, ce qui implique de revoir toutes les signatures de méthode.

I. Dans la classe Maillon par quoi se traduit l'utilisation d'une interface non publique MaillonAbility?

Dans la classe qui implémente la nouvelle interface, tu a juste à ajouter les méthodes manquantes et t'assurer ce les méthodes implémentées de l'interface font bien ce qu'elles sont supposé faire d'après la description de l'interface. toString n'a rien à voir dans l'histoire.

Ensuite, ceci est faux:

Code :

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

setTop(new MaillionAbility(element));

on ne peut pas faire un new sur une interface. Uniquement sur une classe non abstraite.

Code :

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

1
2
 
       this.top = (maillonAbility); //tout seul?

ce code ne veux rien dire et ne compilera pas.

[AntoineCompagnie]

D'accord, merci beaucoup!
donc :

1. pas d'instanciation d'interface,
2. Quand on utilise une classe dans une autre et que cette dernière implémente une interface on change le nom de toutes les "choses" qui utilisent cette interface

je cherche à comprendre maintenant pourquoi le constructeur de Stack n'a pas à considérer son élément comme un StackAbility
alors que le constructeur de Maillon le doit pour next?

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
 
interface StackAbility {
	void push(Object object);
	Object pop();
	Object first();
	boolean isEmpty();
	}
 
public class Stack implements StackAbility, SizeAbility{        				// mofif.
	private MaillonAbility top;        // mofif.
	public Stack() {
	}
 
	public Stack(Object element){
		setTop(new Maillon(element));        				// pas de mofif. !
		}

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
 
interface MaillonAbility{
	Object getElement();
	MaillonAbility next();
	boolean hasNext();
	}
 
class Maillon implements MaillonAbility, SizeAbility{       				 // mofif.
	private Object element;
	private MaillonAbility next=null;        // mofif.
	Maillon(Object element){
             setElement(element);
             }
 
	Maillon(Object element, MaillonAbility next){        // mofif.
		this(element);
		setNext(next);
		}

[joel.drigo]

je cherche à comprendre maintenant pourquoi le constructeur de Stack n'a pas à considérer son élément comme un StackAbility
alors que le constructeur de Maillon le doit pour next?

Stackability défini la capacité d'une classe à être un Stack. MaillonAbility définit la capacité d'une classe à être un maillon.

Le paramètre du constructeur de Stack n'a rien à voir avec une Stack : c'est juste l'élément contenu dans le premier maillon. Et comme on veut pouvoir faire des Stack de n'importe quoi, on utilise Object. Si on déclarait le paramètre élément en Stackability ça voudrait dire qu'on ne pourrait faire que des Stack contenant des Stackability.

Le paramètre next du constructeur de Maillon, lui est bien un maillon, généralisé par l'interface MaillonAbility. Le fait de le typer en MaillonAbility veut dire qu'on peut passer une instance de n'importe quelle classe implémentant MaillonAbility, comme Maillon par exemple, mais aussi d'autres classes si elles implémentent MaillonAbility.

[tchize_]

Quand on utilise une classe dans une autre et que cette dernière implémente une interface on change le nom de toutes les "choses" qui utilisent cette interface

Pas nécessairement, ça depends de ce qu'on veux réaliser. La mise en place d'un interface sert un but, les buts pouvant être divers, donc on ne refactorise pas nécessairement le code appelant et même si on le fait, pas nécessairement tout.