Java Thread einfachste Grundlage

[7123]

Hi,
sorry das ich hier so leichte Fragen stellen muss, aber ich habe erst vor 1 woche mit JAVA angefangen, hier meine Frage:
Wenn ich einen Thread mittels "implement Runnable" erstelle benötigt man ja keine main, jedoch gibt es auf dieser Seite, http://www.javacooperation.gmxhome.de/BallBewegungDeu.html
verschiedene Methoden wie z.b. init, start, usw (siehe seite). Also gleich vorweg, ich habe schon auf vielen Seiten versucht nachzulesen was die Methoden genau bewirken aber den richtigen "Durchblick" habe ich noch nicht. Also bitte ganz einfach erklären, wenn es geht
Ich verstehe den Programmablauf nicht, was wird zuerst aufgerufen, die start() Methode und wo muss man die auf die run() mehtode beziehen?. Und warum wird die run() Methode immer wiederholt? Wenn die run() Methode beendet ist wird doch die paint() Methode ausgeführt, aber warum geht der Compiler dann wieder zur run() Methode zurück? Ich kenne bisher nur Programme mit main, ist bei Threads das anderes?

Ich hoffe ihr könnt mir weiter helfen, am besten wäre es wenn ihr mir das Prinzip der Thread noch mal ganz knapp erklären könnten, in den Tutorials ist das immer ziemlich kompliziert erklärt !!!

mfG

 

[FArt]

Das ist ein wenig zu viel...

http://www.galileocomputing.de/openbook/javainsel7/javainsel_10_001.htm#mj492cc74ea623bacbf44060ae96fdcf36

Kleiner Tipp: Es gibt Leute, die behaupten, Programmierung von Nebenläufigkeiten und deren korrekte Synchronisation sind die Königsdisziplin der Programmierung... von wegen Anfänger ...
Deine Frage lässt vermuten, dass es für dich sinnvoll wäre erst die Grundlagen mal zu festigen...

 

[Guest]

Das Beispiel, dass du dir ausgesucht hast ist vielleicht etwas unglücklich gewählt, da es sich um ein Applet handelt.

Ich würde sagen du liest Dir das hier durch:
http://www.galileodesign.de/openbook/javainsel5/javainsel09_001.htm

Grundsätzlich läuft das mit Threads so:

1. Klasse, die in einem Thread laufen soll implementiert das interface Runnable (das die Klasse zwingt, die Methode run() zu implementieren).

2. Erzeuge ein Threadobjekt und übergebe ein Objekt der Klasse.

Beispiel:

public class ThreadDemo {
	
	public static void main(String[] argv){
		
		RandomNumber randomnumber = new RandomNumber(); // erzeuge Objekt der Klasse
		Thread meinthread = new Thread(randomnumber);	// übergebe randomnumber Objekt einem Thread Objekt
		
		meinthread.start(); // starte thread
	}
	

}

// Programmcode der in einem eigenen Thread laufen soll
class RandomNumber implements Runnable{
	
	// hier ist der Startpunkt des Threads
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println(Math.random());
		}
	}
}

 

[7123]

also bisher habe ich die Seite http://www.gailer-net.de/tutorials/java/java-toc.html#05
halbwegs "durchgearbeitet", bis auf Kapitel 7 und 10 die ich Momentan für nicht ganz so entscheident halte, das Problem ist das ich nicht weiß was noch alles Grundlagen sind, da es auf der Seite leider nicht mehr Kaptiel gibt. ich versuch mal meine Fragen von oben in einer Frage zu formulieren

Bewirkt die run() Anweisung, das der gesamte Programmcode der Klasse noch einmal durchgeführt wird, bis die Bedingung der run() Methode falsch ist?

 

[FArt]

Die run() Methode wird (nachdem man auf der Threadinstanz start() aufgerufen hat) einmal aufgerufen. Wenn sie durchlaufen ist, ist der Thread beendet.

 

[7123]

