JavaFX Timer wird nicht angetriggert...

[Java-Entdecker]

Guten Tag liebe Java-Gemeinde,

ich hänge aktuell an einer Aufgabe fest und wollte hier gerne Hilfe ersuchen....

Ich soll ein Memory-Spiel modifizieren.
in der 1. Aufgabe heißt es, dass ich vor dem Beenden des Programms anzeigen soll wer der Gewinner ist...
und das Beenden des Programms erst nach einer gewissen zeit auftreten soll.

Ich habe aktuell das antriggern des Timers noch nicht ganz durchblickt wie es aussieht...
kann mir einer erklären warum der Timer für 10 Sekunden nicht ausgeführt wird?
Habe ich eine Verknüpfung oder der gleichen im Timerhandler vergessen?

Ich bin sehr dankbar für jede Aussage...

hier einmal der aktuelle Code der Klasse.

package de.fernschulen;


//für die Klassen Arrays und Collections
import java.util.Arrays;
import java.util.Collections;

import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.Label;
import javafx.scene.layout.FlowPane;
import javafx.scene.layout.GridPane;
import javafx.util.Duration;

public class MemoryFeld {
    //eine innere Klasse für den Eventhandler des Timer
    class TimerHandler implements EventHandler<ActionEvent> {
            @Override
            //die Methode ruft die Methode karteSchliessen() auf
            public void handle(ActionEvent arg0) {
                karteSchliessen();
            }
        }

    //das Array für die Karten
    private MemoryKarte[] karten;
    
    //das Array für die Namen der Grafiken
    private String[] bilder = {"grafiken/apfel.jpg", "grafiken/birne.jpg", "grafiken/blume.jpg", "grafiken/blume2.jpg",
            "grafiken/ente.jpg", "grafiken/fisch.jpg", "grafiken/fuchs.jpg", "grafiken/igel.jpg",
            "grafiken/kaenguruh.jpg", "grafiken/katze.jpg", "grafiken/kuh.jpg", "grafiken/maus1.jpg",
            "grafiken/maus2.jpg", "grafiken/maus3.jpg", "grafiken/melone.jpg", "grafiken/pilz.jpg",
            "grafiken/ronny.jpg", "grafiken/schmetterling.jpg","grafiken/sonne.jpg",
            "grafiken/wolke.jpg", "grafiken/maus4.jpg"};
    
    //für die Punkte
    private int menschPunkte, computerPunkte;
    
    //zwei Labels für die Punkte
    private Label menschPunkteLabel, computerPunkteLabel, sieger;
    
    //wie viele Karten sind aktuell umgedreht?
    private int umgedrehteKarten;
    
    //für das aktuell umdrehte Paar
    private MemoryKarte[] paar;
    
    //für den aktuellen Spieler
    private int spieler;
    
    //das "Gedächtnis" für den Computer
    //er speichert hier wo das Gegenstück liegt
    private int[][] gemerkteKarten;

    //für die Spielstärke
    private int spielstaerke;

    //für den Timer
    private Timeline timer;

