Memory-Spiel stecke Fest

[kaper28]

Liebe Freunde,

Ich muß in diesem Memory -Spiel eine Methode schreibenn der mir die aufdecken Karten nach einer Zeit wieder zu deck . Wie ihr in diesem Code sieht habe ich zwei buttons eingebaut . Eine Öffnet alle karten der andere schließt sie wieder . Das schließen soll aber nicht von Hand sondern automatisch nach 5 sekunden passierenm mit einem Timer natürlich. Ich schlage mich seit 3 Wochen mit diesem Code und schaffe es nicht .Brauche also eure hilfe . Hier ist der Code

Klasse MemoryFeld

import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Collections;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;

public class MemoryFeld extends JFrame {

	private String anzeige = "Es Zieht der Mensch";
	private String anzeige1 = "Es Zieht der Computer";

	private ImageIcon bildVorne, bildHinten;

	class MeinListener implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {

			if (e.getActionCommand().equals("aufdecken"))
				;

			kartenAufdecken();

		}
	}

	class MeinListener1 implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {

			if (e.getActionCommand().equals("zudecken"))
				;

			reuckseiteZeigen();

		}
	}

	///eine innere Klasse für den Timer
	class TimerListener implements ActionListener {

		@Override
		//		die Methode ruft die Methode karteSchliessen() auf
		public void actionPerformed(ActionEvent e) {
			karteSchliessen();

		}
	}

	//automatisch über Eclipse ergänzt
	private static final long serialVersionUID = -649630686152121284L;

	//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 JLabel menschPunkteLabel, computerPunkteLabel, anzeigeLabel;

	//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;

	//für den Timer
	private Timer timer;

	//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;

	//der Konstruktor
	//er erzeugt das Spielfeld mit den Karten und die Oberfläche
	public MemoryFeld(String titel) {
		super(titel);
		//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;

		//es gibt keine gemerkten Karten
		for (int aussen = 0; aussen < 2; aussen++)
			for (int innen = 0; innen < 21; innen++)
				gemerkteKarten[aussen][innen] = -1;

		//die Oberfläche erstellen
		initGUI();

		//die Spielstärke ist 10, also eher schwach
		spielstaerke = 10;
		//für den Timer
		//eine neue Instanz erstellen, der Timer soll alle 2 Sekunden ausgelöst werden
		timer = new Timer(2000, new TimerListener());
		//in unserem Spiel soll er aber nur einmal ausgeführt werden
		timer.setRepeats(false);

		//Größe setzen, keine Größenänderungen zulassen, Standard-Verhalten festlegen und anzeigen
		setSize(405, 600);
		setResizable(false);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
	}

	//die Methode erstellt die Oberfläche und zeichnet die Karten
	private void initGUI() {
		//das Layout setzen
		setLayout(new FlowLayout(FlowLayout.LEFT));

		//ein Panel für das eigentliche Spielfeld
		JPanel feld = new JPanel();
		//das Panel bekommt ein Gridlayout mit 7 Zeilen
		feld.setLayout(new GridLayout(7, 0));
		//die Karten erstellen und zeichnen
		kartenZeichnen(feld);

		add(feld);

		//für die Ausgaben
		JPanel ausgabe = new JPanel();
		anzeigeLabel = new JLabel();
		menschPunkteLabel = new JLabel();
		computerPunkteLabel = new JLabel();
		menschPunkteLabel.setText(Integer.toString(menschPunkte));
		computerPunkteLabel.setText(Integer.toString(computerPunkte));

		JButton schummelButton = new JButton("Alles Aufdecken");
		schummelButton.setActionCommand("aufdecken");
		MeinListener listener = new MeinListener();
		schummelButton.addActionListener(listener);

		JButton schummelButton1 = new JButton("Alles zudecken");
		schummelButton1.setActionCommand("zudecken");

		MeinListener1 listener1 = new MeinListener1();
		schummelButton1.addActionListener(listener1);

		//in zwei Spalten
		ausgabe.setLayout(new GridLayout(0, 2));
		ausgabe.add(new JLabel("Mensch: "));
		ausgabe.add(menschPunkteLabel);
		ausgabe.add(new JLabel("Computer: "));
		ausgabe.add(computerPunkteLabel);
		ausgabe.add(anzeigeLabel);
		ausgabe.add(schummelButton);
		ausgabe.add(schummelButton1);
		add(ausgabe);
	}

	//das eigentliche Spielfeld erstellen
	private void kartenZeichnen(JPanel 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 und dann ins Spielfeld gesetzt
		Collections.shuffle(Arrays.asList(karten));
		for (int i = 0; i <= 41; i++) {
			feld.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;
		anzeigeLabel.setText((anzeige));
		//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 2 Karten umgedreht worden?
		if (umgedrehteKarten == 2) {
			//dann prüfen wir, ob es ein Paar ist
			paarPruefen(kartenID);
			//den Timer starten
			timer.start();
		}
		//haben wir zusammen 21 Paare, dann ist das Spiel vorbei
		if (computerPunkte + menschPunkte == 1) {
			JOptionPane.showMessageDialog(this, "Das Spiel ist vorbei.");
			//  4 neue 	MessageDialog eingefügt...
			JOptionPane.showMessageDialog(this, "Der Mensch hat"
					+ (menschPunkte) + " punkte gemacht");
			JOptionPane.showMessageDialog(this, "Der Computer hat"
					+ (computerPunkte) + " punkte gemacht ");
			if (menschPunkte > computerPunkte)
				JOptionPane.showMessageDialog(this, " Der Mensch Hat Gewonnen");
			else
				JOptionPane.showMessageDialog(this,
						" Der Computer  Hat Gewonnen");

			System.exit(0);
		}
	}

	//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;

		anzeigeLabel.setText(anzeige1);
	}

	//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;
	}

	public void kartenAufdecken() {

		int i = 0;
		for (i = 0; i + 1 <= 42; ++i)

			karten[i].vorderseiteZeigen();

	}

	public void reuckseiteZeigen() {
		
		int i = 0;
		for (i = 0; i + 1 <= 42; ++i)
			karten[i].rueckseiteZeigen1();

	}

}

 