aber während die run() Methode ausgeführt wird parellel noch der sich der run() Methode anschließende Programmcode, z.b. eine paint() Methode, die ein Rechteck zeichnet , das ist doch der Sinn der run() Methode, oder bin ich da völlig auf dem falschen weg?

 

[Gast]

Welche Bedingung der run() Methode?

Nein, du musst dir das so vorstellen: Eine Klasse, die das Interface Runnable implementiert, also eine run() Methode hat, überhaupt erst die Möglichkeit hat, als Thread ausgeführt zu werden. run() ist einfach der Startpunkt des Threads. run() wird aber nie "per Hand" aufgerufen, sondern dient dem Thread als eine Art Erkennungsmarke wo er mit der Ausführung beginnen muss.

Du übergibst, wie in meinem Beispiel oben, einem Thread Objekt deine Klasse (die das Interface runnable implementiert).

Über thread.start() wird deine Programmcode, der in der run() Methode steckt, nebenläufig, also als eigener Thread ausgeführt.

 

[Guest]

aber während die run() Methode ausgeführt wird parellel noch der sich der run() Methode anschließende Programmcode, z.b. das Zeichnen eines Rechtecks ausgeführt, das ist doch der Sinn der run Methode, oder?

run() dient nur als Einstiegspunkt in den Thread. Was du innerhalb von run() aufrufst wird auch in diesem Thread ausgeführt:

public class ThreadDemo {
	
	public static void main(String[] argv){
		
		RandomNumber randomnumber = new RandomNumber(); // erzeuge Objekt der Klasse
		Thread meinthread = new Thread(randomnumber);	// übergebe randomnumber Objekt einem Thread Objekt
		
		meinthread.start(); // starte thread
	}
	

}

// Programmcode der in einem eigenen Thread laufen soll
class RandomNumber implements Runnable{
	
	// hier ist der Startpunkt des Threads
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println(Math.random());
		}
		sagwas();
		paintSonstwas()... usw.
	}
	
	private void sagwas(){
		System.out.println("Hallo Welt");
	}
}

 

[7123]

Hm, ich möchte doch noch mal auf den Code von der oben genannten Seite eingehen:

public void run ()
{ 

Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
while (true)
{ 
	x_pos ++;
	repaint();
try
{ 
Thread.sleep (50);
}
catch (InterruptedException ex)
{ 
}

Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
} 
} 

public void paint (Graphics g)
{ 

g.setColor (Color.red);

g.fillOval (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);
}

hier mal ein Auschnitt aus dem Code, in dem Beispiel wird ja ein roter Ball vom linken Bildschirmrand nach rechts bewegt. Ich verstehe nur eins nicht: Zuerst wird doch die run() Methode ausgeführt x_pos wird erhöht und der Sreen neu gezeichnet, soweit so gut, aber der eigentliche "rote Ball" wird doch erst in der paint Methode erstellt und wenn die zu ende ist müsste das Programm doch auch zu ende sein. Jedoch scheint das Programm dann wieder in die run() Methode zu springen diese auszuführen und dann wieder in die paint() usw. Ich kann nicht nachvollziehen warum die beiden Methoden immer wieder ausgeführt werden, ich hoffe ich konnte mein Problem jetzt etwas deutlicher machen

 

[Guest]

Also,