    //der Konstruktor
    public MemoryFeld() {
        //das Array für die Karten erstellen, insgesamt 42 Stück
        karten = new MemoryKarte[42];

        //für das Paar
        paar = new MemoryKarte[2];

        //für das Gedächtnis
        //es speichert für jede Karte paarweise die Position im Spielfeld
        gemerkteKarten = new int[2][21];
        
        //keiner hat zu Beginn einen Punkt
        menschPunkte = 0;
        computerPunkte = 0;
        
        //es ist keine Karte umgedreht
        umgedrehteKarten = 0;
        
        //der Mensch fängt an
        spieler = 0;
        
        //die Spielstärke ist 10
        spielstaerke = 0;
        
        //es gibt keine gemerkten Karten
        for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++)
                gemerkteKarten[aussen][innen] = -1;
    }

    //die Methode erstellt die Oberfläche und zeichnet die Karten über eine eigene Methode
    //übergeben wird ein FlowPane
    public FlowPane initGUI(FlowPane feld) {
        //für die Ausgaben
        kartenZeichnen(feld);
        menschPunkteLabel = new Label();
        computerPunkteLabel = new Label();
        menschPunkteLabel.setText(Integer.toString(menschPunkte));
        computerPunkteLabel.setText(Integer.toString(computerPunkte));
//***************************************Aufgabe1***************************************
        sieger = new Label();
        sieger.setText("");
//***************************************Aufgabe1***************************************
        
        //in zwei Spalten anzeigen
        GridPane tempGrid = new GridPane();
        //und einfügen, dabei werden die Koordinaten angegeben
        tempGrid.add(new Label("Mensch: "), 0 , 0 );
        tempGrid.add(menschPunkteLabel, 1, 0);
        tempGrid.add(new Label("Computer: "), 0, 1);
        tempGrid.add(computerPunkteLabel, 1 ,1);
//***************************************Aufgabe1***************************************
        tempGrid.add(new Label("Sieger: "), 0, 2);
        tempGrid.add(sieger, 1 ,2);
//***************************************Aufgabe1***************************************
        feld.getChildren().add(tempGrid);
        return feld;
    }
    
    //das eigentliche Spielfeld erstellen
    private void kartenZeichnen(FlowPane feld) {
        int count = 0;
        for (int i = 0; i <= 41; i++) {
            //eine neue Karte erzeugen
            karten[i] = new MemoryKarte(bilder[count], count, this);
            //bei jeder zweiten Karte kommt auch ein neues Bild
            if ((i + 1) % 2 == 0)
                count++;
        }
        //die Karten werden gemischt
        Collections.shuffle(Arrays.asList(karten));

        //und ins Spielfeld gesetzt
        for (int i = 0; i <= 41; i++) {
            feld.getChildren().add(karten[i]);
            //die Position der Karte setzen
            karten[i].setBildPos(i);
        }
    }
    
    //die Methode übernimmt die wesentliche Steuerung des Spiels
    //Sie wird beim Anklicken einer Karte ausgeführt
    public void karteOeffnen(MemoryKarte karte) {
        //zum Zwischenspeichern der ID und der Position
        int kartenID, kartenPos;

        //die Karten zwischenspeichern
        paar[umgedrehteKarten]=karte;
        
        //die ID und die Position beschaffen
        kartenID = karte.getBildID();
        kartenPos = karte.getBildPos();
        
        //die Karte in das Gedächtnis des Computers eintragen
        //aber nur dann, wenn es noch keinen Eintrag an der entsprechenden Stelle gibt
        if ((gemerkteKarten[0][kartenID] == -1))
            gemerkteKarten[0][kartenID] = kartenPos;
        else
            //wenn es schon einen Eintrag gibt
            //und der nicht mit der aktuellen Position übereinstimmt, dann haben wir die
            //zweite Karte gefunden
            //die wird dann in die zweite Dimension eingetragen
            if (gemerkteKarten[0][kartenID] != kartenPos)
                gemerkteKarten[1][kartenID] = kartenPos;
        //umgedrehte Karten erhöhen
        umgedrehteKarten++;
        
        //sind zwei Karten umgedreht worden?
        if (umgedrehteKarten == 2) {
            //dann prüfen wir, ob es ein Paar ist
            paarPruefen(kartenID);
            //den Timer erzeugen
            timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerHandler()));
            //und starten
            timer.play();
        }
        //haben wir zusammen 21 Paare, dann ist das Spiel vorbei
        if (computerPunkte + menschPunkte == 21) {
//***************************************Aufgabe1***************************************
            //Variable vereinbaren für die Anzeige des Siegers
//            String sieger;
            //prüfen ob der Mensch mehr Punkte hat.
            //Falls ja hat er gewonnen und wenn nicht hat der Computer gewonnen.
            if (menschPunkte > computerPunkte) {
                this.sieger.setText("Der Mensch hat gewonnen");
//                sieger = "Mensch";
            } else {
                this.sieger.setText("Der Computer hat gewonnen");
//                sieger = "Computer";
            }
            
/**            //den Dialog erzeugen
            Alert meinDialog = new Alert(AlertType.INFORMATION,"Der " + sieger + " hat gesiegt!");
            //den Text setzen
            meinDialog.setHeaderText("Herzlichen Glückwunsch!");
            //den Titel setzen
            meinDialog.setTitle("Gewinner");
            //den Dialog anzeigen
            meinDialog.show(); **/
        
            //den Timer erzeugen um das Ende für 10 Sekunden hinaus zuzögern.
            timer = new Timeline(new KeyFrame(Duration.seconds(10), new TimerHandler()));
            //und starten
            timer.play();
//***************************************Aufgabe1***************************************
            //wir beenden es hier direkt
            Platform.exit();
        }
    }
    
    //die Methode dreht die Karten wieder auf die Rückseite
    //bzw. nimmt sie aus dem Spiel
    private void karteSchliessen() {
        boolean raus = false;
        //ist es ein Paar?
        if (paar[0].getBildID() == paar[1].getBildID())
            raus = true;
        //wenn es ein Paar war, nehmen wir die Karten aus dem Spiel
        //sonst drehen wir sie nur wieder um
        paar[0].rueckseiteZeigen(raus);
        paar[1].rueckseiteZeigen(raus);
        //es ist keine Karte mehr geöffnet
        umgedrehteKarten = 0;
        //hat der Spieler kein Paar gefunden?
        if (raus == false)
            //dann wird der Spieler gewechselt
            spielerWechseln();
        else
            //hat der Computer ein Paar gefunden?
            //dann ist er noch einmal an der Reihe
            if (spieler == 1)
                computerZug();
    }
    
    //die Methode prüft, ob ein Paar gefunden wurde
    private void paarPruefen(int kartenID) {
        if (paar[0].getBildID() == paar[1].getBildID()) {
            //die Punkte setzen
            paarGefunden();
            //die Karten aus dem Gedächtnis löschen
            gemerkteKarten[0][kartenID]=-2;
            gemerkteKarten[1][kartenID]=-2;
        }
    }

    //die Methode setzt die Punkte, wenn ein Paar gefunden wurde
    private void paarGefunden() {
        //spielt gerade der Mensch?
        if (spieler == 0) {
            menschPunkte++;
            menschPunkteLabel.setText(Integer.toString(menschPunkte));
        }
        else {
            computerPunkte++;
            computerPunkteLabel.setText(Integer.toString(computerPunkte));
        }
    }
    
    //die Methode wechselt den Spieler
    private void spielerWechseln() {
        //wenn der Mensch an der Reihe war,
        //kommt jetzt der Computer
        if (spieler == 0) {
            spieler = 1;
            computerZug();
        }
        else
            spieler = 0;
    }
    
    //die Methode setzt die Computerzüge um
    private void computerZug() {
        int kartenZaehler = 0;
        int zufall = 0;
        boolean treffer = false;
        //zur Steuerung über die Spielstärke
        if ((int)(Math.random() * spielstaerke) == 0) {
            //erst einmal nach einem Paar suchen
            //dazu durchsuchen wir das Array gemerkteKarten, bis wir in beiden Dimensionen
            //einen Wert finden
            while ((kartenZaehler < 21) && (treffer == false)) {
                //gibt es in beiden Dimensionen einen Wert größer oder gleich 0?
                if ((gemerkteKarten[0][kartenZaehler] >=0) &&  (gemerkteKarten[1][kartenZaehler] >=0)) {
                    //dann haben wir ein Paar
                    treffer = true;
                    //die Vorderseite der Karte zeigen
                    karten[gemerkteKarten[0][kartenZaehler]].vorderseiteZeigen();
                    //und dann die Karte öffnen
                    karteOeffnen(karten[gemerkteKarten[0][kartenZaehler]]);
                    //die zweite Karte auch
                    karten[gemerkteKarten[1][kartenZaehler]].vorderseiteZeigen();
                    karteOeffnen(karten[gemerkteKarten[1][kartenZaehler]]);
                }
                kartenZaehler++;
            }
        }
        //wenn wir kein Paar gefunden haben, drehen wir zufällig zwei Karten um
        if (treffer == false) {
            //solange eine Zufallszahl suchen, bis eine Karte gefunden wird, die noch im Spiel ist
            do {
                zufall = (int)(Math.random() * karten.length);
            } while (karten[zufall].isNochImSpiel() == false);
            //die erste Karte umdrehen
            //die Vorderseite der Karte zeigen
            karten[zufall].vorderseiteZeigen();
            //und dann die Karte öffnen
            karteOeffnen(karten[zufall]);

            //für die zweite Karte müssen wir außerdem prüfen, ob sie nicht gerade angezeigt wird
            do {
                zufall = (int)(Math.random() * karten.length);
            } while ((karten[zufall].isNochImSpiel() == false) || (karten[zufall].isUmgedreht() == true));
            //und die zweite Karte umdrehen
            karten[zufall].vorderseiteZeigen();
            karteOeffnen(karten[zufall]);
        }
    }
    
    //die Methode liefert, ob Züge des Menschen erlaubt sind
    //die Rückgabe ist false, wenn gerade der Computer zieht
    //oder wenn schon zwei Karten umgedreht sind
    //sonst ist die Rückgabe true
    public boolean zugErlaubt() {
        boolean erlaubt = true;
        //zieht der Computer?
        if (spieler == 1)
            erlaubt = false;
        //sind schon zwei Karten umdreht?
        if (umgedrehteKarten == 2)
            erlaubt = false;
        return erlaubt;
    }
    
}

 