[kaper28]

Klasse MemoryKarte

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.Timer;

import de.fernschulen.memoryspiel.MemoryFeld.TimerListener;

//die Klasse für eine Karte des Memory-Spiels
//Sie erbt von JButton
public class MemoryKarte extends JButton {
	
	//automatisch mit Eclipse erzeugt
	private static final long serialVersionUID = -7586403525312208557L;

	//die Instanzvariablen
	//eine eindeutige ID zur Identifizierung des Bildes
	private int bildID;
	//für die Vorder- und Rückseite
	private ImageIcon bildVorne,bildHinten;


	
	//wo liegt die Karte im Spielfeld
	private int bildPos;

	//ist die Karte umgedreht?
	private boolean umgedreht;
	//ist die Karte noch im Spiel?
	private boolean nochImSpiel;
	
	//das Spielfeld für die Karte
	private MemoryFeld spielfeld;
	
	//die innere Klasse für den ActionListener
	class KartenListener implements ActionListener {

		@Override
		public void actionPerformed(ActionEvent arg0) {
			//ist die Karte überhaupt noch im Spiel?
			//und sind Züge erlaubt?
			if ((nochImSpiel == false) || (spielfeld.zugErlaubt() == false))
				return;
			//wenn die Rückseite zu sehen ist, die Vorderseite anzeigen
			if (umgedreht == false) {
				vorderseiteZeigen();
				//die Methode karteOeffnen() im Spielfeld aufrufen
				//übergeben wird dabei die Karte
				//also die this-Referenz der äußeren Klasse
				spielfeld.karteOeffnen(MemoryKarte.this);
			}
		}
	}
	