beim Starten des Applets wird ein kleiner roter Kreis auf dem Panel ganz links gezeichnet.
Dann wird der Thread gestartet mit th.start(); Das heisst es geht weiter in der run() Methode.
Un dort ist eine Endlosschleife (while(true):Das heisst, auch wenn der rote Kreis schon längst rechts verschwunden ist, befindet sich das Programm immer noch in dieser Schleife.

Durch x_pos++; wird die globale Variabe x_pos um eins erhöht. Wird anschließend repaint() aufgerufen wird die gesamte Oberfläche neu gezeichnet, das bedeutet, dass auch paint aufgerufen wird und den Kreis neu zeichnet mit neuer x_pos Koordinate.

Danach schläft der Thread 50 ms, so dass das man die Bewegung auch noch erkennen kann.

 

[7123]

Ach repaint() ruft ja automatisch die paint() Methode auf, deshalb wird das Bild jedesmal neu gezeichnet, sry für die Frage von oben, jetzt wird mir so einiges klar... . Was ich aber immer noch nicht verstehe ist das Prinzip der run() Methode, ich hab mal in einem Tutorial gelesen, das durch die run() Methode mehrer Programmcodes gleichzeitig ausgeführt werden (Multithreading), aber warum ist das in dem Beispiel nicht so, wenn man z.b. noch einen Programmcode z.b. das Zeichen eines Rechteckes in einer anderen Klasse anhängt, würde dieser dann parallel zur Bewegung des Kreises ausgeführt?

Anm.: "@Gast": Wieso wird der Kreis zuerst gezeichnet, die Paint() Methode wird doch erst in der Run() Methode aufgerufen, also müsste der Kreis beim Starten des Threades noch gar nicht existieren, erst wenn der Thread repaint() aufruft, oder?

 

[Guest]

paint() ist eine Methode des Applets.
Die Klasse Ballbewegung1 erbt von der Klasse Applet:

Ballbewegung1 extends Applet

Dann wird die Methode paint() überschrieben also mit eigenem Programmcode gefüllt.

repaint() bewirkt, dass das Applet neu gezeichnet wird. Da ein Neuzeichnen auch den Aufruf von paint() beinhaltet, wird paint() ausgeführt und dein Kreis um eins nach rechts versetzt gezeichnet.

Ich sagte ja, befasse dich nicht gleich mit einem Applet ;-)

 

[Leroy42]

Ach repaint() ruft ja automatisch die paint() Methode auf, deshalb wird das Bild jedesmal neu gezeichnet

Nicht ganz! repaint() veranlaßt nur den EDT die paint-Methode aufzurufen, sobald
er wieder dran ist.

Anm.: "@Gast": Wieso wird der Kreis zuerst gezeichnet, die Paint() Methode wird doch erst in der Run() Methode aufgerufen, also müsste der Kreis beim Starten des Threades noch gar nicht existieren, erst wenn der Thread repaint() aufruft, oder?

Nein! Erst in der run-Methode wird der EDT aufgefordert, paint erneut auszuführen.

Das paint() wird zusätzlich immer dann aufgerufen, wenn der EDT meint es aufrufen zu müssen.