[Java-Entdecker]

Guten Tag liebe Java-Gemeinde,

ich hänge aktuell an einer Aufgabe fest und wollte hier gerne Hilfe ersuchen....

Ich soll ein Memory-Spiel modifizieren.
in der 1. Aufgabe heißt es, dass ich vor dem Beenden des Programms anzeigen soll wer der Gewinner ist...
und das Beenden des Programms erst nach einer gewissen zeit auftreten soll.

Ich habe aktuell das antriggern des Timers noch nicht ganz durchblickt wie es aussieht...
kann mir einer erklären warum der Timer für 10 Sekunden nicht ausgeführt wird?
Habe ich eine Verknüpfung oder der gleichen im Timerhandler vergessen?

Ich bin sehr dankbar für jede Aussage...

hier einmal der aktuelle Code der Klasse.

package de.fernschulen;


//für die Klassen Arrays und Collections
import java.util.Arrays;
import java.util.Collections;

import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.Label;
import javafx.scene.layout.FlowPane;
import javafx.scene.layout.GridPane;
import javafx.util.Duration;

public class MemoryFeld {
    //eine innere Klasse für den Eventhandler des Timer
    class TimerHandler implements EventHandler<ActionEvent> {
            @Override
            //die Methode ruft die Methode karteSchliessen() auf
            public void handle(ActionEvent arg0) {
                karteSchliessen();
            }
        }

