LinkedList et iterator

Bonjour tout le monde,

Je suis entrain de faire un exercice en Java qui consiste à créer un stock de produits en utilisant une approche basée sur les Tableaux, les linkedList et les iterator. Nous avons trois packages : Produit (contient 02 classes : Produit et ProduitPerissable), Stock (contient les classes : Stock, StockEmpty, StockFull, StockTableau, StockListe et les classes de test) et Date (contient les classes : Date et DateInvalide).
Bref, mon souci est de :

- Voir déjà si mon code est bien;

- Réaliser une méthode ToString() dans la classe Stock et l'utiliser à partir de StockTableau et StocListe;

- Utiliser la méthode iterator() depuis StockTableau et StockListe.

Merci.

Ci-dessous mes classes :

La classe Stock :

Code:

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package stock;
 
import produit.Produit;
import java.util.*;
 
/**
 * Classe abstraite gerant un stock de Produit
 * qui ne connait que le nombre de Produit size
 *
 * un stock sait :
 *  - ajouter/enlever un produit (doivent etre defini)
 *  - indiquer s'il est vide ou plein (doit etre defini)
 *  - donner le nombre de produits qu'il contient
 *  - s'afficher (doit etre defini)
 */
public abstract class Stock {
 
  protected int size = 0;
 
  /**
   * indique si je suis vide
   */
  public boolean isEmpty() { return size == 0; }
 
  /**
   * retourne le nombre d'elements presents dans le Stock
   */
  public int getSize() { return size ; }
 
  /**
   *  Rend une chaine qui decrit chaque element present dans le Stock
   */
 
  /**
   * ajoute un produit et leve l'exception StockFull si le stock est plein
   * @param p le produit ajoute
   */
  public abstract void add(Produit p) throws ProduitNull, StockFull;
 
  /**
   * retire un produit, et leve l'exception StockEmpty si le stock est vide
   */
  public abstract Produit remove() throws StockEmpty;
 
  /**
   * retire un produit, et leve l'exception StockEmpty si le stock est vide
   * @param p le produit a retirer
   */
  public abstract void remove(Produit p) throws ProduitNull, StockEmpty;
 
  /**
   * indique si je suis plein
   */
  public abstract boolean isFull();
 
  /**
   * la methode abstraite qui retourne le ieme element
   */
  public abstract int iemeElement(int i);
  /**
   * la methode abstraite iterator
   */
  public abstract Iterator <Produit> iterator() ;
 
}

La classe StockListe :

Code:

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package stock;
 
import java.util.*;
import produit.Produit;
 
/**
 * Realisation de la classe abstraite Stock sous forme de liste.
 * Ma taille maximale est fixee a ma creation.
 *
 * un stock sait :
 *  - etre cree avec une taille donnee
 *  - ajouter/enlever un produit
 *  - indiquer s'il est plein
 *  - renvoyer une chaine de caracteres decrivant son contenu
 *
 */
public class StockListe extends Stock {
 
  protected LinkedList<Produit> content;
  //protected content = new LinkedList<Produit>();
  int nbMax;
  public Produit pr;
 
  public StockListe() {
    pr = null;
  }
 
  /**
   * Construit un stock dont la capacite est donne par s
   * @param t la taille du stock
   */
 
  public StockListe(int t) {
    if (t < 0)
      t = 0;
    content = new LinkedList<Produit>();
    size = t;
  }
 
  /**
   * ajoute un produit, et incremente le nombre d'elements
   * @param p le produit ajoute
   */
  public void add(Produit p) throws ProduitNull, StockFull {
    if(p == null)
      throw new ProduitNull();
    if(isFull())
      throw new StockFull();
    content.addLast(p);
    size++;
  }
 
  /**
   * retire un produit, et decremente le nombre d'elements
   * on voit ici que le choix du produit retire pourrait
   * etre different...
   */
 
