A propos des Threads,
sauriez vous s'il est possible, au lieu d'utiliser une fonction run(),
de faire quelquechose comme :
class Ragnagna {
Thread go;
public Ragnagna() {
...
if (go == null) {
go = new Thread (new ThreadAdapter() {
... // ce qui est fait en parrallele
}
go.start();
}
}
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
Kupee
Florent wrote:
bonjour,
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
Florent wrote:
bonjour,
A propos des Threads,
sauriez vous s'il est possible, au lieu d'utiliser une fonction run(),
de faire quelquechose comme :
class Ragnagna {
Thread go;
public Ragnagna() {
...
if (go == null) {
go = new Thread (new ThreadAdapter() {
... // ce qui est fait en parrallele
}
go.start();
}
}
merci d'avance.
Euh tu parles pas de l'interface Runnable ?
tout simplement ?
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
Florent
Kupee wrote:
Florent wrote:
bonjour,
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ... donc je sais pas trop en fait :-/
Kupee wrote:
Florent wrote:
bonjour,
A propos des Threads,
sauriez vous s'il est possible, au lieu d'utiliser une fonction
run(), de faire quelquechose comme :
class Ragnagna {
Thread go;
public Ragnagna() {
...
if (go == null) {
go = new Thread (new ThreadAdapter() {
... // ce qui est fait en parrallele
}
go.start();
}
}
merci d'avance.
Euh tu parles pas de l'interface Runnable ?
tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ...
donc je sais pas trop en fait :-/
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ... donc je sais pas trop en fait :-/
Kupee
Florent wrote:
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ... donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui l'implémente doit obligatoirement implémenter. Ca permet de faire de facon limitée de l'héritage multiple. Tu peux faire des threads de 2 manière : en étendant la classe Thread et surchargeant la méthode public void run(), ou en implémentant l'interface Runnable et en passant cette implémentation dans le constructeur du thread ;
if (go == null) { go = new Thread(new Runnable() { public void run() { while (runOk) { //faire un truc; } } }); } go.start();
Florent wrote:
A propos des Threads,
sauriez vous s'il est possible, au lieu d'utiliser une fonction
run(), de faire quelquechose comme :
class Ragnagna {
Thread go;
public Ragnagna() {
...
if (go == null) {
go = new Thread (new ThreadAdapter() {
... // ce qui est fait en parrallele
}
go.start();
}
}
merci d'avance.
Euh tu parles pas de l'interface Runnable ?
tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ...
donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui
l'implémente doit obligatoirement implémenter. Ca permet de faire de
facon limitée de l'héritage multiple. Tu peux faire des threads de 2
manière : en étendant la classe Thread et surchargeant la méthode
public void run(),
ou en implémentant l'interface Runnable et en passant cette
implémentation dans le constructeur du thread ;
if (go == null) {
go = new Thread(new Runnable() {
public void run() {
while (runOk) {
//faire un truc;
}
}
});
}
go.start();
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ... donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui l'implémente doit obligatoirement implémenter. Ca permet de faire de facon limitée de l'héritage multiple. Tu peux faire des threads de 2 manière : en étendant la classe Thread et surchargeant la méthode public void run(), ou en implémentant l'interface Runnable et en passant cette implémentation dans le constructeur du thread ;
if (go == null) { go = new Thread(new Runnable() { public void run() { while (runOk) { //faire un truc; } } }); } go.start();
Florent
Kupee wrote:
Florent wrote:
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ... donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui l'implémente doit obligatoirement implémenter. Ca permet de faire de facon limitée de l'héritage multiple. Tu peux faire des threads de 2 manière : en étendant la classe Thread et surchargeant la méthode public void run(), ou en implémentant l'interface Runnable et en passant cette implémentation dans le constructeur du thread ;
if (go == null) { go = new Thread(new Runnable() { public void run() { while (runOk) { //faire un truc; } } }); } go.start();
Merci !
Kupee wrote:
Florent wrote:
A propos des Threads,
sauriez vous s'il est possible, au lieu d'utiliser une fonction
run(), de faire quelquechose comme :
class Ragnagna {
Thread go;
public Ragnagna() {
...
if (go == null) {
go = new Thread (new ThreadAdapter() {
... // ce qui est fait en parrallele
}
go.start();
}
}
merci d'avance.
Euh tu parles pas de l'interface Runnable ?
tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ...
donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui
l'implémente doit obligatoirement implémenter. Ca permet de faire de
facon limitée de l'héritage multiple. Tu peux faire des threads de 2
manière : en étendant la classe Thread et surchargeant la méthode
public void run(),
ou en implémentant l'interface Runnable et en passant cette
implémentation dans le constructeur du thread ;
if (go == null) {
go = new Thread(new Runnable() {
public void run() {
while (runOk) {
//faire un truc;
}
}
});
}
go.start();
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ... donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui l'implémente doit obligatoirement implémenter. Ca permet de faire de facon limitée de l'héritage multiple. Tu peux faire des threads de 2 manière : en étendant la classe Thread et surchargeant la méthode public void run(), ou en implémentant l'interface Runnable et en passant cette implémentation dans le constructeur du thread ;
if (go == null) { go = new Thread(new Runnable() { public void run() { while (runOk) { //faire un truc; } } }); } go.start();
Merci !
Florent
Florent wrote:
Kupee wrote:
Florent wrote:
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ... donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui l'implémente doit obligatoirement implémenter. Ca permet de faire de facon limitée de l'héritage multiple. Tu peux faire des threads de 2 manière : en étendant la classe Thread et surchargeant la méthode public void run(), ou en implémentant l'interface Runnable et en passant cette implémentation dans le constructeur du thread ;
if (go == null) { go = new Thread(new Runnable() { public void run() { while (runOk) { //faire un truc; } } }); } go.start();
Merci !
Un double merci d'ailleurs:
j'etendais la class Thread et j'implementais Runnable en plus :-/
Florent wrote:
Kupee wrote:
Florent wrote:
A propos des Threads,
sauriez vous s'il est possible, au lieu d'utiliser une fonction
run(), de faire quelquechose comme :
class Ragnagna {
Thread go;
public Ragnagna() {
...
if (go == null) {
go = new Thread (new ThreadAdapter() {
... // ce qui est fait en parrallele
}
go.start();
}
}
merci d'avance.
Euh tu parles pas de l'interface Runnable ?
tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ...
donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui
l'implémente doit obligatoirement implémenter. Ca permet de faire de
facon limitée de l'héritage multiple. Tu peux faire des threads de 2
manière : en étendant la classe Thread et surchargeant la méthode
public void run(),
ou en implémentant l'interface Runnable et en passant cette
implémentation dans le constructeur du thread ;
if (go == null) {
go = new Thread(new Runnable() {
public void run() {
while (runOk) {
//faire un truc;
}
}
});
}
go.start();
Merci !
Un double merci d'ailleurs:
j'etendais la class Thread et j'implementais Runnable en plus :-/
A propos des Threads, sauriez vous s'il est possible, au lieu d'utiliser une fonction run(), de faire quelquechose comme :
class Ragnagna { Thread go; public Ragnagna() { ... if (go == null) { go = new Thread (new ThreadAdapter() { ... // ce qui est fait en parrallele } go.start(); } }
merci d'avance.
Euh tu parles pas de l'interface Runnable ? tout simplement ?
heu... je suis plutot debutant, j'utilise *implements* sans vraiment
savoir comment ca marche ... donc je sais pas trop en fait :-/
Ba en gros une interface définit des méthodes que toutes classe qui l'implémente doit obligatoirement implémenter. Ca permet de faire de facon limitée de l'héritage multiple. Tu peux faire des threads de 2 manière : en étendant la classe Thread et surchargeant la méthode public void run(), ou en implémentant l'interface Runnable et en passant cette implémentation dans le constructeur du thread ;
if (go == null) { go = new Thread(new Runnable() { public void run() { while (runOk) { //faire un truc; } } }); } go.start();
Merci !
Un double merci d'ailleurs:
j'etendais la class Thread et j'implementais Runnable en plus :-/