    //das Array für die Karten
    private MemoryKarte[] karten;
   
    //das Array für die Namen der Grafiken
    private String[] bilder = {"grafiken/apfel.jpg", "grafiken/birne.jpg", "grafiken/blume.jpg", "grafiken/blume2.jpg",
            "grafiken/ente.jpg", "grafiken/fisch.jpg", "grafiken/fuchs.jpg", "grafiken/igel.jpg",
            "grafiken/kaenguruh.jpg", "grafiken/katze.jpg", "grafiken/kuh.jpg", "grafiken/maus1.jpg",
            "grafiken/maus2.jpg", "grafiken/maus3.jpg", "grafiken/melone.jpg", "grafiken/pilz.jpg",
            "grafiken/ronny.jpg", "grafiken/schmetterling.jpg","grafiken/sonne.jpg",
            "grafiken/wolke.jpg", "grafiken/maus4.jpg"};
   
    //für die Punkte
    private int menschPunkte, computerPunkte;
   
    //zwei Labels für die Punkte
    private Label menschPunkteLabel, computerPunkteLabel, sieger;
   
    //wie viele Karten sind aktuell umgedreht?
    private int umgedrehteKarten;
   
    //für das aktuell umdrehte Paar
    private MemoryKarte[] paar;
   
    //für den aktuellen Spieler
    private int spieler;
   
