# Thread-Parameter oder Konstruktor



## Jens81 (26. Okt 2009)

Hallo zusammen,

falls ein Thread so erstellt wird...

```
private void buttonGedrueckt(int zahl) {
  Thread t = new Thread() {
    public void run() {  
      System.out.println(zahl);
      zahl = zahl + 1;
      System.out.println(zahl);
    }
  };
  t.start();
}
```
... ist es ja nicht möglich, auf zahl zuzugreifen, außer es wird final deklariert. Wie kann ich den Parameter übergeben? Über einen Konstruktor? Falls ja, wie schreibe ich den für die Klasse Thread OHNE eine eigene Klasse zu erstellen?!


----------



## objcler (26. Okt 2009)

Wieso willst du keine eigene Klasse erstellen? Angst vor OOP?


----------



## Jens81 (26. Okt 2009)

Nein, ich frage mich nur ob es ohne eigene Klasse geht. Und wenn ja, wie.


----------



## faetzminator (26. Okt 2009)

[c]private void buttonGedrueckt(final int zahl) {[/c]


----------



## Jens81 (26. Okt 2009)

Dies hatte ich ja oben bereits geschrieben. Da mit der Variablen ja noch gearbeitet werden soll, geht's leider nicht via final.


----------



## Verjigorm (26. Okt 2009)

Dein Beispiel ist von Grund auf falsch, so wird niemals ein Thread gestartet, da fehlt das Runnable

Und ohne eigene Klasse machst du dir doch eigentlich nur mehr Ärger


----------



## Michael... (26. Okt 2009)

Jens81 hat gesagt.:


> ... ist es ja nicht möglich, auf zahl zuzugreifen, außer es wird final deklariert.


 Wieso sollte es nicht möglich sein? Solange die Variable in der selben Klasse deklariert wird, in der auch der Thread erzeugt wird. In Deinem Fall hast Du ja eine lokale Variable innerhalb der Methode buttonGedrueckt(...) das funkioniert nicht und final kannst Du sie auch nicht machen, da Du ja hochzählen willst.
Man könnte es so machen (ob's sinnvoll ist weiss ich nicht):

```
private int zahl;
   
public void buttonGedrueckt(int z) {
    	zahl = z;
    	new Thread(new Runnable() {
    		public void run() {
    			System.out.println(zahl++);
    		}
    	}).start();
}
```

Normalerweise verwendet man für Threads Klassen, die Runnable implementieren. Und für aufwendigere Geschichten lohnt es ich eine eigene Klasse zu schreiben.

Übrigens ist Dir bewusst, was Du mit 
	
	
	
	





```
zahl = zahl++;
```
 anstellst????


----------



## Jens81 (26. Okt 2009)

Natürlich läuft das, außer der Zugriff auf zahl.

Hätte ich 

```
private void buttonGedrueckt() {
  Thread t = new Thread() {
    public void run() {  
      System.out.println("1");
    }
  };
  t.start();
}
```

ausgeführt, wird definitiv ein Thread erzeugt der "1" ausgibt.


----------



## Michael... (26. Okt 2009)

kompilierbar ist dieser Code aber nicht.


----------



## Jens81 (26. Okt 2009)

Sry, hatte die Klammer falsch gesetzt. Habs nicht mit copy & paste rausgeholt, sondern ohne editor getippt...hab's editiert.
zahl = zahl++ war natürlich mist 

Zahl global zu deklarieren geht natürlich... Ich würd aber gern wissen, ob es eine Möglichkeit gibt, den Wert als Parameter zu übergeben. Kann man einen eigenen Konstrukter für die Klasse thread schreiben? Ich vermute mal nicht...


----------



## Nader (26. Okt 2009)

Jens81 hat gesagt.:


> ...
> Zahl global zu deklarieren geht natürlich... Ich würd aber gern wissen, ob es eine Möglichkeit gibt, den Wert als Parameter zu übergeben. Kann man einen eigenen Konstrukter für die Klasse thread schreiben? Ich vermute mal nicht...



ich verstehe dein Problem nicht?????:L warum machst du nicht so:


```
class MyThread extends Thread {
		private int zahl;

		public MyThread(int zahl) {
			this.zahl = zahl;
		}

		public void run() {
			System.out.println(zahl);
			zahl = zahl++;
			System.out.println(zahl);
		}
	}
```


----------



## Michael... (26. Okt 2009)

Nader hat gesagt.:


> ```
> class MyThread extends Thread {
> ```


Besser wäre:

```
class MyThread implements Runnable {
```


----------



## Jens81 (26. Okt 2009)

Ich würds gern ohne eigene Klassen versuchen, da es sehr viele Funktionen gibt und ich somit sehr viele Klassen anlegen müsste. Ich weiß, dass es so geht. Meine Frage war nur, ob es auch einen anderen Weg gibt.


----------



## Michael... (26. Okt 2009)

Wüsste nicht, dass es andere Möglichkeiten, als die gezeigten gibt.
Aber wenn Du viele Funktionen hast, die unterschiedliche Threads benötigen, wäre es doch übersichtlicher für die Threads eigene Klassen zu schreiben, als alles in eine Klasse reinzuklatschen.


----------



## Nader (26. Okt 2009)

Jens81 hat gesagt.:


> ...Meine Frage war nur, ob es auch einen anderen Weg gibt.



nein, leider nicht. 

vielleicht noch was:


```
private void buttonGedrueckt(final int zahl) {
		Thread t =
			new Thread() {
				int z = zahl;

				public void run() {
					System.out.println(z);
					z = z + 1;
					System.out.println(z);
				}
			};
		t.start();
	}
```


----------



## Jens81 (26. Okt 2009)

So funktioniert's natürlich  Danke!


Übersichtlicher wären tatsächlich viele Klassen, aber es gibt viele Zugriffe auf globale Komponenten und Abhängigkeiten untereinander, so dass ich die nur äußerst ungern "auseinanderziehen" würde.


----------



## Painii (26. Okt 2009)

Jens81 hat gesagt.:


> aber es gibt viele Zugriffe auf globale Komponenten und Abhängigkeiten untereinander, so dass ich die nur äußerst ungern "auseinanderziehen" würde.



Kommt drauf an wie lang du noch an dem Projekt arbeiten wirst, aber wenns länger ist mach das lieber jetzt einmal richtig aufgebaut, als dass du deinen Datenmüll immer weiter vergrösserst... Das bringt sonst nix.

"Globale" Zugriffe entweder über static final variablen machen, oder über getter/setter, nicht direkt.

Dann kann mit der "globalen Variable" (gekapselt durch getter/setter) ja passieren was will, du bekommst deine Informationen ja aus anderen Methoden.

Ich kanns nur empfehlen, wenn du jetzt weiterbaust obwohl du weisst dass es schon unübersichtlich und "nicht ganz sauber" ist, ist es find ich ein Verbrechen so weiterzumachen und den Aufwand immer weiter zu vergrößern...


----------

