Verfügbare Informationen zu "LabelThread"
Qualität des Beitrags: Beteiligte Poster: alexander Forum: A-Welt Forum Forenbeschreibung: Das geile Forum aus dem Unterforum: Java-Forum Antworten: 1 Forum gestartet am: Freitag 04.03.2005 Sprache: deutsch Link zum Originaltopic: LabelThread Letzte Antwort: vor 18 Jahren, 6 Monaten, 6 Tagen, 17 Stunden, 41 Minuten
Alle Beiträge und Antworten zu "LabelThread"
Re: LabelThread
alexander - 23.10.2005, 13:34LabelThread
Alsoooooo, wir brauchen eine LabelThread-Klasse. Wenn sie in der selben Datei ist, wie unsere (spätere) TestLabelThread-Klasse, dann darf sie nicht public class sein! Man kann nur eine public-Klasse pro Datei haben!
Code: class LabelThread extends Label implements Runnable
{
Wie man hier erahnen kann, ist sie bei mir in der selben Datei.
#das extends Label sagt aus, dass wir von der Label-Klasse unsere LabelThread-Klasse vererben.
#das implements Runnable sagt aus, dass wir die Schnittstelle Runnable implementieren wollen. Deswegen brauchen wir eine run()-Methode in unserer Klasse.
Jetzt braucht unsere Klasse noch einpaar Speicher-Variablen:
Code: String name;
Thread t;
int von,bis,pause;
# Sting name speichert unseren Namen, damit wir ihn noch wissen, wenn wir in der run()-Methode sind. Nicht dass Java Alzheimer hat... obwohl... doch!... Wenn dem Konstruktor ein String übergeben wird, weis er es nur in der Methode. Später vergisst er es. Deswegen muss er es sich merken, also auf einen Zettel schreiben ;) d.h. er speichert es für ihn in eine globale Variable name.
# Thread t ist unser Prozess, der das Zählen übernimmt.
# int von,bis,pause sind die Variablen, die uns beim Zählen helfen. (später mehr...)
Wenn wunderts, so sieht der Kopf des Konstruktors aus:
Code: public LabelThread(String str, int von, int bis, int sleep)
{
ganz wichtig ist, dass wir den originalen Konstrukror, also den Label-Konstuktor in unseren LabelThread-Konstuktor aufrufen. Das geschiet so:
Code: super(); // Label-Konstruktor
Es ist wichtig, dass man es als ersten, wenn überhaupt, in unserem Kontruktor machen, sonst mekert der Compiler.
Jetzt speichern wir die übergebenen Variablen:
Code: this.von = von;
this.bis = bis;
pause = sleep;
name = str;
# this bedeutet so viel wie dieses d.h. das wir auf die aktuelle Instanz der Klasse beziehen. Auf Deutsch heißt das, dass wir die Klasse meinen, wo wir das this verwenden. Das bedeutet, das wir mit this.von die globale Variable von meinen. Das normale von, also ohne this davor, ist das, was man übergeben bekommt. Begründung: Man kann immer zwei gleiche Variable mit exakt dem selben Namen haben; ein globalen und einen lokalen. Beispiel:
Code: // Bespiel
// gehört nicht zu den Quellcode der Aufgabe
class Test()
{
int von; // global
void testus()
{
int von; // lokal
}
void gehtauch()
{
int von; // auch lokal
}
}
Wenn man in einer Methode eine Variable anspicht meint man immer die lokale Variable, es sei den es gibt keine lokale, dann nimmt man die globale, wenn man aber auch keine globale hat, dann hat man einen Fehler, denn die Variable gibt es wahrscheinlich noch nicht!
Jetzt noch mal. this.von meint man die globale Variable von und nur von die lokale. Wenn man aber so geschrieben hätte...
Code: // auch ein Beispiel
// gehört auch nicht zum Quellcode der Aufgabe
class Test()
{
int von; // global
void testus(int von /*lokal*/)
{
von = von; // guck hier
}
}
... dann hätte man das lokale von dem lokalem von zugewiesen. Also hätte man gar nichts sinnvolles gemacht!
#this.bis = bis ist so ähnlich wie this.von
#bei pause = sleep braucht man kein this, da es kein lokales pause exestiert
#name = str ist wie pause = sleep
So weiter geht's. Jetzt müssen wir einen Prozess erzeugen:
Code: t = new Thread(this,name);
}
#new Thread(this,name) erzeugt einen neuen Prozess mit dem Namen name und der Runnablel-implementierten-Klasse na... this... mit der LabelThread Klasse!
So jetzt die run()-Methode:
Code: public void run()
{
Die brauchen wir wegen dem Runnablel und dem Thread t! Jetzt eine Schleife von von bis bis.
Code: for(int i=von;i<bis;i++)
{
Wir geben in der Schleife unseren Fortschritt der Schleife an:
Code: setText(i+" "+name);
#was ist jetzt dieses setText(..)? Wir kennes eigentlich von l.setText(..), wobei l ein Label ist. Nun um es kurz zu machen setText ist eine Methode unserer LabelThread-Klasse. Jetzt fragt man sich vielleicht: wie unserer Klasse? Wir haben die Methode ja nicht in unsere Klasse eingefügt und wir haben auch nicht vor es in unsere Klasse einzufügen. Also woher kommt diese Methode her? Tja.. Es kommt von der vererbten Label-Klasse. Mit der Vererbung kann man auf alle public (und protected) Variablen und Mehtoden zugreifen, die in der zu vererbenden Klasse sind. (protected haben wir nicht behandelt und wie ich es Lommel zutraue, werden wir es auch nicht behandeln. Also werde ich es erklären. Da alle Elemente die private nicht von aussen zugegriffen werden dürfen, auch nicht von der vererbten Klasse , gibt es das protected. Damit kann man auch nicht von außen auf das Element zugreifen, jedoch von der vererbten Klasse! Aha...)
Also weiter:
Code: try{
Thread.sleep(pause);
}catch (InterruptedException e){}
}
Hier sagen wir, dass der Thread pause-lang "schlafen" soll.
Wenn er mit der Schleife fertig ist, soll er das hier ausgeben:
Code: setText("FERTIG! "+name);
}
Damit wir unsern Thread auch starten können, schreiben wir eine start()-Methode:
Code: public void start()
{
t.start();
}
}
Jetzt brauchen wir nur eine Test-Klasse:
Code: public class TestLabelThread extends Frame
{
LabelThread lt1, lt2;
public TestLabelThread()
{
this.addWindowListener (new WindowAdapter(){
public void windowClosing(WindowEvent e){
dispose();
System.exit(0);
}
});
wir erzeugen zwei Instanzen unserer Klasse:
Code: lt1 = new LabelThread("Coerde",0,10,500);
lt2 = new LabelThread("Sprakel",0,10,1000);
wir können wie gewohnt setLayout(null) setzen und per setBounds die Position angeben. Also so:
Code: setLayout(null);
lt1.setBounds(10,60,100,20);
lt2.setBounds(10,100,100,20);
Jedoch mache ich lieber einen anderen Layout, damit ich mich nicht darum kümmern muss:
Code: setLayout(new GridLayout(1,2));
jetzt hinzufügen:
Code: add(lt1);
add(lt2);
und die Prozesse starten:
Code: lt1.start();
lt2.start();
und der restliche Scheiß:
Code: setSize(400,400);
show();
}
public static void main(String args[])
{
System.out.println("Starting App");
new TestLabelThread();
}
}
Und wer hat gewonnen? COERDE!!!! Und warum? Die Zeit, die Coerde immer "schläft" ist kürzer als bei Sprackel!
Jetzt der Code am Stück:
Code: import java.awt.*;
import java.awt.event.*;
class LabelThread extends Label implements Runnable
{
String name;
Thread t;
int von,bis,pause;
public LabelThread(String str, int von, int bis, int sleep)
{
super(); // Label-Konstruktor
this.von = von;
this.bis = bis;
pause = sleep;
name = str;
t = new Thread(this,name);
}
public void run()
{
for(int i=von;i<bis;i++)
{
setText(i+" "+name);
try{
Thread.sleep(pause);
}catch (InterruptedException e){}
}
setText("FERTIG! "+name);
}
public void start()
{
t.start();
}
}
public class TestLabelThread extends Frame
{
LabelThread lt1, lt2;
public TestLabelThread()
{
this.addWindowListener (new WindowAdapter(){
public void windowClosing(WindowEvent e){
dispose();
System.exit(0);
}
});
setLayout(new GridLayout(1,2));
lt1 = new LabelThread("Coerde",0,10,500);
lt2 = new LabelThread("Sprakel",0,10,1000);
add(lt1);
add(lt2);
lt1.start();
lt2.start();
setSize(400,400);
show();
}
public static void main(String args[])
{
System.out.println("Starting App");
new TestLabelThread();
}
}
So jezt sind wir fertig... hoffentlich nicht mit den Nerven, oder?
mfg alexander
Mit folgendem Code, können Sie den Beitrag ganz bequem auf ihrer Homepage verlinken
Weitere Beiträge aus dem Forum A-Welt Forum
Hilferuf aus der 12. - gepostet von Selflezz am Sonntag 20.08.2006
Fräge - gepostet von Belafarinrod am Sonntag 12.03.2006
Ähnliche Beiträge wie "LabelThread"