    //das "Gedächtnis" für den Computer
    //er speichert hier wo das Gegenstück liegt
    private int[][] gemerkteKarten;

    //für die Spielstärke
    private int spielstaerke;

    //für den Timer
    private Timeline timer;

    //der Konstruktor
    public MemoryFeld() {
        //das Array für die Karten erstellen, insgesamt 42 Stück
        karten = new MemoryKarte[42];

        //für das Paar
        paar = new MemoryKarte[2];

        //für das Gedächtnis
        //es speichert für jede Karte paarweise die Position im Spielfeld
        gemerkteKarten = new int[2][21];
       
        //keiner hat zu Beginn einen Punkt
        menschPunkte = 0;
        computerPunkte = 0;
       
        //es ist keine Karte umgedreht
        umgedrehteKarten = 0;
       
        //der Mensch fängt an
        spieler = 0;
       
        //die Spielstärke ist 10
        spielstaerke = 0;
       
        //es gibt keine gemerkten Karten
        for (int aussen = 0; aussen < 2; aussen++)
            for (int innen = 0; innen < 21; innen++)
                gemerkteKarten[aussen][innen] = -1;
    }

    //die Methode erstellt die Oberfläche und zeichnet die Karten über eine eigene Methode
    //übergeben wird ein FlowPane
    public FlowPane initGUI(FlowPane feld) {
        //für die Ausgaben
        kartenZeichnen(feld);
        menschPunkteLabel = new Label();
        computerPunkteLabel = new Label();
        menschPunkteLabel.setText(Integer.toString(menschPunkte));
        computerPunkteLabel.setText(Integer.toString(computerPunkte));
//***************************************Aufgabe1***************************************
        sieger = new Label();
        sieger.setText("");
//***************************************Aufgabe1***************************************
       
        //in zwei Spalten anzeigen
        GridPane tempGrid = new GridPane();
        //und einfügen, dabei werden die Koordinaten angegeben
        tempGrid.add(new Label("Mensch: "), 0 , 0 );
        tempGrid.add(menschPunkteLabel, 1, 0);
        tempGrid.add(new Label("Computer: "), 0, 1);
        tempGrid.add(computerPunkteLabel, 1 ,1);
//***************************************Aufgabe1***************************************
        tempGrid.add(new Label("Sieger: "), 0, 2);
        tempGrid.add(sieger, 1 ,2);
//***************************************Aufgabe1***************************************
        feld.getChildren().add(tempGrid);
        return feld;
    }
   
    //das eigentliche Spielfeld erstellen
    private void kartenZeichnen(FlowPane feld) {
        int count = 0;
        for (int i = 0; i <= 41; i++) {
            //eine neue Karte erzeugen
            karten[i] = new MemoryKarte(bilder[count], count, this);
            //bei jeder zweiten Karte kommt auch ein neues Bild
            if ((i + 1) % 2 == 0)
                count++;
        }
        //die Karten werden gemischt
        Collections.shuffle(Arrays.asList(karten));

        //und ins Spielfeld gesetzt
        for (int i = 0; i <= 41; i++) {
            feld.getChildren().add(karten[i]);
            //die Position der Karte setzen
            karten[i].setBildPos(i);
        }
    }
   