  public Produit remove()throws StockEmpty{
    if(isEmpty()){
      throw new StockEmpty();
      }
    else {
      Produit p = content.removeLast();
       size-- ;
      return p;
    }
  }
 
  /**
   * retire un produit, et decremente le nombre d'elements
   * @param p le Produit a retirer
   */
  public void remove(Produit p) throws ProduitNull, StockEmpty {
    if(p==null)
      throw new ProduitNull();
    if(isEmpty())
      throw new StockEmpty();
    content.remove(p);
    size--;
 
  }
  /**
   * indique si je suis plein
   */
  public boolean isFull() {
    if(size == content.size())return true;
    else return false;
  }
  /**
   * retourne le ieme element
   */
  public int iemeElement(int i){
 
   for(int j=0; j<size; j++) {
      if (content.get(i)==content.get(j)){
         i = j;
      }
   }
   return i;
  }
  /**
   * renvoie une chaine de caracteres representant le contenu du stock
   */
  public String toString() {
    String result = "<";
 
    Iterator itr = content.iterator();
 
    while (itr.hasNext()){
    result += "" +itr.next();
    return result + ">";
    }
    /*
    if (!isEmpty()) {
      result += content.getFirst();
      for(int i = 1; i < size; i++)
        result += ";" + content.get(i);
    }*/
    return result + ">";
  }
 
  public Iterator <Produit> iterator()
  {
    Iterator itr = content.iterator();
    return itr;
  }
 
}

La classe StockTableau :

Code:

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package stock;
 
import java.util.*;
import produit.Produit;
 
/**
 * Realisation de la classe abstraite Stock sous forme de tableau.
 * Ma taille maximale est fixee a ma creation.
 *
 * un stock sait :
 *  - etre cree avec une taille donnee
 *  - ajouter/enlever un produit
 *  - indiquer s'il est plein
 *  - renvoyer une chaine de caracteres decrivant son contenu
 *
 */
public class StockTableau extends Stock {
 
  protected Produit[] content;
 
  /**
   * Construit un stock dont la capacite est donne par s
   * @param s la taille du stock
   */
  public StockTableau(int s) {
    if (s < 0)
      s = 0;
    content = new Produit[s];
  }
 
  /**
   * ajoute un produit, et incremente le nombre d'elements
   * @param p le produit ajoute
   */
  public void add(Produit p) throws ProduitNull, StockFull {
    if(p == null)
      throw new ProduitNull();
    if(isFull())
      throw new StockFull();
    content[size++] = p;
  }
 
  /**
   * retire un produit, et decremente le nombre d'elements
   * on voit ici que le choix du produit retire pourrait
   * etre different...
   */
  public Produit remove()throws StockEmpty{
    if(isEmpty())
      throw new StockEmpty();
    Produit p = content[--size];
    content[size] = null;
    return p;
  }
 
  /**
   * retire un produit, et decremente le nombre d'elements
   * @param p le Produit a retirer
   */
  public void remove(Produit p) throws ProduitNull, StockEmpty {
    if(p==null)
      throw new ProduitNull();
    if(isEmpty())
      throw new StockEmpty();
    int i = 0;
    while(i < size && !p.equals(content[i]))
      i++;
    if(i < size){// le produit existait bien
      for(int j = i; j < size-1; j++)// decalage des elements
        content[j] = content[j+1];
      size--;
      content[size] = null;
    }
  }
 
  /**
   * indique si je suis plein
   */
  public boolean isFull() {
    return size == content.length;
  }
  /**
   * retourne le ieme element
   */
  public int iemeElement(int i){
 
   for(int j=0; j<size; j++) {
      if (content[i]==content[j]){
         i = j;
      }
   }
   return i;
  }
 
  /**
   * renvoie une chaine de caracteres representant le contenu du stock
   */
  public String toString() {
    Iterator itr = content.iterator();
    String result = "[";
    if (!isEmpty()) {
      result += content[0];
      for(int i = 1; i < size; i++)
        result += ";" + content[i];
    }
    return result + "]";
  }
 
}