Also ganz zu Anfang und automatisch immer dann, wenn der Zeichenbereich erneut
in den Vordergrund kommt (zum Beispiel wenn man ein anderes Fenster darüberzieht oder
das Zeichenfenster zwischenzeitlich minimiert wurde.

 

[7123]

Danke erstmal für eure Hilfe, jetzt hab ich zumindest verstanden wie das Programm abläuft, aber eine Frage hab ich doch noch^^ Warum schreibt man den ganzen Ablauf (roter Ball bewegt sich von links nach rechts) nicht in eine einzige main mit einer while schleife und schreibt in die Schleife den ganzen Code hinein?

@Leroy: 1.Was ist EDT?^^
2. Bedeutet das das bei einem Applet immer zuerst die paint( ) Methode aufgerufen wird, bevor eine andere Methode wie der Aufruf von run( ) bewerkstelligt wird?

 

[Gast]

EDT = Event Dispatcher Thread = Der Thread in dem die GUI ausgeführt wird.

Aber warum der Kreis, wenn er in der while Schleife erzeugt wird, flackert das müssten dann die Profis beantworten:

package various;
import java.applet.*;
import java.awt.*;

public class Ballbewegung1 extends Applet implements Runnable
{
	// Initialisierung der Variablen
	int x_pos = 10;		// x - Position des Balles
	int y_pos = 100;	// y - Position des Balles
	int radius = 20;	// Radius des Balles

	public void init()
	{
		setBackground (Color.blue);
	}

	public void start ()
	{
		// Schaffen eines neuen Threads, in dem das Spiel läuft
		Thread th = new Thread (this);
		// Starten des Threads
		th.start ();
	}

	public void stop()
	{

	}

	public void destroy()
	{

	}

	public void run ()
	{
		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

		// Solange true ist läuft der Thread weiter
		
		while (true)
		{

			// Verändern der x- Koordinate
			x_pos ++;

			// Neuzeichnen des Applets
			repaint();

			Graphics g = this.getGraphics();
			g.setColor  (Color.red);
			g.fillOval (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);
			
			try
			{
				// Stoppen des Threads für in Klammern angegebene Millisekunden
				Thread.sleep (20);
			}
			catch (InterruptedException ex)
			{
				// do nothing
			}

			// Zurücksetzen der ThreadPriority auf Maximalwert
			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		}
	}
}

 

[Leroy42]

Aber warum der Kreis, wenn er in der while Schleife erzeugt wird, flackert das müssten dann die Profis beantworten:

Einfach weil dein repaint-Aufruf in der while-Schleife zuerst immer den Bildschirm löscht.

Stichwort: Kein DoubleBuffering.

Außerdem:

Graphics g = this.getGraphics();
// mit g herumhantieren

Ganz ganz böse! :noe:

 

[7123]

hab noch mal einige Fragen zu Befehlen, was macht eigentlich (this), (try) und eben dieses (Graphics g)? Ich hab jetzt mal versucht einen code aus einem Tutorial auszuführen, aber da steht immer das die Main Class nicht gefunden wird, hier mal der Code:

 public class b
 extends Thread
 {
   int cnt = 0;
 
   public void run()
   {
     while (true) {
       if (isInterrupted()) {
         break;
      }
      printLine(++cnt);
    }
   }
 
   private void printLine(int cnt)
   {
     //Zeile ausgeben
     System.out.print(cnt + ": ");
     for (int i = 0; i < 30; ++i) {
     System.out.print(i == cnt % 30 ? "* " : ". ");
     }
     System.out.println();
     //100 ms. warten
     try {
       Thread.sleep(100);
     } catch (InterruptedException e) {
       interrupt();
    }
   }
 
   public static void main(String[] args)
   {
     b th = new b();
     {
       //Thread starten
       th.start();
       //2 Sekunden warten
       try {
         Thread.sleep(2000);
       } catch (InterruptedException e) {
       }
       //Thread unterbrechen
       th.interrupt();
     }
   }
 }

hab auch mal das Programm von "Gast" eine Seite weiter vorne getestet, da kommt der selbe Fehler: Couldnt find main class

 

[Baunty]

Ich hab keine Ahnung von Threads aber ich mein ich hät eben noch gelesen das man Runnable implementieren muss...
Und wenn das nen Applet ist musst du es auch als applet starten & nich als java app..
korrigiert mich wenn ich falsch liege ;-)

 

[SlaterB]

extends Thread reicht alternativ zu Runnable,

Klassen sollte man groß schreiben,
Klassen müssen genauso heißen wie die sie enthaltenen Dateien

wenn man es nicht schafft, ein Programm mit einer main-Operation zu starten, was ja nun ein ganz zentraler Baustein zum Ablauf eines Programmes ist,
dann sollte man sich erstmal an einem Hello World-Programm vom ersten Kapitel eines Lehrbuches versuchen,

auch wenn man das schon kennt, nur um sich wieder zu überzeugen, wie es geht
und dann das funktionierende mti dem nicht funktionierenden Programm Schritt für Schritt vergleichen:
Klasse umbenenen, notfalls jede unterschiedliche Codezeile einzeln einfügen

 

[7123]

"Klassen sollte man große schreiben"!!! Danke, das wusste ich nicht jetzt geht es, gibt es eigentlich einen unterschied zwischen extend thread und implement runnable?

 

[Leroy42]

Ja, den gibt es.

Genaueres findest du hier

Sorry, aber ein bischen lesen muß man schon selbst. :meld:

 

[7123]