	//der Konstruktor
	//er setzt die Größe, die Bilder und die Position
	public MemoryKarte(String vorne, int bildID, MemoryFeld spielfeld) {
		//die Größe auf 64 * 64 setzen
		setPreferredSize(new Dimension(64,64));
		//die Vorderseite, der Dateiname des Bildes wird an den Konstruktor übergeben
		bildVorne = new ImageIcon(vorne);
		//die Rückseite, sie wird fest gesetzt
		bildHinten = new ImageIcon("grafiken/back.jpg");
		setIcon(bildHinten);
		
		//die Bild-ID
		this.bildID = bildID;
	 	//die Karte ist erst einmal umgedreht und noch im Feld
		umgedreht = false;
		nochImSpiel = true;
		//mit dem Spielfeld verbinden
		this.spielfeld = spielfeld;
		//den ActionListener verbinden
		addActionListener(new KartenListener());
	}
	
	//die Methode zeigt die Rückseite der Karte an
	public void rueckseiteZeigen(boolean rausnehmen) {
		//soll die Karten komplett aus dem Spiel genommen werden?
		if (rausnehmen == true) {
			//das Bild aufgedeckt zeigen und die Karte aus dem Spiel nehmen
			setIcon(new ImageIcon("grafiken/aufgedeckt.jpg"));
			nochImSpiel = false;
		}
		else {
			//sonst nur die Rückseite zeigen
			
			setIcon(bildHinten);
			umgedreht = false;
		}
	}
	
	//die Methode zeigt die Vorderseite der Karte an
	public void vorderseiteZeigen() {
		setIcon(bildVorne);
		umgedreht = true;
	}
	public void rueckseiteZeigen1() {
		bildHinten = new ImageIcon("grafiken/back.jpg");
		
		setIcon(bildHinten);
		umgedreht = true;
	}
	//die Methode liefert die Bild-ID einer Karte
	public int getBildID() {
		return bildID;
	}

	//die Methode liefert die Position einer Karte
	public int getBildPos() {
		return bildPos;
	}
	
	//die Methode setzt die Position einer Karte
	public void setBildPos(int bildPos) {
		this.bildPos = bildPos;
	}

	//die Methode liefert den Wert der Variablen umgedreht
	public boolean isUmgedreht() {
		return umgedreht;
	}

	//die Methode liefert den Wert der Variablen nochImSpiel
	public boolean isNochImSpiel() {
		return nochImSpiel;
	}

	

	
	
	}

 

[Marco13]

Ja, nachdem ich ein paar minuten damit verschwendet habe, die beiden Dateien zusammenzukopieren, eine "main" einzufügen, und die (nicht vorhandenen) Bilder zu ersetzen durch kleine Bildchen, die nur einen String anzeigen:

// Von [url]http://www.java-forum.org/de/viewtopic.php?t=80991&highlight=&sid=2ee2ac2521c65006cc9c7246565af47a[/url]

import java.awt.*;
import java.awt.image.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Collections;

import javax.swing.*;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.Timer;



public class MemoryFeld extends JFrame {

    public static void main(String args[])
    {
        new MemoryFeld("Bla").setVisible(true);
    }

   private String anzeige = "Es Zieht der Mensch";
   private String anzeige1 = "Es Zieht der Computer";

   private ImageIcon bildVorne, bildHinten;

   class MeinListener implements ActionListener {
      @Override
      public void actionPerformed(ActionEvent e) {

         if (e.getActionCommand().equals("aufdecken"))
            ;

         Thread threadDerAufdecktUndDannWartetUndDannZudeckt = new Thread(new Runnable()
         {
             public void run()
             {
                 deckDieKartenImEventDispatchThreadAuf_DasIstNichtSoWichtig_ManKönnteAuchDirekt_KartenAufdecken_Aufrufen_AberSoIstEsSauberer();
                 try
                 {
                     Thread.sleep(3000);
                 }
                 catch (InterruptedException e)
                 {
                     e.printStackTrace();
                 }
                 deckDieKartenImEventDispatchThreadZu_DasIstNichtSoWichtig_ManKönnteAuchDirekt_ReuckseiteZeigen_Aufrufen_AberSoIstEsSauberer();
             }

         });
         threadDerAufdecktUndDannWartetUndDannZudeckt.start();
      }
   }