    //die Methode übernimmt die wesentliche Steuerung des Spiels
    //Sie wird beim Anklicken einer Karte ausgeführt
    public void karteOeffnen(MemoryKarte karte) {
        //zum Zwischenspeichern der ID und der Position
        int kartenID, kartenPos;

        //die Karten zwischenspeichern
        paar[umgedrehteKarten]=karte;
       
        //die ID und die Position beschaffen
        kartenID = karte.getBildID();
        kartenPos = karte.getBildPos();
       
        //die Karte in das Gedächtnis des Computers eintragen
        //aber nur dann, wenn es noch keinen Eintrag an der entsprechenden Stelle gibt
        if ((gemerkteKarten[0][kartenID] == -1))
            gemerkteKarten[0][kartenID] = kartenPos;
        else
            //wenn es schon einen Eintrag gibt
            //und der nicht mit der aktuellen Position übereinstimmt, dann haben wir die
            //zweite Karte gefunden
            //die wird dann in die zweite Dimension eingetragen
            if (gemerkteKarten[0][kartenID] != kartenPos)
                gemerkteKarten[1][kartenID] = kartenPos;
        //umgedrehte Karten erhöhen
        umgedrehteKarten++;
       
        //sind zwei Karten umgedreht worden?
        if (umgedrehteKarten == 2) {
            //dann prüfen wir, ob es ein Paar ist
            paarPruefen(kartenID);
            //den Timer erzeugen
            timer = new Timeline(new KeyFrame(Duration.millis(2000), new TimerHandler()));
            //und starten
            timer.play();
        }
        //haben wir zusammen 21 Paare, dann ist das Spiel vorbei
        if (computerPunkte + menschPunkte == 21) {
//***************************************Aufgabe1***************************************
            //Variable vereinbaren für die Anzeige des Siegers
//            String sieger;
            //prüfen ob der Mensch mehr Punkte hat.
            //Falls ja hat er gewonnen und wenn nicht hat der Computer gewonnen.
            if (menschPunkte > computerPunkte) {
                this.sieger.setText("Der Mensch hat gewonnen");
//                sieger = "Mensch";
            } else {
                this.sieger.setText("Der Computer hat gewonnen");
//                sieger = "Computer";
            }
           
/**            //den Dialog erzeugen
            Alert meinDialog = new Alert(AlertType.INFORMATION,"Der " + sieger + " hat gesiegt!");
            //den Text setzen
            meinDialog.setHeaderText("Herzlichen Glückwunsch!");
            //den Titel setzen
            meinDialog.setTitle("Gewinner");
            //den Dialog anzeigen
            meinDialog.show(); **/
       
            //den Timer erzeugen um das Ende für 10 Sekunden hinaus zuzögern.
            timer = new Timeline(new KeyFrame(Duration.seconds(10), new TimerHandler()));
            //und starten
            timer.play();
//***************************************Aufgabe1***************************************
            //wir beenden es hier direkt
            Platform.exit();
        }
    }
   
    //die Methode dreht die Karten wieder auf die Rückseite
    //bzw. nimmt sie aus dem Spiel
    private void karteSchliessen() {
        boolean raus = false;
        //ist es ein Paar?
        if (paar[0].getBildID() == paar[1].getBildID())
            raus = true;
        //wenn es ein Paar war, nehmen wir die Karten aus dem Spiel
        //sonst drehen wir sie nur wieder um
        paar[0].rueckseiteZeigen(raus);
        paar[1].rueckseiteZeigen(raus);
        //es ist keine Karte mehr geöffnet
        umgedrehteKarten = 0;
        //hat der Spieler kein Paar gefunden?
        if (raus == false)
            //dann wird der Spieler gewechselt
            spielerWechseln();
        else
            //hat der Computer ein Paar gefunden?
            //dann ist er noch einmal an der Reihe
            if (spieler == 1)
                computerZug();
    }
   
    //die Methode prüft, ob ein Paar gefunden wurde
    private void paarPruefen(int kartenID) {
        if (paar[0].getBildID() == paar[1].getBildID()) {
            //die Punkte setzen
            paarGefunden();
            //die Karten aus dem Gedächtnis löschen
            gemerkteKarten[0][kartenID]=-2;
            gemerkteKarten[1][kartenID]=-2;
        }
    }

    //die Methode setzt die Punkte, wenn ein Paar gefunden wurde
    private void paarGefunden() {
        //spielt gerade der Mensch?
        if (spieler == 0) {
            menschPunkte++;
            menschPunkteLabel.setText(Integer.toString(menschPunkte));
        }
        else {
            computerPunkte++;
            computerPunkteLabel.setText(Integer.toString(computerPunkte));
        }
    }
   
    //die Methode wechselt den Spieler
    private void spielerWechseln() {
        //wenn der Mensch an der Reihe war,
        //kommt jetzt der Computer
        if (spieler == 0) {
            spieler = 1;
            computerZug();
        }
        else
            spieler = 0;
    }
   