also implements runnable verwendet man um applets threatfähig zu machen und exten d Thread bei anderen, ist das so richtig?

 

[FArt]

also implements runnable verwendet man um applets threatfähig zu machen und exten d Thread bei anderen, ist das so richtig?

Schwachsinn.

Du bist einer von den Lernresistenten, oder?

Bitte mein erstes Posting in diesem Thread (nicht Runnable...ROFL) befolgen, davor sinnvollerweise noch Lerory42s Anweisung befolgen, sonst wird das nichts.

 

[7123]

Hab auf eueren rat noch einmal von vorne angefangen und mal 2 Klassen erstellt, aber diese 2 Klassen können ja nicht beide wie das Projekt heißen, die Klassen heißen Klasse1 und Klasse2, also muss ich doch Klasse 1 in Klasse1.java und Klasse 2 in Klasse 2.java speichern, aber wie kann ich nun in Klasse 1 die Klasse 2 aufrufen, die ich brauche um ein Objekt zu erzeugen (da Klasse 2 ja jetzt in einer anderen Datei ist)?

 

[FArt]

Hab auf eueren rat noch einmal von vorne angefangen und mal 2 Klassen erstellt, aber diese 2 Klassen können ja nicht beide wie das Projekt heißen, die Klassen heißen Klasse1 und Klasse2, also muss ich doch Klasse 1 in Klasse1.java und Klasse 2 in Klasse 2.java speichern, aber wie kann ich nun in Klasse 1 die Klasse 2 aufrufen, die ich brauche um ein Objekt zu erzeugen (da Klasse 2 ja jetzt in einer anderen Datei ist)?

Ne, du hast nicht ganz von vorne angefangen. Ganz von vorne ist die erste Seite von "Java ist auch eine Insel". So ziemlich am Anfang wird dann auch die Lösung zu deiner letzten Frage gebeben... noch ganz ohne Threads.

 

[7123]

Ich meine mit von vorne angefangen nicht das ich dieses E-Book lese, ich verwende andere Quellen weil mir den Art auf der das Buch geschrieben ist zu kompliziert ist, warum könnt ihr mir nicht einfach mal sagen wo es steht, ich kann doch nicht alle seiten durchlesen außerdem ist "so ziemlich am anfang" relativ (sag doch wenigstens mal das kapitel oder wenn du weißt wie es geht das prinzip)

 

[Guest]

Hab auf eueren rat noch einmal von vorne angefangen und mal 2 Klassen erstellt, aber diese 2 Klassen können ja nicht beide wie das Projekt heißen, die Klassen heißen Klasse1 und Klasse2, also muss ich doch Klasse 1 in Klasse1.java und Klasse 2 in Klasse 2.java speichern, aber wie kann ich nun in Klasse 1 die Klasse 2 aufrufen, die ich brauche um ein Objekt zu erzeugen (da Klasse 2 ja jetzt in einer anderen Datei ist)?

hä?

Angenommen du hast ein package demo. Darin enthalten sind Klasse1 und Klasse2. Dann kannst du doch von Klasse1 auf Klasse2 zugreifen:

package demo;

public class Klasse1 {
	public static void main(String[] argv){
		Klasse2 objektvonklasse2 = new Klasse2();
		objektvonklasse2.sagHallo();
	}
}

package demo;

public class Klasse2 {
	public void sagHallo(){
		System.out.println("Hallo Welt");
	}
}

 

[7123]

und wie bekomme ich Klasse 1 und Klasse 2 in das package demo :?:

 

[Leroy42]

und wie bekomme ich Klasse 1 und Klasse 2 in das package demo :?:

Genauso, wie gast es beschrieben hat.

Durch

package demo;

public class Klasse1 {
...
}

ist Klasse1 bereits in dem package demo!

 

[7123]

ok, das ist ja einfach müssen die beiden Dateien .class dann im selben ordner gespeichert werden oder ist das egal, bzw. muss man die in einen speziellen Ordner speichern?

 

[Gast]

Ein package wird physisch als Ordner realisiert.

 

