wie kann ich eine Schleife pausieren, bis ein Jbutton gedrückt wird ?

[Vilkazzz]

Hallo,

ich habe eine Schleife, die 12 male abgerufen sein soll.

jedes mal wir eine andere Frage gestellt, auf die man mit Hilfe von denselben 4 Buttons antworten kann (welche Jahreszeit zu welchem Monat passt, mache ein Lernspiel für mein Sohn)

nun, vereinfacht sieht mein code so aus

for (i=1;1<=12;i++) {

JLabel question = new JLabel("zu welcher Jahreszeit gehört"+month[(chosenMonat[runde])].name);

// dies ist der Grund für meine Schleife, der month[i].name kriegt jedes mal
// einen anderen von den 12 //Monaten ausgesucht, ohne das ein Monat doppelt vorkommt.

JButton button1= new JButton("Winter"); 
JButton button2= new JButton("Frühling"); 
JButton button3= new JButton("Sommer"); 
JButton button4= new JButton("Herbst"); 
}

natürlich kriegt jedes Button eigenen setBounds(); usw,
ich wollte nur das Prinzyp erklären.

nun macht die Schleife natürlich kein halt und ballert 12 male durch, klar.

ich will aber dass jedes mal gewartet wird bis ein Button geklickt wird (egal welches)
dann passieren ein par Aktionen und die Schleife darf um ein Schritt weiter.

google hat mir zum action listener geraten wenn die Schleife anhalten und auf Jbutton Klick
warten soll.

ich habe also extra ein neuen button in die Schleife eingefügt (copypaste aus dem internet).

JButton buttonx = new JButton("This is a button!");    //Add action listener to button
					buttonx.setBounds(350, 300, 150, 50);
					Newframe.getContentPane().add(buttonx);
					buttonx.addActionListener(new ActionListener() {
				    public void actionPerformed(ActionEvent e)
				    {
				        //Execute when button is pressed
				        System.out.println("You clicked the button");
				    }
				 });

die Schleife wird trotzdem nicht unterbunden und läuft 12 male durch.

Aus alten Zeiten kenne ich solche Befehle wie "waitUntilKeypressed", sowas gibt's wohl nicht in java ?

soll ich das ganze völlig anders angehen ?

ich könnte ja die ganze Frame neu mit veränderten Werten starten nach jedem Button klick,
aber hoffe es geht auch elleganter.

So, und jetzt gehe ich googeln wie man JLabel wert löscht, damit bei mir nicht alle 12 monate
auf den selben Fleck überschrieben werden und hoffe auf Hilfe von Euch

wenn ich meine Frage unklar gestellt habe, so bitte ich um Hinweis was noch fehlt.

mfg

Vilkazzz

 

[Adelhorst]

Hallo.
Das funktioniert so nicht.
Am besten so:
Über einen Button "Spielbeginn" startest du das Spiel, sprich es wird eine Methode ("spielstart") aufgerufen, wo eine Integer-Variable (=Variable innerhalb der Klasse) für den Monat auf 1 gesetzt wird und du gibst in dem Label deinen Fragetext aus. Fertig.
Dann wird über die vier Button-Listener eine Methode aufgerufen (z.B. "antwortcheck('intButtonID')"), der als Parameter übermittelt wird welcher Button gedrückt worden ist.
In dieser Methode kannst du Erfolg/Misserfolg auswerten und ausgeben, und ggfls eine neue Frage über den nächsten Monat ausgeben.

 

[fischefr]

Wenn du den Ansatz von dir weiter verfolgen möchtest, müsstest du zwangsläufig mit mehreren Threads arbeiten und diese entsprechend synchronisieren. Das übersteigt aber deinen aktuellen Kenntnisstand um längen vermute ich. Falls du dich trotzdem damit beschäftigen möchtest:
Java notify() and wait() examples

Grundidee: deine Schleife wird in einem separaten Thread ausgeführt. Im anderen Thread läuft die GUI. Dein eigener Thread wartet, bis der GUI-Thread (fachlich korrekt: AWT-Dispatcher-Thread) beim betätigen der Schaltfläche den Monitor (d.h. das Objekt, auf das gelockt wird) freigibt.

