Unterschied zwischen extends Thread und implements Runnable

[Schüler]

Hallo,

ich hab jetzt schonmal das Forum hier nach dieser "Topic-Frage" durchsucht, aber nix gefunden. Ich verstehe irgenwdie nicht ganz wo die gravierenden Unterschiede zwischen extends Thread und implements Runnable sind.

Auch beim Lesen in Java ist auch eine Insel wurde mir des nicht ganz klar. Mir ist nur bei bei kleinen Beispiel Programmen aufgefallen das die Objektinitialisierung anders verläuft.

public class hiphop2_r implements Runnable {

	//Erzeugen der Klassen-Variabeln
	private String word;
	private int delay;

	//Deklarieren des Übergabe-Konstruktors
	public hiphop2_r (String word, int delay){
		this.word = word;
		this.delay = delay;
	}
	/*Deklarieren der run()-Funktion, um somit festzulegen, was passieren soll, 
	wenn die Threats gestartet werden. Die Funktion run() muss hier deklariert
	werden, da Sie Teil der Schnittstelle ist.*/
	public void run (){
		while (true){
			System.out.print(word + " ");

			/*Die Funktion "sleep" gehört zur Klasse Threat und unterbricht die 
			Ausführung des aktuellen Threats für die in Milli- und Nanosekunden
			angegebene Zeit. Sie kann eine "IllegalArgumentException" oder eine 
			"InterruptedException" auslösen*/
			try{
				Thread.sleep(delay);
			}catch (InterruptedException e){}
		}
	}

	 public static void main(String[] args) {
		//Initialisieren der zwei Threat-Objekte hip und hop
		hiphop2_r hip = new hiphop2_r ("Hip", 100);
		hiphop2_r hop = new hiphop2_r ("HOP", 500);

		/*Die Methode "start" beginnt mit der Ausführung des aufrufenden Objektes. Sie 
		kann eine IllegalThreadStateException auslösen, wenn der Threat bereits 
		gestartet wurde.*/
		new Thread(hip).start();
		new Thread(hop).start();

	}

}

und mit extends Thread

public static void main(String[] args) {
		//Initialisieren der zwei Threat-Objekte hip und hop
		hiphop2_t hip = new hiphop2_t ("Hip", 100);
		hiphop2_t hop = new hiphop2_t ("HOP", 500);

		/*Die Methode "start" beginnt mit der Ausführung des aufrufenden Objektes. Sie 
		kann eine IllegalThreadStateException auslösen, wenn der Threat bereits 
		gestartet wurde.*/

		hip.start();
		hop.start();

	}

Nur warum, muss das anders Initialisiert werden. Was geht da im System vor? Das kann ich mir einfach nicht erklären. Wäre über eine einleutende Erklärung wirklich dankbar.

[DEvent]

Wenn deine Klasse A direkt von Thread ableitest, dann ist die Klasse A ein Thread, somit wird im Konstruktor von A der Konstruktor des Threads aufgerufen.

new A() // hier erzeugest du schon ein Thread.

Eine Klasse B die nur Runnable implementiert ist kein Thread, sondern nur "runnable", deswegen muss zuerst ein Thread erzeugt werden mit

new Thread(b)

und dann eben die .start() Methode aufgerufen werden.

Imho macht es mehr Sinn nur das zu implementieren was man auch braucht, also eigentlich nur Runnable. Von Thread würde ich nur ableiten, wenn ich auch wirklich ein speziellen Thread brauche.

[LeGaN]

Außerdem kann man, wenn man von Thread ableitet, nicht mehr von einer anderen Klasse ableiten. Wenn man nur Runnable implementiert, dann eben schon.

public class B extends A implements Runnable

[Schüler]

Vielen Dank, das war genau die kurze aussagekräftige Erklärung die ich gebraucht hab.