[7123]

sry, ich habe noch eine Frage^^ Warum funktioniert der folgende befehl?

 public class Hallo {Hallo eins;}

Die Konstruktor ist ja default, aber warum kann man jetzt einfach in einer Klassendefinition Objekt des Typs Hallo erzeugen, obwohl nicht festgelegt ist, was ein Objekt Hallo eigentlich ist (da Hallo ja keine Daten enthält bzw. durch einen Kostruktor zugewiesen bekommt)

 

[SlaterB]

klar ist das Objekt festgelegt,
jeder compilierbare Code ist ein 'festgelegter' Code,

man kann Hallo-Objekte erzeugen,
dann ist eins darin leer oder kann von außen etwas zugewiesen bekommen,
diese Klasse kann also sogar echte Funktionalität übernehmen, z.B. zur Zählung:
wenn man die Zahl fünf darstellen will, verknüpft man einfach 5 Hallo-Objekte

es gibt übrigens auch Interface udn abstrakte Klassen, zu denen man keine Objekte erzeugen kann,
dennoch ist die Deklaration entsprechender Variablen erlaubt,
weil man Objekte von SubKlassen darin speichern kann

------


zum Hallo-Beispiel: man sollte aber darauf achten, nicht in einem Konstruktor ein weiteres Hallo-Objekt für die eins Variable zu erstellen -> Endlosschleife

 

[7123]

Achso, danke für die Erklärung, aber da du gerade Schnittstellen angesprochen hast, hab ich da auch gleich noch einmal eine Frag dazu^^: Was ist eigentlich der Vorteil einer Schnittstelle gegenüber einer Subklasse, klar man kann in der Schnittstelle feste Variblen definieren, aber das könnte man doch auch in der Subklasse und die Methoden die man in der Schnittstelle festlegt kann man doch auch einfach ohne die Schnittstelle in die Subklasse schreiben, man verpflichtet sich ja noch durch die Schnittstelle mehrere Methoden auszuführen, da bringt es auch nichts wenn man mehrer Schnittstellen implementiert, da man eh in der Subklasse noch einmal alle Methoden neu schreiben darf, also was ist der Vorteil einer Schnittstelle, hoffe jemand kann mir das noch einmal so gut erklären wie SlaterB

 

[FArt]

*Tüte Chips und Bier hol*

:bae:

Wird noch ein interessanter Thread, mal sehen wie lange das noch so geht... ich tippe auf 5 Seiten. Wer bietet mehr?

 

[diggaa1984]

mit ner schnittstelle versteckst du die eigenltiche Implementierung dieser vor dem Nutzer der Schnittstelle.
Somit kannst die selben Methoden auf versch. Realisierungen dieser Schnittstelle aufrufen, und somit kannst relativ einfach Klassen austauschen ohne grossartig im Code rumzuändern:

List<String> list1;

list1 = new ArrayList<String>(); //oder zB
list1 = new LinkedList<String>();

ohne nun zig Stellen im Code zu ändern wo du mit list1 arbeitest kannst einfach die jeweilige implementierende Klasse des Interfaces wechseln.

ich tippe auf 5 Seiten. Wer bietet mehr?

meeehr .. aber is schon richtig, Forensuche nutzen, findet man genug, und wenn das nich hilft wenigstens n neuen thread erstellen. Obwohl ersteres fruchten sollte

 

[7123]

hoffe nicht das es mehr als 5 seiten werden ; obwohl das Niveau der Fragen bisher nicht besser geworden ist, ich weiß , wie habt ihr das ganze Wissen eigentlich gelernt (nur über das Java Insel Buch?)

Also das mit der Schnittstelle und dem Vorteil hab ich noch nicht ganz verstanden, ich mache mal ein Beispiel:
z.b. eine Schnittstelle Liste mit der Methode Ausgabe:

public interface Liste
{public void Ausgabe};}

public class Beispiel implements Liste
{public void Ausgabe ()
{System.out.println("Ich verstehe das (noch) nicht")}
}