    //die Methode setzt die Computerzüge um
    private void computerZug() {
        int kartenZaehler = 0;
        int zufall = 0;
        boolean treffer = false;
        //zur Steuerung über die Spielstärke
        if ((int)(Math.random() * spielstaerke) == 0) {
            //erst einmal nach einem Paar suchen
            //dazu durchsuchen wir das Array gemerkteKarten, bis wir in beiden Dimensionen
            //einen Wert finden
            while ((kartenZaehler < 21) && (treffer == false)) {
                //gibt es in beiden Dimensionen einen Wert größer oder gleich 0?
                if ((gemerkteKarten[0][kartenZaehler] >=0) &&  (gemerkteKarten[1][kartenZaehler] >=0)) {
                    //dann haben wir ein Paar
                    treffer = true;
                    //die Vorderseite der Karte zeigen
                    karten[gemerkteKarten[0][kartenZaehler]].vorderseiteZeigen();
                    //und dann die Karte öffnen
                    karteOeffnen(karten[gemerkteKarten[0][kartenZaehler]]);
                    //die zweite Karte auch
                    karten[gemerkteKarten[1][kartenZaehler]].vorderseiteZeigen();
                    karteOeffnen(karten[gemerkteKarten[1][kartenZaehler]]);
                }
                kartenZaehler++;
            }
        }
        //wenn wir kein Paar gefunden haben, drehen wir zufällig zwei Karten um
        if (treffer == false) {
            //solange eine Zufallszahl suchen, bis eine Karte gefunden wird, die noch im Spiel ist
            do {
                zufall = (int)(Math.random() * karten.length);
            } while (karten[zufall].isNochImSpiel() == false);
            //die erste Karte umdrehen
            //die Vorderseite der Karte zeigen
            karten[zufall].vorderseiteZeigen();
            //und dann die Karte öffnen
            karteOeffnen(karten[zufall]);

            //für die zweite Karte müssen wir außerdem prüfen, ob sie nicht gerade angezeigt wird
            do {
                zufall = (int)(Math.random() * karten.length);
            } while ((karten[zufall].isNochImSpiel() == false) || (karten[zufall].isUmgedreht() == true));
            //und die zweite Karte umdrehen
            karten[zufall].vorderseiteZeigen();
            karteOeffnen(karten[zufall]);
        }
    }
   
    //die Methode liefert, ob Züge des Menschen erlaubt sind
    //die Rückgabe ist false, wenn gerade der Computer zieht
    //oder wenn schon zwei Karten umgedreht sind
    //sonst ist die Rückgabe true
    public boolean zugErlaubt() {
        boolean erlaubt = true;
        //zieht der Computer?
        if (spieler == 1)
            erlaubt = false;
        //sind schon zwei Karten umdreht?
        if (umgedrehteKarten == 2)
            erlaubt = false;
        return erlaubt;
    }
   
}

noch als Zusatz... es geht um Zeile 208 & 210..

 

[KonradN]

Also Deine Logik ist nicht gut durchdacht. Du startest den Timer, der dann in 30 Sekunden etwas machen soll. Aber dann beendest Du die Anwendung sofort knallhart. Das ist doch asynchron und das Beenden beendet die Anwendung ohne auf irgend etwas zu warten.

Dann willst Du ja, dass die Anwendung nch 30 Sekunden beendet wird (so ich dich richtig verstanden habe). Aber was Du da machst ist unter dem Strich einfach nur ein karteSchliessen Aufruf.... Aber was Du haben willst ist doch, dass der Timer die Anwendung beendet...

Was Du also brauchst ist ein EventHandler, der dann Platform.exit() aufruft. Und das Platform.exit() nach dem Start des Timers entfällt komplett.

 

[Java-Entdecker]

Erst einmal vielen Dank für die rasche Antwort.

Sowas in der Art hatte ich mir schon gedacht.. ich habe aktuell aber einen großen Gedankenfehler was den Umgang mit den
EventHandler angeht.. Sollte ich einfach einen zweiten Override befehl rein schreiben? also quasi darunter?

 

[mihe7]

Sollte ich einfach einen zweiten Override befehl rein schreiben? also quasi darunter?