Deutlich einfacherer Ansatz (- Empfehlung! -):

ActionListener ist schon mal ein guter Ansatz. Initialisier den Dialog mit der 1. Frage und wechsle als Reaktion auf das Drücken der Schaltfläche (d.h. in der Methode actionPerformed) zur jeweils nächsten Frage. Das ist die einfachste Lösung.

Der 2. Ansatz entspricht dem von Adelhorst, ich war zu dem Zeitpunkt aber bereits am tippen ;-)

 

[kaoZ]

for (i=1;1<=12;i++)

was ist das für eine Schleifendeklaration ^^ ?

for(int i = 1; i <= 12; i++){...}

Siehst du den fehler den du gemacht hast ?

Wenn du JButtons per Schleife beschriften möchtest mach das so :

String[] label = {"Button1","Button2","Button3"};
		
JButton[] btns = new JButton[3];
		
for (int i = 0; i < btns.length; i++) {
	btns[i] = new JButton(label[i]);
}

du kannst in diesem Schritt auch gleich die Listener setzen, und auch die Bounds für die einzelnen Buttons :

String[] label = {"Button1","Button2","Button3"};
		
JButton[] btns = new JButton[3];
		
for (int i = 0; i < btns.length; i++) {
	btns[i] = new JButton(label[i]);
	btns[i].addActionListener(this);
}

an die einzelnen Buttons kommst du dann über den index

String input = btns[2].getText();

oder du schreibst dir eine methode für den von dir gewünschten anwendungsfall.

ich würde die Buttons je nach Frage einfach den state der Buttons verändern..

aber so ganz weiß ich nicht wo dein Konkretes Problem liegt, ich würde die Buttons definitiv außerhalb des Gameloops erstellen.

 

[Vilkazzz]

hallo,

vielen dank für alle schnelle Antworten !

dann bau ich halt eine überprüf Methode und rufe die auf,
dies scheint die optimale Lösung zu sein,
das Synchronisieren von 2 Threats lasse ich mir als Übung für ... kommende Woche oder so
noch brauch ich es nicht wirklich

und KaoZ, dass kommt von schnellen Fingern und nicht copypaste benutzen

1ch hab den Fehler natürl1ch bemerkt