La classe Produit :

Code:

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package produit;
 
import date.*;
 
/**
 * je suis un Produit. j'obtiens un numero et un name a ma creation
 * Ma classe (Produit) garde le nombre numberCreated de produits crees.
 *
 * un produit sait :
 *  - etre cree
 *  - donner son numero
 *  - donner son name
 *  - s'imprimer
 * la classe produit sait :
 *  - donner le namebre numberCreated de produits creer
 * le main permet de tester la classe
 *
 * J'utilise les classes systeme : String, (System pour le test)
 *
 */
 
public class Produit {
 
    /**
     * Chaque Produit a un nom
     */
    private String name;
 
    /**
     * variable de classe qui memorise le nombre de produits crees
     */
    static private int numberCreated = 0; 
 
    /**
     * Chaque Produit a un numero
     */
    private int number;
 
 
    /**
     * @param  unNom le name du nouveau Produit
     * me cree, et m'attribue un numero
     * incremente le namebre de produits crees.
     */
    public Produit(String name) {
    this.name = name;
    number = ++numberCreated;
    }
 
    /**
     * rend mon numero, fixe a sa creation,
     */
    public int getNumber() {
    return number;
    }
 
    /**
     * rend le nom du Produit
     */
    public String getName() {
    return name;
    }
 
    /**
     * rend le nombre de produits crees
     */     
    public static int getNumberCreated() {
    return numberCreated;
    }
 
 
    /**
     * compare ce Produit avec l'objet specifie
     *@param o l'Objet a comparer avec le Produit courant
     */        
    public boolean equals(Object o){
    Produit p = (Produit)o;
    return name.equals(p.name) && number == p.number;
    }
 
    /**
     *  methode standard qui transforme un objet en Chaine de caractere.
     */
    public String toString() {
    return "(Produit=" + name + ", number=" + number + ")";
    }
 
    public static void main(String args []) {
    // for testing run : java niveau1_1.Produit
    Produit p1, p2, p3;
    p1 = new Produit("beurre");
    System.out.println(p1);
    // -> Produit number : 1
    System.out.println("NombreproduitCrees ==  " +
               Produit.getNumberCreated());
    // -> NombreproduitCrees == 1
    p2 = new Produit("lait");
    p3 = new Produit("fromage");
    if(p2.equals(p3))
        System.out.println(p2 + " est identique a " + p3);
    else
        System.out.println(p2 + " est different de " + p3);
    System.out.println(p1);
    // -> Produit number : 1
    System.out.println(p3);
    // -> Produit number : 3
    System.out.println("number de p3  :" + p3.getNumber());
    // -> number de p3  :3
    System.out.println("NombreproduitCrees ==  " + Produit.getNumberCreated());
    // -> NombreproduitCrees ==  3
    }
}

La classe ProduitPerissable :

Code:

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package produit;
 
import date.*;
 
/**
 * je suis un ProduitPerissable. j'obtiens un numero et un name a ma creation
 * ainsi qu'une date de peremption
 * Ma classe (Produit) garde le nombre numberCreated de produits crees.
 *
 * un produitPerissable sait :
 *  - etre cree
 *  - donner son numero
 *  - donner son name
 *  - donner son date de peremption
 *  - donner la chaine de caracteres correspondant a un ProduitPerissable
 *  - donner le nombre numberCreated de produits creer
 * le main permet de tester la classe
 *
 * J'utilise les classes systeme : String, (System pour le test)
 *
 */
 
public class ProduitPerissable extends Produit {
 
    /**
     * Chaque ProduitPerissable a un date de peremption
     */
    private Date bestBeforeDate;
 
 
    /**
     * @param  name le nom du nouveau Produit
     * @param  bestBeforeDate la date de consommation
     * me cree, et m'attribue un numero, un nom et une date de Peremption
     */
    public ProduitPerissable(String name, Date bestBeforeDate) {
    super(name);
    this.bestBeforeDate = bestBeforeDate;
    }
 
