Bloquer les éléments d'une liste pendant un laps de temps...
4 réponses
Foub31400
Bonjour,
je souhaite pouvoir bloquer les =E9l=E9ments pr=E9sents dans une
java.util.List jusqu'=E0 que l'utilisateur clique sur un bouton par
exemple.
Par exemple, j'aimerais pouvoir =E9crire l'action suivante pour mon
bouton : =AB
JButton btnDebloquer =3D new JButton("D=E9bloquer situation !");
btnDebloquer.addActionListener(new ActionListener(){@Override
public void actionPerformed(ActionEvent arg0) {
maListe.setBloquer(false);
}
}); =BB.
Si avant que je clique sur le bouton, on essaye d'ajouter des =E9l=E9ments
=E0 ma liste, il faudrait que ces actions soient mis dans une file
d'attente jusqu'=E0 que mon clique autorise l'acc=E8s =E0 ma liste.
Savez-vous comment pourrais-je faire cela en java ?
J'ai essay=E9 de me cr=E9er la classe "ArrayListPerso" : =AB
package listPerso;
import java.util.ArrayList;
public class ArrayListPerso<T> extends ArrayList<T> {
/** Version de s=E9rialisation */
private static final long serialVersionUID =3D 1L;
/**
* Constructeur par d=E9faut.
*/
public ArrayListPerso() {
super();
}
/**
* Retourne un boolean pour indiquer si on bloque l'ajout d'=E9l=E9ment
* dans la liste.
*
* @return true la liste des =E9l=E9ments est bloqu=E9, false on peut
modifier la liste.
*/
public boolean isBloquer() {
return bloquer;
}
/**
* D=E9finit l'=E9tat de la liste : bloque-t-on tout ajout d'=E9l=E9ment ou=
pas ?
* @param bloquer true on bloque tout ajout d'=E9l=E9ment, false on
autorise tout modification.
*/
public void setBloquer(boolean bloquer) {
if ((bloquer =3D=3D false) && (this.bloquer =3D=3D true)) {
this.bloquer =3D bloquer;
this.notifyAll();
} else {
this.bloquer =3D bloquer;
}
}
@Override
public boolean add(T arg0) {
if (bloquer) {
System.out.println("L'ajout de l'=E9l=E9ment " + arg0 + " est
suspendu !");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Voici les informations affich=E9es dans la console : =AB
Exception in thread "main" java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:485)
at listPerso.ArrayListPerso.add(ArrayListPerso.java:50)
at TestFabienListePerso.main(TestFabienListePerso.java:45)
Ajout de l'=E9l=E9ment allo effectu=E9 !
L'ajout de l'=E9l=E9ment coucou est suspendu !
=BB alors que je souhaiterais avoir : =AB
Ajout de l'=E9l=E9ment allo effectu=E9 !
L'ajout de l'=E9l=E9ment coucou est suspendu !
=BB puis, quand je clique sur le bouton : =AB Ajout de l'=E9l=E9ment coucou
effectu=E9 ! =BB.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Raphael Tagliani
Bonjour,
Et si vous procédiez ainsi : Créer une classe dans laquelle vous mettez un champ liste (LinkedList p.ex), que vous utiliseriez comme pile. Lors de l'ajout d'un élément, vous le mettez simplement dans la pile. Cette classe devrait être un actionListener pour le bouton, et lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements ActionListener {
private List stack;
ArrayListPerso() { this.stack = new Stack(); }
@Override public void actionPerformed(ActionEvent event) { for(Object o : this.stack) { this.add(o); } }
@Override public void add(Object o) { this.stack.add(o); }
}
Si vous voulez que l'action soit automatique plutôt que contrôlée par un bouton, utilisez simplement un timer pour générer l'action.
Bonne journée!
Foub31400 wrote:
Bonjour,
je souhaite pouvoir bloquer les éléments présents dans une java.util.List jusqu'à que l'utilisateur clique sur un bouton par exemple.
Par exemple, j'aimerais pouvoir écrire l'action suivante pour mon bouton : «
JButton btnDebloquer = new JButton("Débloquer situation !"); btnDebloquer.addActionListener(new ActionListener(){@Override public void actionPerformed(ActionEvent arg0) { maListe.setBloquer(false); } }); ».
Si avant que je clique sur le bouton, on essaye d'ajouter des éléments à ma liste, il faudrait que ces actions soient mis dans une file d'attente jusqu'à que mon clique autorise l'accès à ma liste.
Savez-vous comment pourrais-je faire cela en java ?
J'ai essayé de me créer la classe "ArrayListPerso" : «
package listPerso;
import java.util.ArrayList;
public class ArrayListPerso<T> extends ArrayList<T> { /** Version de sérialisation */ private static final long serialVersionUID = 1L;
/** * Constructeur par défaut. */ public ArrayListPerso() { super(); }
/** * Retourne un boolean pour indiquer si on bloque l'ajout d'élément * dans la liste. * * @return true la liste des éléments est bloqué, false on peut modifier la liste. */ public boolean isBloquer() { return bloquer; }
/** * Définit l'état de la liste : bloque-t-on tout ajout d'élément ou pas ? * @param bloquer true on bloque tout ajout d'élément, false on autorise tout modification. */ public void setBloquer(boolean bloquer) { if ((bloquer == false) && (this.bloquer == true)) { this.bloquer = bloquer; this.notifyAll(); } else { this.bloquer = bloquer; } }
@Override public boolean add(T arg0) {
if (bloquer) { System.out.println("L'ajout de l'élément " + arg0 + " est suspendu !"); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } }
Voici les informations affichées dans la console : «
Exception in thread "main" java.lang.IllegalMonitorStateException at java.lang.Object.wait(Native Method) at java.lang.Object.wait(Object.java:485) at listPerso.ArrayListPerso.add(ArrayListPerso.java:50) at TestFabienListePerso.main(TestFabienListePerso.java:45) Ajout de l'élément allo effectué ! L'ajout de l'élément coucou est suspendu !
» alors que je souhaiterais avoir : « Ajout de l'élément allo effectué ! L'ajout de l'élément coucou est suspendu ! » puis, quand je clique sur le bouton : « Ajout de l'élément coucou effectué ! ».
Merci d'avance pour votre aide. F.
Foub31400 wrote:
Bonjour,
je souhaite pouvoir bloquer les éléments présents dans une java.util.List jusqu'à que l'utilisateur clique sur un bouton par exemple.
Par exemple, j'aimerais pouvoir écrire l'action suivante pour mon bouton : «
JButton btnDebloquer = new JButton("Débloquer situation !"); btnDebloquer.addActionListener(new ActionListener(){@Override public void actionPerformed(ActionEvent arg0) { maListe.setBloquer(false); } }); ».
Si avant que je clique sur le bouton, on essaye d'ajouter des éléments à ma liste, il faudrait que ces actions soient mis dans une file d'attente jusqu'à que mon clique autorise l'accès à ma liste.
Savez-vous comment pourrais-je faire cela en java ?
J'ai essayé de me créer la classe "ArrayListPerso" : «
package listPerso;
import java.util.ArrayList;
public class ArrayListPerso<T> extends ArrayList<T> { /** Version de sérialisation */ private static final long serialVersionUID = 1L;
/** * Constructeur par défaut. */ public ArrayListPerso() { super(); }
/** * Retourne un boolean pour indiquer si on bloque l'ajout d'élément * dans la liste. * * @return true la liste des éléments est bloqué, false on peut modifier la liste. */ public boolean isBloquer() { return bloquer; }
/** * Définit l'état de la liste : bloque-t-on tout ajout d'élément ou pas ? * @param bloquer true on bloque tout ajout d'élément, false on autorise tout modification. */ public void setBloquer(boolean bloquer) { if ((bloquer == false) && (this.bloquer == true)) { this.bloquer = bloquer; this.notifyAll(); } else { this.bloquer = bloquer; } }
@Override public boolean add(T arg0) {
if (bloquer) { System.out.println("L'ajout de l'élément " + arg0 + " est suspendu !"); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } }
Voici les informations affichées dans la console : «
Exception in thread "main" java.lang.IllegalMonitorStateException at java.lang.Object.wait(Native Method) at java.lang.Object.wait(Object.java:485) at listPerso.ArrayListPerso.add(ArrayListPerso.java:50) at TestFabienListePerso.main(TestFabienListePerso.java:45) Ajout de l'élément allo effectué ! L'ajout de l'élément coucou est suspendu !
» alors que je souhaiterais avoir : « Ajout de l'élément allo effectué ! L'ajout de l'élément coucou est suspendu ! » puis, quand je clique sur le bouton : « Ajout de l'élément coucou effectué ! ».
Merci d'avance pour votre aide. F.
Bonjour,
Et si vous procédiez ainsi :
Créer une classe dans laquelle vous mettez un champ liste (LinkedList
p.ex), que vous utiliseriez comme pile.
Lors de l'ajout d'un élément, vous le mettez simplement dans la pile.
Cette classe devrait être un actionListener pour le bouton, et
lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les
éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements
ActionListener {
private List stack;
ArrayListPerso() {
this.stack = new Stack();
}
@Override
public void actionPerformed(ActionEvent event) {
for(Object o : this.stack) {
this.add(o);
}
}
@Override
public void add(Object o) {
this.stack.add(o);
}
}
Si vous voulez que l'action soit automatique plutôt que contrôlée par un
bouton, utilisez simplement un timer pour générer l'action.
Bonne journée!
Foub31400 wrote:
Bonjour,
je souhaite pouvoir bloquer les éléments présents dans une
java.util.List jusqu'à que l'utilisateur clique sur un bouton par
exemple.
Par exemple, j'aimerais pouvoir écrire l'action suivante pour mon
bouton : «
JButton btnDebloquer = new JButton("Débloquer situation !");
btnDebloquer.addActionListener(new ActionListener(){@Override
public void actionPerformed(ActionEvent arg0) {
maListe.setBloquer(false);
}
}); ».
Si avant que je clique sur le bouton, on essaye d'ajouter des éléments
à ma liste, il faudrait que ces actions soient mis dans une file
d'attente jusqu'à que mon clique autorise l'accès à ma liste.
Savez-vous comment pourrais-je faire cela en java ?
J'ai essayé de me créer la classe "ArrayListPerso" : «
package listPerso;
import java.util.ArrayList;
public class ArrayListPerso<T> extends ArrayList<T> {
/** Version de sérialisation */
private static final long serialVersionUID = 1L;
/**
* Constructeur par défaut.
*/
public ArrayListPerso() {
super();
}
/**
* Retourne un boolean pour indiquer si on bloque l'ajout d'élément
* dans la liste.
*
* @return true la liste des éléments est bloqué, false on peut
modifier la liste.
*/
public boolean isBloquer() {
return bloquer;
}
/**
* Définit l'état de la liste : bloque-t-on tout ajout d'élément ou
pas ?
* @param bloquer true on bloque tout ajout d'élément, false on
autorise tout modification.
*/
public void setBloquer(boolean bloquer) {
if ((bloquer == false) && (this.bloquer == true)) {
this.bloquer = bloquer;
this.notifyAll();
} else {
this.bloquer = bloquer;
}
}
@Override
public boolean add(T arg0) {
if (bloquer) {
System.out.println("L'ajout de l'élément " + arg0 + " est
suspendu !");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Voici les informations affichées dans la console : «
Exception in thread "main" java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:485)
at listPerso.ArrayListPerso.add(ArrayListPerso.java:50)
at TestFabienListePerso.main(TestFabienListePerso.java:45)
Ajout de l'élément allo effectué !
L'ajout de l'élément coucou est suspendu !
» alors que je souhaiterais avoir : «
Ajout de l'élément allo effectué !
L'ajout de l'élément coucou est suspendu !
» puis, quand je clique sur le bouton : « Ajout de l'élément coucou
effectué ! ».
Merci d'avance pour votre aide.
F.
Foub31400 wrote:
Bonjour,
je souhaite pouvoir bloquer les éléments présents dans une
java.util.List jusqu'à que l'utilisateur clique sur un bouton par
exemple.
Par exemple, j'aimerais pouvoir écrire l'action suivante pour mon
bouton : «
JButton btnDebloquer = new JButton("Débloquer situation !");
btnDebloquer.addActionListener(new ActionListener(){@Override
public void actionPerformed(ActionEvent arg0) {
maListe.setBloquer(false);
}
}); ».
Si avant que je clique sur le bouton, on essaye d'ajouter des éléments
à ma liste, il faudrait que ces actions soient mis dans une file
d'attente jusqu'à que mon clique autorise l'accès à ma liste.
Savez-vous comment pourrais-je faire cela en java ?
J'ai essayé de me créer la classe "ArrayListPerso" : «
package listPerso;
import java.util.ArrayList;
public class ArrayListPerso<T> extends ArrayList<T> {
/** Version de sérialisation */
private static final long serialVersionUID = 1L;
/**
* Constructeur par défaut.
*/
public ArrayListPerso() {
super();
}
/**
* Retourne un boolean pour indiquer si on bloque l'ajout d'élément
* dans la liste.
*
* @return true la liste des éléments est bloqué, false on peut
modifier la liste.
*/
public boolean isBloquer() {
return bloquer;
}
/**
* Définit l'état de la liste : bloque-t-on tout ajout d'élément ou
pas ?
* @param bloquer true on bloque tout ajout d'élément, false on
autorise tout modification.
*/
public void setBloquer(boolean bloquer) {
if ((bloquer == false) && (this.bloquer == true)) {
this.bloquer = bloquer;
this.notifyAll();
} else {
this.bloquer = bloquer;
}
}
@Override
public boolean add(T arg0) {
if (bloquer) {
System.out.println("L'ajout de l'élément " + arg0 + " est
suspendu !");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Voici les informations affichées dans la console : «
Exception in thread "main" java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:485)
at listPerso.ArrayListPerso.add(ArrayListPerso.java:50)
at TestFabienListePerso.main(TestFabienListePerso.java:45)
Ajout de l'élément allo effectué !
L'ajout de l'élément coucou est suspendu !
» alors que je souhaiterais avoir : «
Ajout de l'élément allo effectué !
L'ajout de l'élément coucou est suspendu !
» puis, quand je clique sur le bouton : « Ajout de l'élément coucou
effectué ! ».
Et si vous procédiez ainsi : Créer une classe dans laquelle vous mettez un champ liste (LinkedList p.ex), que vous utiliseriez comme pile. Lors de l'ajout d'un élément, vous le mettez simplement dans la pile. Cette classe devrait être un actionListener pour le bouton, et lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements ActionListener {
private List stack;
ArrayListPerso() { this.stack = new Stack(); }
@Override public void actionPerformed(ActionEvent event) { for(Object o : this.stack) { this.add(o); } }
@Override public void add(Object o) { this.stack.add(o); }
}
Si vous voulez que l'action soit automatique plutôt que contrôlée par un bouton, utilisez simplement un timer pour générer l'action.
Bonne journée!
Foub31400 wrote:
Bonjour,
je souhaite pouvoir bloquer les éléments présents dans une java.util.List jusqu'à que l'utilisateur clique sur un bouton par exemple.
Par exemple, j'aimerais pouvoir écrire l'action suivante pour mon bouton : «
JButton btnDebloquer = new JButton("Débloquer situation !"); btnDebloquer.addActionListener(new ActionListener(){@Override public void actionPerformed(ActionEvent arg0) { maListe.setBloquer(false); } }); ».
Si avant que je clique sur le bouton, on essaye d'ajouter des éléments à ma liste, il faudrait que ces actions soient mis dans une file d'attente jusqu'à que mon clique autorise l'accès à ma liste.
Savez-vous comment pourrais-je faire cela en java ?
J'ai essayé de me créer la classe "ArrayListPerso" : «
package listPerso;
import java.util.ArrayList;
public class ArrayListPerso<T> extends ArrayList<T> { /** Version de sérialisation */ private static final long serialVersionUID = 1L;
/** * Constructeur par défaut. */ public ArrayListPerso() { super(); }
/** * Retourne un boolean pour indiquer si on bloque l'ajout d'élément * dans la liste. * * @return true la liste des éléments est bloqué, false on peut modifier la liste. */ public boolean isBloquer() { return bloquer; }
/** * Définit l'état de la liste : bloque-t-on tout ajout d'élément ou pas ? * @param bloquer true on bloque tout ajout d'élément, false on autorise tout modification. */ public void setBloquer(boolean bloquer) { if ((bloquer == false) && (this.bloquer == true)) { this.bloquer = bloquer; this.notifyAll(); } else { this.bloquer = bloquer; } }
@Override public boolean add(T arg0) {
if (bloquer) { System.out.println("L'ajout de l'élément " + arg0 + " est suspendu !"); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } }
Voici les informations affichées dans la console : «
Exception in thread "main" java.lang.IllegalMonitorStateException at java.lang.Object.wait(Native Method) at java.lang.Object.wait(Object.java:485) at listPerso.ArrayListPerso.add(ArrayListPerso.java:50) at TestFabienListePerso.main(TestFabienListePerso.java:45) Ajout de l'élément allo effectué ! L'ajout de l'élément coucou est suspendu !
» alors que je souhaiterais avoir : « Ajout de l'élément allo effectué ! L'ajout de l'élément coucou est suspendu ! » puis, quand je clique sur le bouton : « Ajout de l'élément coucou effectué ! ».
Merci d'avance pour votre aide. F.
Foub31400 wrote:
Bonjour,
je souhaite pouvoir bloquer les éléments présents dans une java.util.List jusqu'à que l'utilisateur clique sur un bouton par exemple.
Par exemple, j'aimerais pouvoir écrire l'action suivante pour mon bouton : «
JButton btnDebloquer = new JButton("Débloquer situation !"); btnDebloquer.addActionListener(new ActionListener(){@Override public void actionPerformed(ActionEvent arg0) { maListe.setBloquer(false); } }); ».
Si avant que je clique sur le bouton, on essaye d'ajouter des éléments à ma liste, il faudrait que ces actions soient mis dans une file d'attente jusqu'à que mon clique autorise l'accès à ma liste.
Savez-vous comment pourrais-je faire cela en java ?
J'ai essayé de me créer la classe "ArrayListPerso" : «
package listPerso;
import java.util.ArrayList;
public class ArrayListPerso<T> extends ArrayList<T> { /** Version de sérialisation */ private static final long serialVersionUID = 1L;
/** * Constructeur par défaut. */ public ArrayListPerso() { super(); }
/** * Retourne un boolean pour indiquer si on bloque l'ajout d'élément * dans la liste. * * @return true la liste des éléments est bloqué, false on peut modifier la liste. */ public boolean isBloquer() { return bloquer; }
/** * Définit l'état de la liste : bloque-t-on tout ajout d'élément ou pas ? * @param bloquer true on bloque tout ajout d'élément, false on autorise tout modification. */ public void setBloquer(boolean bloquer) { if ((bloquer == false) && (this.bloquer == true)) { this.bloquer = bloquer; this.notifyAll(); } else { this.bloquer = bloquer; } }
@Override public boolean add(T arg0) {
if (bloquer) { System.out.println("L'ajout de l'élément " + arg0 + " est suspendu !"); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } }
Voici les informations affichées dans la console : «
Exception in thread "main" java.lang.IllegalMonitorStateException at java.lang.Object.wait(Native Method) at java.lang.Object.wait(Object.java:485) at listPerso.ArrayListPerso.add(ArrayListPerso.java:50) at TestFabienListePerso.main(TestFabienListePerso.java:45) Ajout de l'élément allo effectué ! L'ajout de l'élément coucou est suspendu !
» alors que je souhaiterais avoir : « Ajout de l'élément allo effectué ! L'ajout de l'élément coucou est suspendu ! » puis, quand je clique sur le bouton : « Ajout de l'élément coucou effectué ! ».
Merci d'avance pour votre aide. F.
Jack
Bonjour,
Et si vous procédiez ainsi : Créer une classe dans laquelle vous mettez un champ liste (LinkedList p.ex), que vous utiliseriez comme pile. Lors de l'ajout d'un élément, vous le mettez simplement dans la pile. Cette classe devrait être un actionListener pour le bouton, et lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans le dialogue ? Un boolean, la pile, et la liste. Quand le booleen "bloquer" est a true, les éléments sont ajoutés à la pile, et au moment de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet: - de ne pas créer de sous classe inutilement - de ne pas mélanger le code graphique (Swing) et le code des données - de ne pas avoir de synchronisation comliquée
Bonjour,
Et si vous procédiez ainsi :
Créer une classe dans laquelle vous mettez un champ liste (LinkedList
p.ex), que vous utiliseriez comme pile.
Lors de l'ajout d'un élément, vous le mettez simplement dans la pile.
Cette classe devrait être un actionListener pour le bouton, et
lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les
éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements
ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans
le dialogue ? Un boolean, la pile, et la liste. Quand le booleen
"bloquer" est a true, les éléments sont ajoutés à la pile, et au moment
de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet:
- de ne pas créer de sous classe inutilement
- de ne pas mélanger le code graphique (Swing) et le code des données
- de ne pas avoir de synchronisation comliquée
Et si vous procédiez ainsi : Créer une classe dans laquelle vous mettez un champ liste (LinkedList p.ex), que vous utiliseriez comme pile. Lors de l'ajout d'un élément, vous le mettez simplement dans la pile. Cette classe devrait être un actionListener pour le bouton, et lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans le dialogue ? Un boolean, la pile, et la liste. Quand le booleen "bloquer" est a true, les éléments sont ajoutés à la pile, et au moment de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet: - de ne pas créer de sous classe inutilement - de ne pas mélanger le code graphique (Swing) et le code des données - de ne pas avoir de synchronisation comliquée
Raphael Tagliani
Bonjour,
en effet, suivez les conseils de Jack pour les types. Je ne m'en suis pas du tout occupé dans mon exemple, j'ai juste montré le concept.
Jack wrote:
Bonjour,
Et si vous procédiez ainsi : Créer une classe dans laquelle vous mettez un champ liste (LinkedList p.ex), que vous utiliseriez comme pile. Lors de l'ajout d'un élément, vous le mettez simplement dans la pile. Cette classe devrait être un actionListener pour le bouton, et lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans le dialogue ? Un boolean, la pile, et la liste. Quand le booleen "bloquer" est a true, les éléments sont ajoutés à la pile, et au moment de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet: - de ne pas créer de sous classe inutilement - de ne pas mélanger le code graphique (Swing) et le code des données - de ne pas avoir de synchronisation comliquée
Bonjour,
en effet, suivez les conseils de Jack pour les types. Je ne m'en suis
pas du tout occupé dans mon exemple, j'ai juste montré le concept.
Jack wrote:
Bonjour,
Et si vous procédiez ainsi :
Créer une classe dans laquelle vous mettez un champ liste (LinkedList
p.ex), que vous utiliseriez comme pile.
Lors de l'ajout d'un élément, vous le mettez simplement dans la pile.
Cette classe devrait être un actionListener pour le bouton, et
lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les
éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements
ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans
le dialogue ? Un boolean, la pile, et la liste. Quand le booleen
"bloquer" est a true, les éléments sont ajoutés à la pile, et au moment
de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet:
- de ne pas créer de sous classe inutilement
- de ne pas mélanger le code graphique (Swing) et le code des données
- de ne pas avoir de synchronisation comliquée
en effet, suivez les conseils de Jack pour les types. Je ne m'en suis pas du tout occupé dans mon exemple, j'ai juste montré le concept.
Jack wrote:
Bonjour,
Et si vous procédiez ainsi : Créer une classe dans laquelle vous mettez un champ liste (LinkedList p.ex), que vous utiliseriez comme pile. Lors de l'ajout d'un élément, vous le mettez simplement dans la pile. Cette classe devrait être un actionListener pour le bouton, et lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter les éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans le dialogue ? Un boolean, la pile, et la liste. Quand le booleen "bloquer" est a true, les éléments sont ajoutés à la pile, et au moment de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet: - de ne pas créer de sous classe inutilement - de ne pas mélanger le code graphique (Swing) et le code des données - de ne pas avoir de synchronisation comliquée
Foub31400
On 16 mar, 12:17, Raphael Tagliani wrote:
Bonjour,
en effet, suivez les conseils de Jack pour les types. Je ne m'en suis pas du tout occupé dans mon exemple, j'ai juste montré le concept.
Jack wrote:
Bonjour,
Et si vous procédiez ainsi : Créer une classe dans laquelle vous mettez un champ liste (LinkedList p.ex), que vous utiliseriez comme pile. Lors de l'ajout d'un élément, vous le mettez simplement dans la pil e. Cette classe devrait être un actionListener pour le bouton, et lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter l es éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans le dialogue ? Un boolean, la pile, et la liste. Quand le booleen "bloquer" est a true, les éléments sont ajoutés à la pile, et au moment de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet: - de ne pas créer de sous classe inutilement - de ne pas mélanger le code graphique (Swing) et le code des donnée s - de ne pas avoir de synchronisation comliquée
merci bcp pour vos réponses... Très intéressant, je vais pas hésiter à m'en inspirer...
On 16 mar, 12:17, Raphael Tagliani <raphael.tagli...@gmail.com> wrote:
Bonjour,
en effet, suivez les conseils de Jack pour les types. Je ne m'en suis
pas du tout occupé dans mon exemple, j'ai juste montré le concept.
Jack wrote:
Bonjour,
Et si vous procédiez ainsi :
Créer une classe dans laquelle vous mettez un champ liste (LinkedList
p.ex), que vous utiliseriez comme pile.
Lors de l'ajout d'un élément, vous le mettez simplement dans la pil e.
Cette classe devrait être un actionListener pour le bouton, et
lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter l es
éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements
ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans
le dialogue ? Un boolean, la pile, et la liste. Quand le booleen
"bloquer" est a true, les éléments sont ajoutés à la pile, et au moment
de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet:
- de ne pas créer de sous classe inutilement
- de ne pas mélanger le code graphique (Swing) et le code des donnée s
- de ne pas avoir de synchronisation comliquée
merci bcp pour vos réponses...
Très intéressant, je vais pas hésiter à m'en inspirer...
en effet, suivez les conseils de Jack pour les types. Je ne m'en suis pas du tout occupé dans mon exemple, j'ai juste montré le concept.
Jack wrote:
Bonjour,
Et si vous procédiez ainsi : Créer une classe dans laquelle vous mettez un champ liste (LinkedList p.ex), que vous utiliseriez comme pile. Lors de l'ajout d'un élément, vous le mettez simplement dans la pil e. Cette classe devrait être un actionListener pour le bouton, et lorsqu'elle reçoit l'événement 'Débloquer situation', ajouter l es éléments de la pile dans la liste finale.
Exemple (en pseudo java):
public class ArrayListPerso<T> extends ArrayList<T> implements ActionListener {
Plutôt que de créer des sous types, pourquoi ne pas mettre 3 champs dans le dialogue ? Un boolean, la pile, et la liste. Quand le booleen "bloquer" est a true, les éléments sont ajoutés à la pile, et au moment de débloquer, le contenu de la pile est ajouté à la liste.
Cela permet: - de ne pas créer de sous classe inutilement - de ne pas mélanger le code graphique (Swing) et le code des donnée s - de ne pas avoir de synchronisation comliquée
merci bcp pour vos réponses... Très intéressant, je vais pas hésiter à m'en inspirer...