   void deckDieKartenImEventDispatchThreadAuf_DasIstNichtSoWichtig_ManKönnteAuchDirekt_KartenAufdecken_Aufrufen_AberSoIstEsSauberer()
   {
       SwingUtilities.invokeLater(new Runnable()
       {
           public void run()
           {
                kartenAufdecken();
           }
       });
   }

   void deckDieKartenImEventDispatchThreadZu_DasIstNichtSoWichtig_ManKönnteAuchDirekt_ReuckseiteZeigen_Aufrufen_AberSoIstEsSauberer()
   {
       SwingUtilities.invokeLater(new Runnable()
       {
           public void run()
           {
               reuckseiteZeigen();
           }
       });
   }





   class MeinListener1 implements ActionListener {
      @Override
      public void actionPerformed(ActionEvent e) {

         if (e.getActionCommand().equals("zudecken"))
            ;

         reuckseiteZeigen();

      }
   }

   ///eine innere Klasse für den Timer
   class TimerListener implements ActionListener {

      @Override
      //      die Methode ruft die Methode karteSchliessen() auf
      public void actionPerformed(ActionEvent e) {
         karteSchliessen();

      }
   }

   //automatisch über Eclipse ergänzt
   private static final long serialVersionUID = -649630686152121284L;

   //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 JLabel menschPunkteLabel, computerPunkteLabel, anzeigeLabel;

   //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;

   //für den Timer
   private Timer timer;

   //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;

   //der Konstruktor
   //er erzeugt das Spielfeld mit den Karten und die Oberfläche
   public MemoryFeld(String titel) {
      super(titel);
      //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;

      //es gibt keine gemerkten Karten
      for (int aussen = 0; aussen < 2; aussen++)
         for (int innen = 0; innen < 21; innen++)
            gemerkteKarten[aussen][innen] = -1;

      //die Oberfläche erstellen
      initGUI();

      //die Spielstärke ist 10, also eher schwach
      spielstaerke = 10;
      //für den Timer
      //eine neue Instanz erstellen, der Timer soll alle 2 Sekunden ausgelöst werden
      timer = new Timer(2000, new TimerListener());
      //in unserem Spiel soll er aber nur einmal ausgeführt werden
      timer.setRepeats(false);

      //Größe setzen, keine Größenänderungen zulassen, Standard-Verhalten festlegen und anzeigen
      setSize(405, 600);
      setResizable(false);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setVisible(true);
   }

   //die Methode erstellt die Oberfläche und zeichnet die Karten
   private void initGUI() {
      //das Layout setzen
      setLayout(new FlowLayout(FlowLayout.LEFT));

      //ein Panel für das eigentliche Spielfeld
      JPanel feld = new JPanel();
      //das Panel bekommt ein Gridlayout mit 7 Zeilen
      feld.setLayout(new GridLayout(7, 0));
      //die Karten erstellen und zeichnen
      kartenZeichnen(feld);

      add(feld);

      //für die Ausgaben
      JPanel ausgabe = new JPanel();
      anzeigeLabel = new JLabel();
      menschPunkteLabel = new JLabel();
      computerPunkteLabel = new JLabel();
      menschPunkteLabel.setText(Integer.toString(menschPunkte));
      computerPunkteLabel.setText(Integer.toString(computerPunkte));

      JButton schummelButton = new JButton("Alles Aufdecken");
      schummelButton.setActionCommand("aufdecken");
      MeinListener listener = new MeinListener();
      schummelButton.addActionListener(listener);

      JButton schummelButton1 = new JButton("Alles zudecken");
      schummelButton1.setActionCommand("zudecken");

      MeinListener1 listener1 = new MeinListener1();
      schummelButton1.addActionListener(listener1);

      //in zwei Spalten
      ausgabe.setLayout(new GridLayout(0, 2));
      ausgabe.add(new JLabel("Mensch: "));
      ausgabe.add(menschPunkteLabel);
      ausgabe.add(new JLabel("Computer: "));
      ausgabe.add(computerPunkteLabel);
      ausgabe.add(anzeigeLabel);
      ausgabe.add(schummelButton);
      ausgabe.add(schummelButton1);
      add(ausgabe);
   }