    /**
     * @param  date la date que l'on veut comparer avec la date de peremption
     */
    public boolean isOutOfDate(){
    Date now = new Date();
    return  bestBeforeDate.before(now);
    } 
 
    /**
     *  retourne la date de peremption.
     */
    public Date getBestBeforeDate(){
    return  bestBeforeDate;
    } 
 
    /**
     *  methode standard qui transforme un objet en Chaine de caractere.
     */
    public String toString() {
    return super.toString() + " sera perime le " + bestBeforeDate;
    }
 
    public static void main(String[] args) {
    try{
        Date d1 = new Date(2018, 7, 25);
        Date d2 = new Date(2018, 7, 29);
        Date d3 = new Date(2018, 8, 15);
        ProduitPerissable p1 = new ProduitPerissable("beurre", d1);
        System.out.println(p1);
            // -> Produit number : 1
        System.out.println("NombreproduitCrees ==  " +
                   Produit.getNumberCreated());
        // -> NombreproduitCrees == 1
        ProduitPerissable p2 = new ProduitPerissable("lait", d2);
        ProduitPerissable p3 = new ProduitPerissable("fromage", d2);
        if(p1.isOutOfDate())
        System.out.println(p1 + " est perime aujourd'hui le " + new Date());
        else
        System.out.println(p1 + " n'est pas perime le "+ new Date());
        System.out.println(p1);
            // -> Produit number : 1
        System.out.println(p3);
            // -> Produit number : 3
        System.out.println("numero de p3  :" + p3.getNumber());
            // -> number de p3  :3
        System.out.println("Nombre de produits crees =  " + Produit.getNumberCreated());
            // -> NombreproduitCrees ==  3
        System.out.println("Le produit  " + p3.getName() + " sera perime le " +
                   p3.getBestBeforeDate());
    } catch(DateInvalide er){
        System.out.println("votre date est erronnee");
    }
    }
}

Certes, je n'ai pas l'énoncé de l'exercice exact, mais vu de loin, le code me semble mal architecturé.

Déjà, posons qu'il existe le principe de responsabilité ( https://fr.wikipedia.org/wiki/Princi...t%C3%A9_unique )

En particulier, nous avons des classes qui décrivent des choses (ou des concepts) et des classes qui font des choses (ou un traitement).

La classe décrit un concept , mais elle fait des choses (comme supprimer un produit).

En général, on différentie les entités (les classes qui décrivent les concepts) et les DAO (classes qui manipule les concepts).

https://fr.wikipedia.org/wiki/Objet_...x_donn%C3%A9es

Cordialement.

Citation:

Envoyé par PhilippeGibault

Certes, je n'ai pas l'énoncé de l'exercice exact, mais vu de loin, le code me semble mal architecturé.

Déjà, posons qu'il existe le principe de responsabilité ( https://fr.wikipedia.org/wiki/Princi...t%C3%A9_unique )

En particulier, nous avons des classes qui décrivent des choses (ou des concepts) et des classes qui font des choses (ou un traitement).

La classe décrit un concept , mais elle fait des choses (comme supprimer un produit).

En général, on différentie les entités (les classes qui décrivent les concepts) et les DAO (classes qui manipule les concepts).

https://fr.wikipedia.org/wiki/Objet_...x_donn%C3%A9es

Cordialement.

Bonjour PhilippeGibault et merci pour votre réponse.

Voila je résume mon problème :

Je souhaite créer une méthode ToString() à concrétiser dans la classe Stock qui utilisera un objet de type Iterator<Produit> renvoyé par la méthode abstraite iterator de la même classe, pour la factoriser ensuite dans les classes StockTableau et StockListe, comment doit être cette méthode (code) ?

"Pour cela on créera une méthode abstraite iemeElement(int i):Produit dans la classe Stock. La valeur retournée par iemeElement devra être le ième produit du Stock. cette méthode devra être concrétisée dans StockTableau et StockListe".

Merci encore une autre fois.