Nein. Du kannst eine Methode nur einmal implementieren bzw. überschreiben. Und die @Override-Annotation ist nur ein Hinweis für den Compiler, damit Du eine Fehlermeldung bekommst, wenn sich z. B. an der Superklasse etwas ändert und die Methode tatsächlich nichts mehr überschreibt.

Ich denke mal, @KonradN wollte auf https://docs.oracle.com/javase/8/ja...html#setOnFinished-javafx.event.EventHandler- hinaus.

 

[KonradN]

    class TimerHandler implements EventHandler<ActionEvent> {
            @Override
            //die Methode ruft die Methode karteSchliessen() auf
            public void handle(ActionEvent arg0) {
                karteSchliessen();
            }
        }

das ist eine Klasse die EventHandler implementiert.

EventHander ist ein Funktionales Interface: https://openjfx.io/javadoc/21/javafx.base/javafx/event/EventHandler.html

Jetzt könntest Du eine neue innere Klasse bauen, die eben Platform.exit() aufruft:

    class ApplicationQuitter implements EventHandler<ActionEvent> {
            @Override
            //die Methode ruft die Methode karteSchliessen() auf
            public void handle(ActionEvent arg0) {
                Platform.exit();
            }
        }

Aber funktionale Interfaces sollten anders genutzt werden. (Aber der Lehrer/Professor akzeptieren das ggf. nicht. Das sieht halt nach eine Schulaufgabe aus) So eine innere Klasse wird seit Java 8 eigentlich nicht mehr gemacht. Schau Dir Lambda Expressions und Methoden Referenzen an...
Aus
timer = new Timeline(new KeyFrame(Duration.seconds(10), new TimerHandler()));
kannst Du einfach machen:
timer = new Timeline(new KeyFrame(Duration.seconds(10), () -> this.karteSchliesen() )); // lambda
timer = new Timeline(new KeyFrame(Duration.seconds(10), this::karteSchliesen )); // methoden referenz

bzw. mit Plattform.exit wäre es:
timer = new Timeline(new KeyFrame(Duration.seconds(10), () -> Platform.exit() )); // lambda
timer = new Timeline(new KeyFrame(Duration.seconds(10), Platform::exit )); // methoden referenz

Alles direkt im Forum getippt, Tippfehler möglich. Und ich habe lange kein JavaFX und Timeline mehr gemacht/genutzt. Das setzt voraus, dass Dein Code nach 10 Sekunden die karteSchliessen Methode aufgerufen hatte ...

Ich denke mal, @KonradN wollte auf https://docs.oracle.com/javase/8/ja...html#setOnFinished-javafx.event.EventHandler- hinaus.

Nein, er hatte da hoffentlich schon etwas, das nach x Sekunden etwas gemacht hat (Sprich: Karten wurden wieder umgedreht) so dass ich lediglich das weiter verwendet habe. Sollte das bereits falsch gewesen sein und Timeline so nicht funktionieren, dann wäre ich da schlicht rein gefallen ...
Aber hier geht es ja nur um einen einfachen Timer, nicht darum, dass er nach Abschluss einer Timeline noch etwas zusätzlich machen soll ...

 

[Jw456]

kann mir einer erklären warum der Timer für 10 Sekunden nicht ausgeführt wird?

Du benutzt den gleichen Teimer auch zweimal in Zeile 179 und 208

 

[KonradN]

Du benutzt den gleichen Teimer auch zweimal in Zeile 179 und 208

Das ist zwar nicht schön, aber stört auch nicht. Er erstellt immer eine neue Timeline. Statt einer Instanzvariable wäre dann eine lokale Variable besser, denn er greift da ja sonst nie zu. Ein Merken des Timers ist somit schlicht nicht notwendig.

 

[Jw456]

Ja das stimmt aber er Fürt immer eine neue Instanz des Handler aus. Er ruft in jeden Teimer die Methode karteSchliessen() auf.
Und nicht ein beenden des Programms war er ja scheinbar will.
Da wäre deine lambdas besser geeignet. Als Zwei underschiedliche inneren Klassen.