Hoffe der Code stimmt Also, die Klasse Beispiel würde ja auch ohne das interface funktionieren, aber wie meinst du das mit der implementierungändern, ich könnte doch z.b. noch eine zweite Klasse erstellen, welche auch die gleiche Methode hat, warum spare ich da Code ein?

 

[diggaa1984]

wie habt ihr das ganze Wissen eigentlich gelernt (nur über das Java Insel Buch?)

lesen, [fragen,] üben, verstehen

Bsp:

public interface Sortierer {
    public void sortiere(int[] liste);
}

*******************************

public class BubbleSort implements Sortierer {
    public void sortiere (int[] liste) {
        //BubbleSort-algorithmus
    }
}


public class Quicksort implements Sortierer {
    public void sortiere (int[] liste) {
        //Quicksort-algorithmus

    }
}

public class Mergesort implements Sortierer {
    public void sortiere (int[] liste) {
        //Mergesort-algorithmus
    }
}
******************************

public class Test {

    Sortierer sorter;
    int[] testdaten = {2,1,4,3,6,5,8,6,9,7};
 
    public Test() {
        sorter = new Bubblesort();
        sorter.sortiere(testdaten)
    }
} //nicht getestet

so wennu nun lieber Quicksort statt Bubblesort wöhlen willst, dann brauchst du nur im Kontruktor von Test statt Bubblesort Quicksort schreiben. uns alles andere wäre davon unberührt (sprich in dem fall der aufruf von "sortiere").

irgendwie deutlicher?


EDIT: les grad noch was anderes in deiner Frage
machen wir ma sowas:

public class MainClass {
    public static void main(String[] args) {
        Sortierer s = new Bubblesort();
        Test t = new Test(s);
    }
}

//edit Testclass

public class Test {
    private Sortierer sorter;
    int[] testdaten = {2,1,5,3,7,4,8,5,3,9};

    public Test(Sortierer s) {
        sorter = s;  
        sorter.sortiere(testdaten);
    }
}

somit kannst du mit nur einer änderung in der mainclass die genutzte implementierung ändern, ohne zusätzlich den Parameter im Konstruktor der Testklasse anzupassen an den neuen Typ.

Glaube das wars was du wolltest.

 

[FArt]

Das beste Beispiel ist das Collection Framework:

List, Map als Interface und die verschiedenen Implementierungen.

Ich muss ja schauen, dass der Thrad wächst... darf jetzt jeder, der eine Antwort schreibt die nächste Frage stellen oder wie sind die Regeln?

 

[7123]

ich glaube langsam verstehe ich das, aber noch einmal eine Frage zum Verständnis, wenn ich jetzt deinen Code ohne das Interface schreibe...

public class BubbleSort  { 
    public void sortiere (int[] liste) { 
        //BubbleSort-algorithmus 
} 


public class Quicksort  { 
    public void sortiere (int[] liste) { 
        //Quicksort-algorithmus 

} 

public class Mergesort  { 
    public void sortiere (int[] liste) { 
        //Mergesort-algorithmus 
} 

****************************** 

public class Test { 

    BubbleSort sorter; //Änderung 1
    int[] testdaten = {2,1,4,3,6,5,8,6,9,7}; 