ich liebe ja arrays und werde dein Vorschlag wo anders gebrauchen !
(und zwar um alte Fragen zu löschen befor ich, JLabel="" wird mein Freund sein

Da die 4 Knöpfe ja das einzige Konstante hier ist (Jahreszeiten halt),
die können gleich bleiben.

Also grob muss ich da ganze Verfahren wohl so machen.

Frame erzeugen mit 4 konstanten Jbuttons, 
Label[] frageFeld = new JLabel[12]

zu jedem button muss ich dan einen ActionListener einbauen,
(da kann ich hoffentlich eifach sowas schreiben

 Boolean abfrage = button.getText.equals(month[i].jahreszeit)

(beides sind ja Strings)

danach wohl

IF (abfrage){
      Alte Frage löschen ;
       i++;
       neue Frage  Stellen;
}
else Fehler++;

thx für den mentalen Input !


p.s. wegen deines Edits KaoZ = meine Denkweise ist noch sehr von basic/turbopascal/Qbasic geprägt,
daher gehe ich einfach grundsächlisch mit falscher Vorgehensweise an Java an.

 

[turtle]

Ich möchte da noch etwas theoretischen Unterbau liefern, damit du weisst, warum es keine waitUntilKeypressed in der GUI gibt.

Grafische Oberflächen wie Swing oder JavaFX arbeiten Event-getrieben.

Das bedeutet eigentlich wartet dein Programm "nur" auf Ereignisse (events).#

Dieses kann beispielsweise das Klicken eines Buttons oder die Eingabe von Text in einem Textfeld sein. Oft generiert das System selbständig Events und liefert diese an dein Programm, damit du darauf reagieren kannst. Zu letzteren gehört beispielsweise der Neu-zeichnen-Event, wenn zum Beispiel ein Fenster verschoben wird und nun mehr Teile der GUI von deinem Programm sichtbar werden.

Also ist klar, das du, wenn du "irgendetwas" machen möchtest, nur auf Reaktion von Events machen kannst. Und es ist auch klar, warum es kein waitUntilKeypressed geben kann, denn deine GUI ist ja ständig sichtbar und muss darauf reagieren, das Fenster über der GUI geschoben werden und da kann das Programm ja nicht warten und nix tun.

Auf Events reagieren kannst du, indem du Listener für ein Event registrierst. Diese werden automatisch aufgerufen, wenn der Event auftritt und an dein Programm/Listener weitergeleitet wird.

Somit sollte klar sein, das die Erstellung von 12-Fragen/Antworten wenig Sinn macht. Viel besser und das haben meine Vorredner richtig vorgeschlagen, ist es, den Wechsel von einer Frage zur nächsten (bis zur Höchstzahl 12) als Event auf einen Button-Klick zu realisieren. Repräsentiert der Button-Kick die falsche Antwort gibst du wohl einen Hinweistext aus, bei richtiger Antwort wechselt der Action-Listener des Buttons auf die nächste Frage.

Ich hoffe ich habe es verständlich ausgedrückt.

 

[Vilkazzz]

danke Turtle !

hast ohne es zu wissen auf meine folgende Frage beantwortet:

"ich hab eine jlabel der die Fehlversuche anzeigt, soll ich den Frame mit veränderden Variabeln sich neu rekursiv aufrufen lassen bei einer falschen Antwort damit die Anzeige aktualisiert wird ?"

wenn ich dich richtig verstanden habe, wird es nicht nötig sein,
sobald etwas passiert, wird alles in Jframe von alleine aktualisiert.

Kompliment an den Forum hier, ich werde euch wohl noch öffters belästigen bis ich mich in Java einarbeite, sry dafür feif:

 

[turtle]

wird alles in Jframe von alleine aktualisiert.

Ja, genau, aber...

Ich sehe immer wieder Code, wo eine Klasse von JFrame erbt. Das ist Blödsinn und du solltest SO nicht anfangen

Das übliche Vorgehen ist ein JFrame zu erzeugen und diesem ein JPanel (deine Oberfäche) hinzufügen. Das standardisierte Bauen einer Swing-GUI sieht also so aus:

public class DeineGUI extends JPanel {
	public static void main(String[] args) {
		JFrame frame = new JFrame("Turtle");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.add(new DeineGUI());
		frame.pack();
		frame.setVisible(true);
	}
}

 

[fischefr]

Wenn dir schon Klassen, die von JFrame ableiten nicht gefallen, solltest du gleich noch darauf hinweisen, dass die main-Methode in der von JPanel abgeleiteten Klasse auch keinen Schönheitspreis gewinnt. Mach dafür eine eigene Klasse.

Grundüberlegung beim Ableiten von JPanel:

Packt man das JPanel in ein JFrame, bekommt man ein Fenster
Packt man das JPanel in JApplet, hast du ein Applet (Anwendung im Browser)
...
u.s.w, du bist also flexibel für spätere Erweiterungen und Änderungen

 

[Vilkazzz]

hab minimal gegoogelt und erstmals den Oberen Teil der Frage in diesem Post bereits gelöscht

ich hab halt einfach den windowsBuilder für eclipse instaliert, und dort versucht die erzeugten Befehle in eigene Klassen zu kopieren, um die zu verstehen.

So wie ich es verstehe, ist JFrame sowas wie der Rahmen, und Panel wäre etwas wie eine Folie, die AUF dem Rahmen liegt, und besser zur Bearbeitung sich eignet ?

das würde einiges erklären, denn zb hab ich die ersten male ganze Frames neu gebaut um
neue Anzeigen zu bekommen.

Es kommt ja dann fast "Datei schliessen, neue Datei mit Werten so und so aufmachen" gleich, oder ?

Dan ziehe ich mir erstmalls ein Tutorial zum JPanel rein, danke Turtle und fischefr.

Wenn es noch sachen gibts, die man von Anfang an sich NICHT angewöhnen sollte, nur her mit dem Wissen

 

[Anti-Banane]

ja, da gibts noch was : sei generell sparsam mit vererbung

extends JFrame ist defintiv ein absolutes NO-GO und mir persönlich fällt nicht mal auch nur ein anwendungsfall ein wo es sinn machen würde

extends JPanel ist aber auch nicht wirklich toll

du musst dir immer vor augen halten das "B extends A" eine "B ist ein A" beziehung bedeutet, was aber gerade bei "normalen" GUIs völlig falsch ist

was genau willst du denn machen .. ziehen wir es doch ruhig mal auseinander

du willst eine oberfläche in der eine frage steht (JLabel), 4 buttons zum antworten (JButton) und einen fail-counter (ebenfalls wieder JLabel)
ergo : du musst von überhaupt nichts erben sondern einfach nur vorhandene sachen nehmen und zusammen bauen

du hast schon was von windowbuilder gesagt ... klar ... kann man machen wenns mal schnell quick'n'dirty werden soll ... was es mir jetzt etwas erschwert dir das ganze low-level zu erklären


was passiert wenn du extends JPanel nutzen würdest : du sagst damit das deine neue eigene klasse ein sub-typ von JPanel ist ... oder wenn wir es von "oben" betrachten : deine klasse ist letzten endes ein JPanel ... mit dem du dann genau WAS machen willst ?
das erben von JPanel macht nur dann sinn wenn du seine funktionsweise änderst oder erweitern willst


warum extends JPanel schlecht ist : lass mich das ganze mal etwas plastischer darstellen

stell dir einfach mal ne wand vor ... so 10 x 3 meter beton
wenn du dieses "grundgerüst Wand" erweitern würdest ... also "extends Wand" dann macht das nur sinn wenn du wie gesagt die wand an sich selbst verändert willst ... z.b. weil du die maße ändern willst ... oder fenster / türen drin ... etc

willst du mit der wand aber ein haus bauen und lässt erstmal die wand nur ne wand sein ... dann brauchst du nicht von ihr erben ... dir also keine "eigene wand zusammenbauen" ... sondern nimmst einfach eine fertige wand X

übertragen auf die GUI : du willst nichts an der wand selbst verändern ... sondern nimmst sie nur als eine grundfläche um eben darauf (treffender weise passt das sogar mit swing) zu zeichnen



welches leider sub-optimale beispiel dir gebracht wurde : extends JPanel
was sinnvoller ist (und was mit sicherheit dein windowbuilder auch so machen wird) : du erstellst dir einfach ein objekt von JPanel ... also [c]JPanel meinPanel = new JPanel()[/c] und nutzt dieses dann um deine GUI zu bauen .. also um entsprechend weitere elemente DARAUF zu platzieren ... das geht dann mit [c]meinPanel.add(button/label/etc);[/c]


um das ganze mal in ein kurzes code-stück zu giesen



extends JPanel (in diesem fall zwar nicht unbedingt falsch, aber ziemlich unschön / sub-optimal)

public class MeinPanel extends JPanel
{
	public MeinPanel()
	{
		super();
		this.add(label);
		this.add(button1...4);
		this.add(noch irgendwas);
	}
}

instanz von JPanel

public class MeinSpiel
{
	//...
	JPanel panel=new JPanel();
	panel.add(label);
	panel.add(button1...4);
	panel.add(XXX);
}

es ist schade das hier mal wieder viele gute ideen hatten ... aber scheinbar alle zusammen nur über ziemlich schlechtes halbwissen verfügen



ich wiederhole es gerne noch mal in form eines merksatzes (für ALLE ... nicht nur TO ... da hier scheinbar einige die gute posts geliefert haben selbst noch was lernen müssen) :

Nutze "extends" nur dann wenn du die innere Funktion einer Super-Klasse verändern oder erweitern willst. Niemals wenn du sie nutzen willst !

 

[turtle]

@Anti-Banane

Also, mir schwillt der Kamm wenn ich deine arroganten und anmassenden Kommentare lese, die nahelegen, das nur du im Besitz der allumfassenden Wahrheit bist.
Ich rate dir, sachlicher auf Anfragen im Forum zu reagieren und beleidigende Angriffe zu lassen.

Aber zum Thema:

Leider liest sich dein Betonwand Beispiel ganz schön hat aber wenig mit GUIs zu tun. Wir sind auf einer Wellenlänge, das das Erben von JFrame schlecht ist. Das Erben von JPanel aber findest du auch schlecht und deine Gründe finde ich nicht passend.

Denn in der Tat B (extends JPanel) ist-ein JPanel und kann überall als solches verwendet werden.

Und es wird auch das Aussehen der "Wand" und das Verhalten geändert, weil Widgets auf der Wand platziert werden und über Listener mit Code verdrahtet werden. Und um diesen Zusammenschluss als Einheit (Objekt) behandeln zu können, bietet sich an, das per "extends JPanel" auch auszudrücken. Denn somit ist das keine Wand mehr, sondern meine Wand, die sich von der "Grundwand" unterscheidet, weil beispielsweise ein JButton (Tür) drauf ist,den man klicken kann, worauf eine weitere Wand erscheint. Das ist Vererbung.
Dies hat IMHO folgende Vorteile

• Reusability - Die Komponente kann leicht in andere (Teil)-Applikationen wieder verwendet werden.
• Encapsulation - Die Komponente ist gekapselt und benötigt keine externen Abhängigkeiten. Dies erhöht auch die Testbarkeit.
• Maintainability - Es wird einfach, Code mit der Klasse zu refactoren, da die Klasse "self-contained" ist.

Ich finde, das ein extends JPanel gut dem SRP-Prinzip folgt, eine starke Kohäsion besitzt und lose gekoppelt sind. Dies sind GUTE Dinge beim Design, die angestrebt werden sollten.

Wenn du auf Code-Ebene runterbrichst, sieht dein Vorschlag so aus

       JButton button = new JButton("Hello");
        JLabel labelOne = new JLabel("Hello");
        JLabel labelTwo = new JLabel("Bye");

        MyJPanel testPanel = new MyJPanel();
        testPanel.add(button);
        testPanel.add(labelOne);
        testPanel.add(labelTwo);

während eine Klasse die extends JPanel ist,

public MyJPanel() {

    JButton button = new JButton("Hello");
    JLabel labelOne = new JLabel("Hello");
    JLabel labelTwo = new JLabel("Bye");

    add(button);
    add(labelOne);
    add(labelTwo);
}

Und da ist es schon mehr "Geschmackssache", welche Version "besser" ist.

 

[Vilkazzz]

@Anti-Banane danke für früh am Morgen Lektur !

habe mir gestern noch ein Tutorial zu jlabel reingezogen.

Was das Vererben angeht kann ich dich beruhigen, solange ich keine eigene Methode einer "super" class
einfügen will, mache ich es nicht.

//Edit och, erstmals Turtles Post verdauern und Verstehen

das extend würde ich evtl dann nehmen, wenn ich in den jlabel eine Methode einbauen will,
die zb die getText felder von verschiedenen elementen im gleichem jlabel vergleicht.

kann ich aber auch mit einer extra dafür geschriebener Klasse z.B. "checkAntworten(String button1.getText(); String month.name) " machen.

WindowsBuilder dient bei mir auch nur als schnelleres google für Befehle.

Ich hab ein "experimenten" Folder, dort erstelle ich die Elemente die ich brauche, schau mir die Gramatik davon an
(label, radiobutton, usw) und schreibe dann den Code per Hand in mein "haupt" Program.

Aus meiner Kindheit weiss ich, dass ich so am besten eine Programiersprache verinnerliche,
indem ich einfach den Kode verändere und gucke wie das Endergebniss sich verändert.

(mit jede menge sysouts dazwischen )

meine Frage zu jlabels die ich wahrscheinlich selber innerhalb der nächster stunde lösen werde ...
, kann ich mehrere verschiedene Jlabel objekte gleichzeitig anzeigen lassen ?

oder mehrere Frames ?

(für mein Monat Frage Spiel ist es irrelewant, das Ding ist aber auch mehr "lerne zu gehen in Java" für mich.

Ich will mir nacher eine einfache Bürosoftware programieren,
und einfach wenn ich dort z.B. meine Firmendaten verändern will,
muss einfach ein neues Popup auftauchen mit "Optionen"
aber das Hauptframe muss im Hintergrund weiter laufen.

würde auch gerne ein permanentes Menu haben, und ein "inhaltsfenster" welches sich verändert,
jenachdem welches menu Item angeklickt wurde.

Daher würden sich min 2 objekte ideal dafür eignen.

hab es noch nicht gegoogelt und verstöhe hiermit gegen die Forumregeln verdammt.

sry dafür, aber ihr seid selber Schuld, Ihr alle, mit eurer Hilfsbereitschaf ^^

 

[turtle]

ihr seid selber Schuld, Ihr alle, mit eurer Hilfsbereitschaft

kann ich mehrere verschiedene Jlabel objekte gleichzeitig anzeigen lassen ?

Klar, das ist ja Aufgabe eines JPanels, als Container für andere Elemente zu dienen

oder mehrere Frames ?

Das sehe ich nun wieder kritischer. Ein JFrame ist ein Top-level-container und repräsentiert "normalerweise" eine gesamte Applikation. Daher macht es wenig Sinn, mehrere JFrames zu haben.

In Windows gibt es das sogenannte Mulltiple document interface (MDI). Da können in einer Applikation mehrere Instanzen von Dokumenten geöffnet/bearbeitet werden, z.B. Word-Dokumente. Abgesehen davon, das von MDI abgeraten wird, kann dies in Java mit JInternalFrame umgesetzt werden.

 

[Vilkazzz]

ok, also mach ich es mit jpanels und nicht mit mehreren Frames.

hab grade Spielprogramierung tutorial für 2d Spiel hier im forum gefunden,
dort finde ich gewiss ausführliche Einführung in mehrere Objekte auf dem Bildschirm gleichzeitig

 

[Anti-Banane]

@turtle

ERNSTHAFT ?
alter ... DU kotzt mich an .. erst s*****e labern ... sich dann drüber aufregen das man korrigiert wurde ... und dann noch mehr bullshit von sich geben


ich wiederhole es noch ein mal : wenn man ein JPanel lediglich nutzen will um halt seine GUI darauf zu platzieren ist ein erben schlicht FALSCH !

warum sollte es sinnvoll sein ? was macht es für ein sinn den konstruktor voll zu krachen mit dem was man eigentlich korrekt von außen über die setter regelt ?



aber is ok ... wenn du der meinung bist deine ... und ja , sorry , in dem fall ist es scheinbar nicht mal mehr nur noch "halbwissen" ... sondern scheinbar auf grund deiner ignoranz komplette unwissenheit ... an anfänger weitergeben zu müssen und dich dann doch selbst als was besseres dar zu stellen nur weil mal jemand zeigt das auch deine antwort leider nicht ganz so optimal ist ... dann solltest DU vielleicht mal einen blick hier rein werfen : Trail: Creating a GUI With JFC/Swing (The Java™ Tutorials)

nenn mir mal auch nur EINE stelle an der dort auf extends verwiesen wird ?

übrigens : schon mal was von composition over inheritance gehört ? ... scheinbar nicht ...

 

[kaoZ]

machen wir uns doch nichts vor , es ist an und für sich einfach der bequemere Weg.......

man könnte genau so gut einfach eine Referenz auf einen JPanel (Container) halten und sich dann per getter den Container liefern lassen.....

es ist aber "unbequemer" als einfach abzuleiten , auch wenn es nicht der standardisierte weg ist, und man Komposition der Vererbung vorziehen soll.........

Vererbung macht nach Konvention nur da Sinn wo ich auch "wirklich" Spezialisiere.... bzw. Verhalten hinzufüge, und das ist halt in den seltensten Anwendungsgebieten der Fall.....

 

[turtle]

nenn mir mal auch nur EINE stelle an der dort auf extends verwiesen wird ?

Creating the Demo Application (Step 2) (The Java™ Tutorials > Creating a GUI With JFC/Swing > Performing Custom Painting)