   //das eigentliche Spielfeld erstellen
   private void kartenZeichnen(JPanel 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 und dann ins Spielfeld gesetzt
      Collections.shuffle(Arrays.asList(karten));
      for (int i = 0; i <= 41; i++) {
         feld.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;
      anzeigeLabel.setText((anzeige));
      //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 2 Karten umgedreht worden?
      if (umgedrehteKarten == 2) {
         //dann prüfen wir, ob es ein Paar ist
         paarPruefen(kartenID);
         //den Timer starten
         timer.start();
      }
      //haben wir zusammen 21 Paare, dann ist das Spiel vorbei
      if (computerPunkte + menschPunkte == 1) {
         JOptionPane.showMessageDialog(this, "Das Spiel ist vorbei.");
         //  4 neue    MessageDialog eingefügt...
         JOptionPane.showMessageDialog(this, "Der Mensch hat"
               + (menschPunkte) + " punkte gemacht");
         JOptionPane.showMessageDialog(this, "Der Computer hat"
               + (computerPunkte) + " punkte gemacht ");
         if (menschPunkte > computerPunkte)
            JOptionPane.showMessageDialog(this, " Der Mensch Hat Gewonnen");
         else
            JOptionPane.showMessageDialog(this,
                  " Der Computer  Hat Gewonnen");

         System.exit(0);
      }
   }

   //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;

      anzeigeLabel.setText(anzeige1);
   }

   //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;
   }

   public void kartenAufdecken() {

      int i = 0;
      for (i = 0; i + 1 <= 42; ++i)

         karten[i].vorderseiteZeigen();

   }

   public void reuckseiteZeigen() {

      int i = 0;
      for (i = 0; i + 1 <= 42; ++i)
         karten[i].rueckseiteZeigen1();

   }

}



//die Klasse für eine Karte des Memory-Spiels
//Sie erbt von JButton
class MemoryKarte extends JButton {

   //automatisch mit Eclipse erzeugt
   private static final long serialVersionUID = -7586403525312208557L;

   //die Instanzvariablen
   //eine eindeutige ID zur Identifizierung des Bildes
   private int bildID;
   //für die Vorder- und Rückseite
   private ImageIcon bildVorne,bildHinten;



   //wo liegt die Karte im Spielfeld
   private int bildPos;

   //ist die Karte umgedreht?
   private boolean umgedreht;
   //ist die Karte noch im Spiel?
   private boolean nochImSpiel;

   //das Spielfeld für die Karte
   private MemoryFeld spielfeld;

   //die innere Klasse für den ActionListener
   class KartenListener implements ActionListener {

      @Override
      public void actionPerformed(ActionEvent arg0) {
         //ist die Karte überhaupt noch im Spiel?
         //und sind Züge erlaubt?
         if ((nochImSpiel == false) || (spielfeld.zugErlaubt() == false))
            return;
         //wenn die Rückseite zu sehen ist, die Vorderseite anzeigen
         if (umgedreht == false) {
            vorderseiteZeigen();
            //die Methode karteOeffnen() im Spielfeld aufrufen
            //übergeben wird dabei die Karte
            //also die this-Referenz der äußeren Klasse
            spielfeld.karteOeffnen(MemoryKarte.this);
         }
      }
   }