    public Test() { 
        sorter = new Bubblesort(); //Änderung 2
        sorter.sortiere(testdaten) 
    } 
}

... müsste ich jedesmal 2 Zeilen ändern um die Methode einer anderen Klasse anzuwenden (siehe Änderung im Code), also hätte mir dieser Code nur den Vorteil gebracht das ich bei einer Änderung 1 Zeile weniger ändern müsste, richtig? (könnte bei Änderung 1 auch "Object sorter;" schreiben bei diesem Beispiel?)

 

[diggaa1984]

könnte bei Änderung 1 auch "Object sorter;" schreiben bei diesem Beispiel?

Können: JA ... Sollte: NEIN
du müsstest dein Object bei jeder Benutzung von "sorter" in den jeweiligen Sort casten.

Der eigentliche Nutzen des Interfaces wird im bsp ersichtlich was ich oben nach dem EDIT stehen hab.
so gesehen ist es hier nur eine Zeile ggü 2 Zeile beim andern Bsp. Allerdings musst du das ganze dann mal auf große Projekte projezieren. Im kleinen Rahmen kannst dir auch 5 einzelne Sortierer ohne interface schreiben, weil du musst ja nur 2 Zeilen ändern, aber im großen komplexen Programm machst du das nicht mehr freiwillig ^^

 

[7123]

ok, alles klar danke für die Erklärung, im größeren Rahmen ergibt das Sinn, aber auf den ersten Blick wird der Sinn des Interface nicht so deutlich. So jetzt muss ich mir noch ein paar Fragen einfallen lassen, damit die 5 Seiten noch erreicht werden

 

[diggaa1984]

lol dann mach bitte einer vorher den thread zu
weil thema is ja nu schon längst verfehlt ^^

 

[7123]

einfachste Grundlagen stimmt ja noch, vielleicht stelle ich ja eine Frage zu Threads demnächst^^

 

[7123]

mir ist noch etwas eingfallen

noch einmal zum Beispiel von oben:

public class Hallo {
int Zahl
Hallo Eins;
public Hallo (int Zahl){
this.Zahl = Zahl;}
}

****************************

public class HalloBezug{
public static void main (String [] args){
Hallo Zwei, Drei;
Drei = new Hallo(0);
Zwei = new Hallo(1);
Drei.Eins = Zwei;  // unklar
Drei = Zwei;}}

Ok, also in diesem Programm werden 2 Hallo Objekte in der main erzeugt, soweit klar. Jedoch verstehe ich den Befehl

 Drei.Eins = Zwei // oder Drei.Eins.Eins = Zwei sofern das auch funktioniert

nicht, ich dachte immer man kann nur Methoden so Schreiben, also "Instanzvariable.Methode". Warum funktioniert aber auch "Instanzvariable.Instanzvariable des Objektes" und was bewirkt dieser Ausdruck genau? Denn es wird ja das Hallo Objekt mit der Variable 1 irgendetwas zugeordnet, hoffe jemand kann mir das noch einmal genau erklären

 

[diggaa1984]

sofern du "this.Zahl" verstehst, solltest du auch Drei.Eins verstehen, ist nix anderes. Bedingung ist nur das "Eins" public deklariert ist damit man von aussen drauf zugreifen kann.

 

[7123]

also this.Zahl heißt ja das sich Zahl auf die Variable Zahl, in der Klasse bezieht, dachte ich zumindest also wird Zwei, dem Eins aus der Klasse Hallo zugeordnet?

 

[Guest]

also this.Zahl heißt ja das sich Zahl auf die Variable Zahl, in der Klasse bezieht, dachte ich zumindest also wird Zwei, dem Eins aus der Klasse Hallo zugeordnet?

ja

 

[diggaa1984]

also wird Zwei, dem Eins aus der Klasse Hallo zugeordnet?

public class Hallo {
int Zahl
Hallo Eins;
public Hallo (int Zahl){
this.Zahl = Zahl;}
}

****************************

public class HalloBezug{
public static void main (String [] args){
Hallo Zwei, Drei;
Drei = new Hallo(0); //Drei.Zahl = 0
Zwei = new Hallo(1); //Zwei.Zahl = 1
Drei.Eins = Zwei;  // Drei.Eins.Zahl = 1
Drei = Zwei;}} //Drei.Zahl = 1

 

[7123]

Also kann man die Variablen einer Klasse solange diese public ist auch andere Zahlen zuordnen ohne ein neues Hallo Objekt erzeugen zu müssen, aber wem wird hier die 1 zugeordnet, der Variablen Eins und der Variable Zahl in der Klasse Hallo?

  Drei.Eins.Zahl = 1

oder ist das das gleiche wie

  Drei.Zahl = 1

?