   //der Konstruktor
   //er setzt die Größe, die Bilder und die Position
   public MemoryKarte(String vorne, int bildID, MemoryFeld spielfeld) {
      //die Größe auf 64 * 64 setzen
      setPreferredSize(new Dimension(64,64));
      //die Vorderseite, der Dateiname des Bildes wird an den Konstruktor übergeben
      bildVorne = new ImageIcon(vorne);

      Image img = new BufferedImage(64,64,BufferedImage.TYPE_INT_ARGB);
      Graphics g = img.getGraphics();
      g.setColor(Color.BLACK);
      g.drawString(vorne.substring(vorne.indexOf("/"),vorne.indexOf(".")),0,20);
      bildVorne = new  ImageIcon(img);


      //die Rückseite, sie wird fest gesetzt
      bildHinten = new ImageIcon("grafiken/back.jpg");

      img = new BufferedImage(64,64,BufferedImage.TYPE_INT_ARGB);
      g = img.getGraphics();
      g.setColor(Color.BLACK);
      g.drawString("back",0,20);
      bildHinten = new  ImageIcon(img);

      setIcon(bildHinten);

      //die Bild-ID
      this.bildID = bildID;
       //die Karte ist erst einmal umgedreht und noch im Feld
      umgedreht = false;
      nochImSpiel = true;
      //mit dem Spielfeld verbinden
      this.spielfeld = spielfeld;
      //den ActionListener verbinden
      addActionListener(new KartenListener());
   }

   //die Methode zeigt die Rückseite der Karte an
   public void rueckseiteZeigen(boolean rausnehmen) {
      //soll die Karten komplett aus dem Spiel genommen werden?
      if (rausnehmen == true) {
         //das Bild aufgedeckt zeigen und die Karte aus dem Spiel nehmen
         setIcon(new ImageIcon("grafiken/aufgedeckt.jpg"));
         nochImSpiel = false;
      }
      else {
         //sonst nur die Rückseite zeigen

         setIcon(bildHinten);
         umgedreht = false;
      }
   }

   //die Methode zeigt die Vorderseite der Karte an
   public void vorderseiteZeigen() {
      setIcon(bildVorne);
      umgedreht = true;
   }
   public void rueckseiteZeigen1() {
      //bildHinten = new ImageIcon("grafiken/back.jpg");

      setIcon(bildHinten);
      umgedreht = true;
   }
   //die Methode liefert die Bild-ID einer Karte
   public int getBildID() {
      return bildID;
   }

   //die Methode liefert die Position einer Karte
   public int getBildPos() {
      return bildPos;
   }

   //die Methode setzt die Position einer Karte
   public void setBildPos(int bildPos) {
      this.bildPos = bildPos;
   }

   //die Methode liefert den Wert der Variablen umgedreht
   public boolean isUmgedreht() {
      return umgedreht;
   }

   //die Methode liefert den Wert der Variablen nochImSpiel
   public boolean isNochImSpiel() {
      return nochImSpiel;
   }





   }

Das relevante ist eigentlich das, was im ActionListener für "aufdecken" gemacht wird. Dort könnte man einfach reinschreiben

         Thread threadDerAufdecktUndDannWartetUndDannZudeckt = new Thread(new Runnable()
         {
             public void run()
             {
                 kartenAufdecken();
                 try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
                 reuckseiteZeigen();
             }

         });
         threadDerAufdecktUndDannWartetUndDannZudeckt.start();

Dort wird ein neuer Thread erstellt, der "nebenher" läuft, und die "run"-Methode ausführt. In der run-Methode wird nichts anderes gemacht als die Karten aufzudecken, kurz zu warten, und die Karten wieder zuzudecken.

Wie im obigen Code zu sehen ist, sollte das auf/zudecken in diesem Fall eigentlich mit SwingUtilities gemacht werden (weil man den Zustand einer Swing Component (in diesem Fall, das ImageIcon) eigentlich NICHT von jedem beliebigen Thread aus verändern darf. In diesem Fall würde es auch gehen, wenn man die Sachen direkt aus dem neu erzeugten Thread aufruft, aber in anderen Fällen kann das problematisch sein)

Wenn noch Fragen sind, stell sie (präzise und so... du weißt schon....)