Universidad Carlos III de Madrid

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import java.awt.BorderLayout;

class Simple00GUI {

	private static final String TITULO_FRAME = "Simple00GUI";
	private static final String TEXTO_BOTON = "Púlsame!";

	private void creaGUI() {
		JFrame.setDefaultLookAndFeelDecorated(true);
		JFrame frame = new JFrame(TITULO_FRAME);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JPanel contentPane = (JPanel) frame.getContentPane();
		JButton button = new JButton(TEXTO_BOTON);
		contentPane.add(button, BorderLayout.CENTER);
		frame.pack();
		frame.setVisible(true);
	}

	public static void main(String args[]) {
		Simple00GUI p = new Simple00GUI();
		p.creaGUI();
	}
}

          

Soluciones

Las soluciones se pueden ver en los siguientes listados:

Simple00GUI

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import java.awt.BorderLayout;

class Simple00GUI {

	private static final String TITULO_FRAME = "Simple00GUI";
	private static final String TEXTO_BOTON = "Púlsame!";

	private void creaGUI() {
		JFrame.setDefaultLookAndFeelDecorated(true);
		JFrame frame = new JFrame(TITULO_FRAME);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JPanel contentPane = (JPanel) frame.getContentPane();
		JButton button = new JButton(TEXTO_BOTON);
		button.addActionListener(new ButtonActionListener());
		contentPane.add(button, BorderLayout.CENTER);
		frame.pack();
		frame.setVisible(true);
	}

	public static void main(String args[]) {
		Simple00GUI p = new Simple00GUI();
		p.creaGUI();
	}
}

	  

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

class ButtonActionListener implements ActionListener {
	
	private static final String MSG = "Hola Mundo!";

	public void actionPerformed(ActionEvent e) {
		System.out.println(MSG);
	}
	
}

	  

Simple01GUI

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JLabel;
import java.awt.GridLayout;
import java.awt.Color;

class Simple01GUI {

	private static final String TITULO_FRAME = "Simple01GUI";
	private static final String TEXTO_BOTON = "¡Púlsame!";
	private static final String TEXTO_ETIQUETA  = "¡Mira en la salida estándar!";

	private void createGUI() {
		JFrame.setDefaultLookAndFeelDecorated(true);
		JFrame frame = new JFrame(TITULO_FRAME);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JPanel contentPane = (JPanel) frame.getContentPane();
		contentPane.setLayout(new GridLayout(2,1));

		JLabel label = new JLabel(TEXTO_ETIQUETA, JLabel.CENTER);
		label.setOpaque(true);
		label.setBackground(Color.GREEN);
		contentPane.add(label);

		JButton button = new JButton(TEXTO_BOTON);
		button.addActionListener(new ButtonActionListener());
		contentPane.add(button);

		frame.pack();
		frame.setVisible(true);
	}

	public static void main(String args[]) {
		Simple01GUI p = new Simple01GUI();
		p.createGUI();
	}
}

	  

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JLabel;
import java.awt.Color;

class ButtonActionListener implements ActionListener {


	public ButtonActionListener() {
	}

	public void actionPerformed(ActionEvent e) {
		System.out.println(Thread.currentThread().getName() + ": Sacando un mensaje por la salida estándar.");

	}
	
}

	  

Simple02GUI

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JLabel;
import java.awt.GridLayout;
import java.awt.Color;

class Simple02GUI {

	private static final String TITULO_FRAME = "Simple02GUI";
	private static final String TEXTO_BOTON = "¡Púlsame!";
	private static final String TEXTO_ETIQUETA  = "¡El texto del botón cambia!";

	private void createGUI() {
		JFrame.setDefaultLookAndFeelDecorated(true);
		JFrame frame = new JFrame(TITULO_FRAME);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JPanel contentPane = (JPanel) frame.getContentPane();
		contentPane.setLayout(new GridLayout(2,1));

		JLabel label = new JLabel(TEXTO_ETIQUETA, JLabel.CENTER);
		label.setOpaque(true);
		label.setBackground(Color.GREEN);
		contentPane.add(label);

		JButton button = new JButton(TEXTO_BOTON);
		button.addActionListener(new ButtonActionListener(button));
		contentPane.add(button);

		frame.pack();
		frame.setVisible(true);
	}

	public static void main(String args[]) {
		Simple02GUI p = new Simple02GUI();
		p.createGUI();
	}
}

	  

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JLabel;
import javax.swing.JButton;
import java.awt.Color;

class ButtonActionListener implements ActionListener {

	private static final String TEXTO_BOTON = "¡Púlsame!";

	private JButton button;

	public ButtonActionListener(JButton button) {
		this.button = button;
	}

	public void actionPerformed(ActionEvent e) {
		System.out.println(Thread.currentThread().getName() + ": Cambiando el texto del botón.");
		if ( button.getText().equals(TEXTO_BOTON) ) {
			button.setText("Cámbiame!");
		}else{
			button.setText(TEXTO_BOTON);
		}
		
	}
	
}

	  

Simple03GUI

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JLabel;
import java.awt.GridLayout;
import java.awt.Color;

class Simple03GUI {

	private static final String TITULO_FRAME = "Simple03GUI";
	private static final String TEXTO_BOTON = "¡Púlsame!";
	
	private void creaGUI() {
		JFrame.setDefaultLookAndFeelDecorated(true);
		JFrame frame = new JFrame(TITULO_FRAME);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JPanel contentPane = (JPanel) frame.getContentPane();
		contentPane.setLayout(new GridLayout(2,1));

		JLabel label = new JLabel("", JLabel.CENTER);
		label.setOpaque(true);
		label.setBackground(Color.GREEN);
		label.setVisible(false);
		contentPane.add(label);

		JButton button = new JButton(TEXTO_BOTON);
		button.addActionListener(new ButtonActionListener(label));
		contentPane.add(button);

		frame.pack();
		frame.setVisible(true);
	}

	public static void main(String args[]) {
		Simple03GUI p = new Simple03GUI();
		p.creaGUI();
	}
}

	  

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JLabel;
import java.awt.Color;

class ButtonActionListener implements ActionListener {

	private static final String TEXTO_ETIQUETA  = "¡El texto de la etiqueta aparece!";

	private JLabel label;

	public ButtonActionListener(JLabel label) {
		this.label = label;
	}

	public void actionPerformed(ActionEvent e) {
		System.out.println(Thread.currentThread().getName() + ": Haciendo que aparezca el texto del la etiqueta.");
		label.setText(TEXTO_ETIQUETA);
		label.setVisible(true);
	}
	
}

	  

TwoButtons en una única clase (Descargalo aquí)

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.Object;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class TwoButtons implements ActionListener {

    private  static  final  String  FRAME_TITLE ="TwoButtons";
    private  static  final  String  BUTTON_TEXT ="Click me!";
    private  JButton  pushed ;
    private  JButton  disabled ;

    TwoButtons( ) {
        pushed =null;
        disabled =null;
        return;
    }
    
    private void createGUI( )  {
        JFrame.setDefaultLookAndFeelDecorated(true);
        JFrame frame = new JFrame("TwoButtons");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel contentPane=(JPanel)frame.getContentPane();

        JButton left = new JButton("Click me!");
        JButton rigth =  new JButton("Click me!");
        pushed =rigth;
        disabled =left;

        left.addActionListener(this);
        rigth.addActionListener(this);

        contentPane.add(left,"West");
        contentPane.add(rigth,"East");

        frame.pack();
        frame.setVisible(true);
        return;
    }
    
    private void changeButtonRoles( ) {
        JButton temp = pushed;
        pushed = disabled;
        disabled = temp;
        return;
    }

    public void enableDisable( ) {
        pushed.setEnabled(false);
        disabled.setEnabled(true);
        return;
    }
    public void actionPerformed(ActionEvent e) {
        changeButtonRoles();
        enableDisable();
        return;
    }

    public  static   void main(String [] aStringArray_0) {
        TwoButtons t= new TwoButtons();
        t.createGUI();
        t.enableDisable();
        return;
    }
}

	  

TwoButtons en varias clases(Descargalo aquí)

import java.awt.Component;
import java.lang.Object;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class TwoButtons {

    private  static  final  String  FRAME_TITLE ="TwoButtons";
    private  static  final  String  BUTTON_TEXT ="Click me!";

    private void createGUI( )  {
        JFrame.setDefaultLookAndFeelDecorated(true);
        JFrame frame = new JFrame("TwoButtons");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel contentPane=(JPanel)frame.getContentPane();

        JButton left = new JButton("Click me!");
        JButton rigth =  new JButton("Click me!");
        rigth.setEnabled(false);
        left.setEnabled(true);

        ButtonActionListener buttonListener = new ButtonActionListener(rigth, left);
        left.addActionListener(buttonListener);
        rigth.addActionListener(buttonListener);

        contentPane.add(left,"West");
        contentPane.add(rigth,"East");

        frame.pack();
        frame.setVisible(true);
        return;
    }
    

    public  static   void main(String [] aStringArray_0) {
        TwoButtons t= new TwoButtons();
        t.createGUI();
        return;
    }
}

	  

-----------------

import javax.swing.JButton;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ButtonActionListener implements ActionListener {
    private  JButton  pushed ;
    private  JButton  disabled ;

    ButtonActionListener (JButton b1, JButton b2 ) {
        pushed =b1;
        disabled =b2;
    }

    private void changeButtonRoles( ) {
        JButton temp = pushed;
        pushed = disabled;
        disabled = temp;
        return;
    }

    public void enableDisable( ) {
        pushed.setEnabled(false);
        disabled.setEnabled(true);
        return;
    }

    public void actionPerformed(ActionEvent e) {
        changeButtonRoles();
        enableDisable();
        return;
    }
}

	  

Soluciones

El código con la solución del ejercicio se muestra a continuación:

   import javax.swing.*;
   import javax.swing.event.*;
   import java.awt.*;
   import java.awt.event.*; 
 
    /**
     * This class implements a square of the board as a button. The button has 
     * to mantain the correct state (the owner's player) and has to change it
     * according to the game's rules. 
     */
     public  class TicTacToeButton extends JButton {
        
		    // State variables 
		   /**
		     * Indicates if square is free, it can be occupied by the other player.
		     */
		      public static final int FREE = -1;
		     
		   /**
		     * The square is occupied by player  #1
		     */
		      public static final int PLAYER_1 = 0;
		   	
		   /**
		     * The square is occupied by player  #2
		     */
		      public static final int PLAYER_2 = 1;
		
	    /**
	     * This array stores the buttons' images.
	     */
	      public static Icon[] images;				
				
				// Static constructor
			static {
	        // Creating the images' array to make them accesible.
	         images = new ImageIcon[] { 
	               new ImageIcon("img/x.jpg"),
	               new ImageIcon("img/o.jpg")
	               };			
			}	
   
         /**
      	 * The state of the button, that is, the owner's player.			 
      	 */
         private int ownerPlayer;
      
      
        /**
         * Default constructor.
         */
          public TicTacToeButton() {
            // First of all, always we call to the base class constructor (always)
            super();
				// Adjusting the state to FREE
				setPlayer(FREE);
         }
      

        /**
         * Return whether the button's state is free or not.
         *
         * @return true if it is free, or false if it is owned by a player.
         */
          public boolean isFree() {
            return ownerPlayer == FREE;
         }
      
        /**
         * This method updates the state of the button with the new player that is passed
      	*  as parameter. 
         *
         * @param newPlayer The new player that has "marked" the square, that is, that has 
			* 						clicked the botton.
         */
          public void setPlayer(int newPlayer) {
         	// Update the new player
            ownerPlayer = newPlayer;
         	// Changing the button's icon according to the state.
            if (ownerPlayer == FREE) {
					// calling the super class method to delete the button's image.
               setIcon(null);
            } 
            else {
					// calling the super class method to update the button's image.
               setIcon( images[ ownerPlayer ] );
            }
         	
         }
        
        /**
         * Returns the button's state, that is, the owner of the square(button).
         *
         * @return The button's owner player.
         */
          public int getPlayer() { 
            return ownerPlayer; 
         }
        /**
         * The main method of the class
         *
         * @param args The parameters' array.
         */
       public static void main(String[] args) {
        
       	int player = 0;
			
         // Create a window.  Use JFrame since this window will include 
         // lightweight components.
         JFrame frame = new JFrame("Demo TicTacToeButton");
			
			JLabel lTitle = new JLabel();
		  
         // Create a button.
         TicTacToeButton bTic = new TicTacToeButton();
			
			// Adjusting the state according to the argument
			if ( args.length == 1 ) {
					player = Integer.parseInt(args[0]) ;
					if ( player == 0 || player == 1 || player == -1 )
						bTic.setPlayer( Integer.parseInt(args[0]) );
					else  {
						 javax.swing.JOptionPane.showMessageDialog(frame, "Valor Argumento incorrecto.Los únicos posibles son -1, 0 o 1." );
                   System.exit(0);
					}

			}

			switch ( player ) {
				case -1:
					lTitle.setText("Casilla LIBRE (FREE) -> Estado -1");
					break;
				case 0:
					lTitle.setText("Casilla JUGADOR_1 (PLAYER_1) -> Estado 0");
					break;
				case 1:
					lTitle.setText("Casilla JUGADOR_2 (PLAYER_2) -> Estado 1");
					break;
				default:
					break;
			}
							  
      
        // Registering a Listener to react to the window closing event
        // We use an anonymous class to implement the interface's method. 
         frame.addWindowListener(
                new WindowAdapter() {
                   public void windowClosing(WindowEvent e) {System.exit(0);}
               });
        
        // Finally, we set the size of the window and we show it
		  frame.getContentPane().add(bTic, BorderLayout.CENTER);
		  frame.getContentPane().add(lTitle, BorderLayout.NORTH);		  

         frame.setSize(300, 300);
         frame.setVisible(true);
        
      
      }
   
   }

	  

   import javax.swing.*;
   import javax.swing.event.*;
   import java.awt.*;
   import java.awt.event.*;

/**
 * This class models the TicTacToe game. It extends from JFrame and
 * builds the board as a bidimentional matrix of Buttons. Event Management
 * is achived in a centralized  manner by  using a single Event Listener.
 * 
 * @author DIT - UC3M
 * @version 1.0
 */
    public class TicTacToe extends JFrame {
   
    // NON GRAPHIC ATTRIBUTES DECLARATION
   /**
     * Window's title.
     */
      public static final String TITTLE = "3 en raya";
    
   /**
     * The size of the board (CONSTANT).
     */
      public static final int BOARD_SIZE = 3;
   
    /**
     *  This array stores the number (counter) of figures placed by each player. 
     */
      public static int[] placedFigures = { 0, 0 };   
   
    /**
     * Indicates the actual turn's player.
     */
      private int turnPlayer;    
    
    // GRAPHIC ATTRIBUTES DECLARATION 
   
    /**
     * Label that shows the actual turn player.
     */    
      private JLabel actualTurn;
   	
    /**
     *	Label that shows the image of the actual turn player.
     * 
     */    
      private JLabel labelFigure;
    
     /**
     *  Button's bidimensional array that represents the main board of the game.
     */    
      private TicTacToeButton[][] board;
   	
    /**
     * El panel que contiene el tablero con los botones (casillas).
     */    
      private JPanel panel_board;
   
    /**
     * El panel que contiene las etiquetas (JLabels).
     */    
      private JPanel panel_info;		
    
    // Window's dimension
    
    /**
     * Window's width (CONSTANT).
     */
      public static final int WIDTH = 400;
   	
    /**
     * Window's height (CONSTANT).
     */
      static final int HEIGHT = 400;
   
   	   
   
    /**
     *  Class Constructor.
     *
     * @param title The game's title..
     */
       public TicTacToe( String title ) {
      
         super(title);
      
        // Building graphics elements of the game (using an auxiliary method).
         buildGraphicElements();
        
        // Adding graphic elements to the containers (using an auxiliary method).
         addElementsToContainers();
      
        // Creating the Event Listener (using an auxiliary method).
         createEventListener();
        
        // The rest of the initialization process.
         turnPlayer = TicTacToeButton.PLAYER_1;
        
        // After all, we should pack previously to show.
         pack();
       
      
      }
   
   
    /**
     * This method creates the graphic elements of the board (labels, buttons, panels, etc...)
     */
       private void buildGraphicElements() {
      
        
        // A descriptive label showing the corresponding turn.
         actualTurn = new JLabel("TURNO: [Jugador_"+ TicTacToeButton.PLAYER_1+"] - ");
        
         // Starting with Player #1
         labelFigure = new JLabel(TicTacToeButton.images[ TicTacToeButton.PLAYER_1]);
         
        // Creating the main buttons' array to add to the panel later.
         board = new TicTacToeButton[BOARD_SIZE][BOARD_SIZE];
         for (int f=0; f<BOARD_SIZE; f++) {
            for (int c=0; c<BOARD_SIZE; c++) {
               board[f][c] = new TicTacToeButton();
            }
         }
      
      }
   
    /**
     * This auxiliary method adds elements to its containers respectively.
     */
       private void addElementsToContainers(){
      
        // Creating the panels to add elements
      // The main board panel
         panel_board = new JPanel();
         panel_board.setLayout(new GridLayout(BOARD_SIZE, BOARD_SIZE));
      	
        //adding buttons to the container
         for (int f=0; f<BOARD_SIZE; f++) {
            for (int c=0; c<BOARD_SIZE; c++) {
               panel_board.add(board[f][c]);
            }
         }
        
      // The info's panel ("Flowlayout" as default)
         panel_info = new JPanel();
      // Adding the actual turn player info and the associated image.
         panel_info.add(actualTurn);
         panel_info.add(labelFigure);
      
        // Finally, adding the previous panels to the main panel container ("BorderLayout" as default)
      // We add the info's panel to the North and the board's panel to the South.
      // But first of all, we have to obtain a reference to the Main's Window panel container.
         Container content = getContentPane();
         content.add(panel_info,BorderLayout.NORTH);
         content.add(panel_board,BorderLayout.CENTER);
      
      }
   
    /**
     * This auxiliary method configures the Event Listener for the graphic elements (Buttons) .
     */
       private void createEventListener() {
      
      	// First of all, Create the Listener that manages the events of the buttons
         TicTacToeButtonListener butListen  = new TicTacToeButtonListener(this);
      
      
      // Finally, registering the Listener on each element source of events, in this case,
      // each button.
         for (int f=0; f<BOARD_SIZE; f++) 
            for (int c=0; c<BOARD_SIZE; c++) 
               board[f][c].addActionListener(butListen);
      }
   
   /**
     * This auxiliary method changes the turn of the player. 
     */
       private void changeTurn() {
         if (turnPlayer ==  TicTacToeButton.PLAYER_1) {
            turnPlayer =  TicTacToeButton.PLAYER_2;
            actualTurn.setText("TURNO Jugador_"+ TicTacToeButton.PLAYER_2);
            labelFigure.setIcon(TicTacToeButton.images[ TicTacToeButton.PLAYER_2]);
            
         }
         else {
            turnPlayer =  TicTacToeButton.PLAYER_1;
            actualTurn.setText("TURNO Jugador_"+ TicTacToeButton.PLAYER_1);
            labelFigure.setIcon(TicTacToeButton.images[ TicTacToeButton.PLAYER_1]);
         }
      }
   
      /**
     * This auxiliary method test if the owner has won the game. 
     */
       private boolean hasWon( int player ) {
      
         int countFigures = 0;	
      	// Test if there's a line of figures of the player
      	// Horizontal lines
         for (int i=0; i<BOARD_SIZE; i++) {
            countFigures = 0;
            for (int j=0; j<BOARD_SIZE; j++) {
               if ( board[i][j].getPlayer() == player ) {
                  countFigures ++;
                  if ( countFigures == BOARD_SIZE ) {
                     return true;
                  }
               }
            }
         }
      	
      	// Vertical lines
         for (int i=0; i<BOARD_SIZE; i++) {
            countFigures = 0;
            for (int j=0; j<BOARD_SIZE; j++) {
               if ( board[j][i].getPlayer() == player ) {
                  countFigures ++;
                  if ( countFigures == BOARD_SIZE ) {
                     return true;
                  }
               }
            }
         }    	
      	
       	// First Diagonal 
         countFigures = 0;
         for (int i=0; i<BOARD_SIZE; i++) {
         
            if ( board[i][i].getPlayer() == player ) {
               countFigures ++;
               if ( countFigures == BOARD_SIZE ) {
                  return true;
               }
            }
         }  
      	
         countFigures = 0;	    	
      	// First Diagonal
         for (int i=0; i<BOARD_SIZE; i++) {
            if ( board[BOARD_SIZE-(i+1)][i].getPlayer() == player ) {
               countFigures ++;
               if ( countFigures == BOARD_SIZE ) {
                  return true;
               }
            }
         }
         return false;    
      }
   	
   	
        /**
         * The main method of the class
         *
         * @param args The parameters' array.
         */
       public static void main(String[] args) {
        
        // Building a TicTacToe's instance
         TicTacToe game = new TicTacToe(TicTacToe.TITTLE);
      
        // Registering a Listener to react to the window closing event
        // We use an anonymous class to implement the interface's method. 
         game.addWindowListener(
                new WindowAdapter() {
                   public void windowClosing(WindowEvent e) {System.exit(0);}
               });
        
        // Finally, we set the size of the window and we show it
         game.setSize(WIDTH, HEIGHT);
         game.setVisible(true);
        
      
      }
   			
      
   /**
     * This class implements de Listener of events that will be produced by the buttons of the
     * main board. The Events will be thrown as ActionEvents and, consequentlly, it has to
     * implement the corresponding method of the interface ActionListener.
     */
       class TicTacToeButtonListener implements ActionListener {
        
      	/**   	
      	 *  We need a reference to the frame to access the elements we want to change.
      	 */
         private JFrame miFrame;
        
        /**
         * Class constructor.
      	*
         * @param frame The frame that we need to store so we can acces  the elements to modify later.
         */
          public TicTacToeButtonListener( JFrame frame ) {
            
            this.miFrame = frame;
            
         }
      	
        
        /**
         *  This is the method of the ActionListener interface that has to be overwritten.
         *
         * @param event The ActionEvent's event that is thrown when the button is clicked.
         */
          public void actionPerformed(ActionEvent event) {
            // First of all, we have to obtain the reference of the button that has been pressed.
            TicTacToeButton clickedButton = (TicTacToeButton) event.getSource();
            
            // If the player has still figures left to put (the size of the board)
            if (placedFigures[turnPlayer] < BOARD_SIZE) { 
                
                // We check if the square is free or not
               if (clickedButton.isFree()) {
                    // We update the state of the square, that is, the button.
                  clickedButton.setPlayer(turnPlayer);
               	
               	// Incrementing the counter of placed figures of the player
                  ((TicTacToe)miFrame).placedFigures[turnPlayer]++;
                  
               	// Check if we have won the game
                  if ( placedFigures[turnPlayer] == BOARD_SIZE) {
                  		// Check if the player has won the game
                     if ( hasWon(turnPlayer) ) {
                     		 // ¡¡ GREETINGS, THE PLAYER HAS WON THE GAME !!
                        javax.swing.JOptionPane.showMessageDialog(miFrame, "¡¡ ENHORABUENA, JUGADOR_"+turnPlayer+","+ 
                           	"HAS GANADO EL JUEGO !!" );
                        System.exit(0);
                     }
                  
                  }
                    // And, finally, we change the player's turn 
                  changeTurn();
               } 
               else {  
                    // We show a Message Dialog with an error message.
                  javax.swing.JOptionPane.showMessageDialog(miFrame, "No se puede poner ahí el símbolo.");
               }
                
            } 
            else {  
            	// We have no figures left, we must take out one to move it.
               actualTurn.setText("¡HAY QUE MOVER UN SÍMBOLO!");
               // We have to check whether we are the correct player to take it out
               if (clickedButton.getPlayer() == turnPlayer ) {
                    // in that case, the square becomes free
                  clickedButton.setPlayer( TicTacToeButton.FREE);
               	
               	// Decrementing the counter of placed figures
                  ((TicTacToe)miFrame).placedFigures[turnPlayer]--;
               } 
               else {
                    // We are not the correct player so we alert.
                  javax.swing.JOptionPane.showMessageDialog(miFrame, "No se puede poner ahí el símbolo.");
               }
            }
         }
      }		
   
   }


	  

Soluciones

El código con la solución del ejercicio se muestra a continuación:

   import javax.swing.*;
   import javax.swing.event.*;
   import java.awt.*;
   import java.awt.event.*; 
 
    /**
     * This class implements a square of the board as a button. The button has 
     * to mantain the correct state (the owner's player) and has to change it
     * according to the game's rules. 
     */
     public  class TicTacToeButtonTimer extends JButton {
        
		    // State variables 
		   /**
		     * Indicates if square is free, it can be occupied by the other player.
		     */
		      public static final int FREE = -1;
		     
		   /**
		     * The square is occupied by player  #1
		     */
		      public static final int PLAYER_1 = 0;
		   	
		   /**
		     * The square is occupied by player  #2
		     */
		      public static final int PLAYER_2 = 1;
		
	    /**
	     * This array stores the buttons' images.
	     */
	      public static Icon[] images;				
				
				// Static constructor
			static {
	        // Creating the images' array to make them accesible.
	         images = new ImageIcon[] { 
	               new ImageIcon("img/x.jpg"),
	               new ImageIcon("img/o.jpg")
	               };			
			}	
   
         /**
      	 * The state of the button, that is, the owner's player.			 
      	 */
         private int ownerPlayer;
      
      
        /**
         * Default constructor.
         */
          public TicTacToeButtonTimer() {
            // First of all, always we call to the base class constructor (always)
            super();
				// Adjusting the state to FREE
				setPlayer(FREE);
         }
      

        /**
         * Return whether the button's state is free or not.
         *
         * @return true if it is free, or false if it is owned by a player.
         */
          public boolean isFree() {
            return ownerPlayer == FREE;
         }
      
        /**
         * This method updates the state of the button with the new player that is passed
      	*  as parameter. 
         *
         * @param newPlayer The new player that has "marked" the square, that is, that has 
			* 						clicked the botton.
         */
          public void setPlayer(int newPlayer) {
         	// Update the new player
            ownerPlayer = newPlayer;
         	// Changing the button's icon according to the state.
            if (ownerPlayer == FREE) {
					// calling the super class method to delete the button's image.
               setIcon(null);
            } 
            else {
					// calling the super class method to update the button's image.
               setIcon( images[ ownerPlayer ] );
            }
         	
         }
        
        /**
         * Returns the button's state, that is, the owner of the square(button).
         *
         * @return The button's owner player.
         */
          public int getPlayer() { 
            return ownerPlayer; 
         }
        /**
         * The main method of the class
         *
         * @param args The parameters' array.
         */
       public static void main(String[] args) {
        
       	int player = 0;
			
         // Create a window.  Use JFrame since this window will include 
         // lightweight components.
         JFrame frame = new JFrame("Demo TicTacToeButton");
			
			JLabel lTitle = new JLabel();
		  
         // Create a button.
         TicTacToeButtonTimer bTic = new TicTacToeButtonTimer();
			
			// Adjusting the state according to the argument
			if ( args.length == 1 ) {
					player = Integer.parseInt(args[0]) ;
					if ( player == 0 || player == 1 || player == -1 )
						bTic.setPlayer( Integer.parseInt(args[0]) );
					else  {
						 javax.swing.JOptionPane.showMessageDialog(frame, "Valor Argumento incorrecto.Los únicos posibles son -1, 0 o 1." );
                   System.exit(0);
					}

			}

			switch ( player ) {
				case -1:
					lTitle.setText("Casilla LIBRE (FREE) -> Estado -1");
					break;
				case 0:
					lTitle.setText("Casilla JUGADOR_1 (PLAYER_1) -> Estado 0");
					break;
				case 1:
					lTitle.setText("Casilla JUGADOR_2 (PLAYER_2) -> Estado 1");
					break;
				default:
					break;
			}
							  
      
        // Registering a Listener to react to the window closing event
        // We use an anonymous class to implement the interface's method. 
         frame.addWindowListener(
                new WindowAdapter() {
                   public void windowClosing(WindowEvent e) {System.exit(0);}
               });
        
        // Finally, we set the size of the window and we show it
		  frame.getContentPane().add(bTic, BorderLayout.CENTER);
		  frame.getContentPane().add(lTitle, BorderLayout.NORTH);		  

         frame.setSize(300, 300);
         frame.setVisible(true);
        
      
      }
   
   }

	  

   import javax.swing.*;
   import javax.swing.event.*;
   import java.awt.*;
   import java.awt.event.*;

/**
 * This class models the TicTacToe game. It extends from JFrame and
 * builds the board as a bidimentional matrix of Buttons. Event Management
 * is achived in a centralized  manner by  using a single Event Listener.
 * 
 * @author DIT - UC3M
 * @version 1.0
 */
    public class TicTacToeTimer extends JFrame {
   
    // NON GRAPHIC ATTRIBUTES DECLARATION
   /**
     * Window's title.
     */
      public static final String TITTLE = "3 en raya";
    
   /**
     * The size of the board (CONSTANT).
     */
      public static final int BOARD_SIZE = 3;
   
    /**
     *  This array stores the number (counter) of figures placed by each player. 
     */
      public static int[] placedFigures = { 0, 0 };   
   
    /**
     * Indicates the actual turn's player.
     */
      private int turnPlayer;    
    
    // GRAPHIC ATTRIBUTES DECLARATION 
   
    /**
     * Label that shows the actual turn player.
     */    
      private JLabel actualTurn;
   	
    /**
     *	Label that shows the image of the actual turn player.
     * 
     */    
      private JLabel labelFigure;
    
     /**
     *  Button's bidimensional array that represents the main board of the game.
     */    
      private TicTacToeButton[][] board;
   	
    /**
     * El panel que contiene el tablero con los botones (casillas).
     */    
      private JPanel panel_board;
   
    /**
     * El panel que contiene las etiquetas (JLabels).
     */    
      private JPanel panel_info;	
   
    
    // Window's dimension
    
    /**
     * Window's width (CONSTANT).
     */
      public static final int WIDTH = 400;
   	
    /**
     * Window's height (CONSTANT).
     */
      static final int HEIGHT = 400;
   	
   	
    /**
    *  Maximum time for each turn (miliseconds)
    */	
      static final int MAX_TURN_TIME = 10000;
   	   
    /**
    *	Label that holds the turn's time remaining.
    */
      public JLabel labelTimer;	
   	
    /**
    *	The timer.
    */		
      public Timer t;
   	
   	   
    /**
     *  Class Constructor.
     *
     * @param title The game's title..
     */
       public TicTacToeTimer( String title ) {
      
         super(title);
      
        // Building graphics elements of the game (using an auxiliary method).
         buildGraphicElements();
        
        // Adding graphic elements to the containers (using an auxiliary method).
         addElementsToContainers();
      
        // Creating the Event Listener (using an auxiliary method).
         createEventListener();
        
        // The rest of the initialization process.
         turnPlayer = TicTacToeButton.PLAYER_1;
        
        // After all, we should pack previously to show.
         pack();
      	
      	// Now we create the Timer object
         t = new Timer( 1000, new TimerListener(this) );
      	
         t.start(); 
       
      
      }
   
   
    /**
     * This method creates the graphic elements of the board (labels, buttons, panels, etc...)
     */
       private void buildGraphicElements() {
      
        
        // A descriptive label showing the corresponding turn.
         actualTurn = new JLabel("TURNO: [Jugador_"+ TicTacToeButton.PLAYER_1+"] - ");
      	
      	// A label to show the time remaining
         labelTimer = new JLabel("Tiempo restante : ");
        
         // Starting with Player #1
         labelFigure = new JLabel(TicTacToeButton.images[ TicTacToeButton.PLAYER_1]);
      	
         
        // Creating the main buttons' array to add to the panel later.
         board = new TicTacToeButton[BOARD_SIZE][BOARD_SIZE];
         for (int f=0; f<BOARD_SIZE; f++) {
            for (int c=0; c<BOARD_SIZE; c++) {
               board[f][c] = new TicTacToeButton();
            }
         }
      
      }
   
    /**
     * This auxiliary method adds elements to its containers respectively.
     */
       private void addElementsToContainers(){
      
        // Creating the panels to add elements
      // The main board panel
         panel_board = new JPanel();
         panel_board.setLayout(new GridLayout(BOARD_SIZE, BOARD_SIZE));
      	
        //adding buttons to the container
         for (int f=0; f<BOARD_SIZE; f++) {
            for (int c=0; c<BOARD_SIZE; c++) {
               panel_board.add(board[f][c]);
            }
         }
        
      // The info's panel ("Flowlayout" as default)
         panel_info = new JPanel();
      // Adding the actual turn player info and the associated image.
         panel_info.add(actualTurn);
         panel_info.add(labelFigure);
      	// Adding the label with the time remaining
         panel_info.add(labelTimer);
      
        // Finally, adding the previous panels to the main panel container ("BorderLayout" as default)
      // We add the info's panel to the North and the board's panel to the South.
      // But first of all, we have to obtain a reference to the Main's Window panel container.
         Container content = getContentPane();
         content.add(panel_info,BorderLayout.NORTH);
         content.add(panel_board,BorderLayout.CENTER);
      
      }
   
    /**
     * This auxiliary method configures the Event Listener for the graphic elements (Buttons) .
     */
       private void createEventListener() {
      
      	// First of all, Create the Listener that manages the events of the buttons
         TicTacToeButtonListener butListen  = new TicTacToeButtonListener(this);
      
      
      // Finally, registering the Listener on each element source of events, in this case,
      // each button.
         for (int f=0; f<BOARD_SIZE; f++) 
            for (int c=0; c<BOARD_SIZE; c++) 
               board[f][c].addActionListener(butListen);
      }
   
   /**
     * This auxiliary method changes the turn of the player. 
     */
       public void changeTurn() {
       
			// Reset the second's counter
			TimerListener.sec_count=0;
			
         if (turnPlayer ==  TicTacToeButton.PLAYER_1) {
            turnPlayer =  TicTacToeButton.PLAYER_2;
            actualTurn.setText("TURNO Jugador_"+ TicTacToeButton.PLAYER_2);
            labelFigure.setIcon(TicTacToeButton.images[ TicTacToeButton.PLAYER_2]);
            
         }
         else {
            turnPlayer =  TicTacToeButton.PLAYER_1;
            actualTurn.setText("TURNO Jugador_"+ TicTacToeButton.PLAYER_1);
            labelFigure.setIcon(TicTacToeButton.images[ TicTacToeButton.PLAYER_1]);
         }
		}
   
      /**
     * This auxiliary method test if the owner has won the game. 
     */
       private boolean hasWon( int player ) {
      
         int countFigures = 0;	
      	// Test if there's a line of figures of the player
      	// Horizontal lines
         for (int i=0; i<BOARD_SIZE; i++) {
            countFigures = 0;
            for (int j=0; j<BOARD_SIZE; j++) {
               if ( board[i][j].getPlayer() == player ) {
                  countFigures ++;
                  if ( countFigures == BOARD_SIZE ) {
                     return true;
                  }
               }
            }
         }
      	
      	// Vertical lines
         for (int i=0; i<BOARD_SIZE; i++) {
            countFigures = 0;
            for (int j=0; j<BOARD_SIZE; j++) {
               if ( board[j][i].getPlayer() == player ) {
                  countFigures ++;
                  if ( countFigures == BOARD_SIZE ) {
                     return true;
                  }
               }
            }
         }    	
      	
       	// First Diagonal 
         countFigures = 0;
         for (int i=0; i<BOARD_SIZE; i++) {
         
            if ( board[i][i].getPlayer() == player ) {
               countFigures ++;
               if ( countFigures == BOARD_SIZE ) {
                  return true;
               }
            }
         }  
      	
         countFigures = 0;	    	
      	// First Diagonal
         for (int i=0; i<BOARD_SIZE; i++) {
            if ( board[BOARD_SIZE-(i+1)][i].getPlayer() == player ) {
               countFigures ++;
               if ( countFigures == BOARD_SIZE ) {
                  return true;
               }
            }
         }
         return false;    
      }
   	
   	
        /**
         * The main method of the class
         *
         * @param args The parameters' array.
         */
       public static void main(String[] args) {
        
        // Building a TicTacToe's instance
         TicTacToeTimer game = new TicTacToeTimer(TicTacToeTimer.TITTLE);
      
        // Registering a Listener to react to the window closing event
        // We use an anonymous class to implement the interface's method. 
         game.addWindowListener(
                new WindowAdapter() {
                   public void windowClosing(WindowEvent e) {System.exit(0);}
               });
        
        // Finally, we set the size of the window and we show it
         game.setSize(WIDTH, HEIGHT);
         game.setVisible(true);
        
      
      }
   			
      
   /**
     * This class implements de Listener of events that will be produced by the buttons of the
     * main board. The Events will be thrown as ActionEvents and, consequentlly, it has to
     * implement the corresponding method of the interface ActionListener.
     */
       class TicTacToeButtonListener implements ActionListener {
        
      	/**   	
      	 *  We need a reference to the frame to access the elements we want to change.
      	 */
         private JFrame miFrame;
        
        /**
         * Class constructor.
      	*
         * @param frame The frame that we need to store so we can acces  the elements to modify later.
         */
          public TicTacToeButtonListener( JFrame frame ) {
            
            this.miFrame = frame;
            
         }
      	
        
        /**
         *  This is the method of the ActionListener interface that has to be overwritten.
         *
         * @param event The ActionEvent's event that is thrown when the button is clicked.
         */
          public void actionPerformed(ActionEvent event) {
            // First of all, we have to obtain the reference of the button that has been pressed.
            TicTacToeButton clickedButton = (TicTacToeButton) event.getSource();
            
            // If the player has still figures left to put (the size of the board)
            if (placedFigures[turnPlayer] < BOARD_SIZE) { 
                
                // We check if the square is free or not
               if (clickedButton.isFree()) {
                    // We update the state of the square, that is, the button.
                  clickedButton.setPlayer(turnPlayer);
               	
               	// Incrementing the counter of placed figures of the player
                  ((TicTacToeTimer)miFrame).placedFigures[turnPlayer]++;
                  
               	// Check if we have won the game
                  if ( placedFigures[turnPlayer] == BOARD_SIZE) {
                  		// Check if the player has won the game
                     if ( hasWon(turnPlayer) ) {
                     		 // ¡¡ GREETINGS, THE PLAYER HAS WON THE GAME !!
                        javax.swing.JOptionPane.showMessageDialog(miFrame, "¡¡ ENHORABUENA, JUGADOR_"+turnPlayer+","+ 
                           	"HAS GANADO EL JUEGO !!" );
                        System.exit(0);
                     }
                  
                  }
                    // And, finally, we change the player's turn 
                  changeTurn();
               } 
               else {  
                    // We show a Message Dialog with an error message.
                  javax.swing.JOptionPane.showMessageDialog(miFrame, "No se puede poner ahí el símbolo.");
               }
                
            } 
            else {  
            	// We have no figures left, we must take out one to move it.
               actualTurn.setText("¡HAY QUE MOVER UN SÍMBOLO!");
               // We have to check whether we are the correct player to take it out
               if (clickedButton.getPlayer() == turnPlayer ) {
                    // in that case, the square becomes free
                  clickedButton.setPlayer( TicTacToeButton.FREE);
               	
               	// Decrementing the counter of placed figures
                  ((TicTacToeTimer)miFrame).placedFigures[turnPlayer]--;
               } 
               else {
                    // We are not the correct player so we alert.
                  javax.swing.JOptionPane.showMessageDialog(miFrame, "No se puede poner ahí el símbolo.");
               }
            }
         }
      }		
   
   }



    class TimerListener implements ActionListener {
   
      	/**   	
      	 *  We need a reference to the frame to access the elements we want to change.
      	 */
      private JFrame miFrame;
        
        /**
         * Class constructor.
      	*
         * @param frame The frame that we need to store so we can acces  the elements to modify later.
         */
       public TimerListener( JFrame frame ) {
            
         this.miFrame = frame;
            
      }
   		
   		// The second's counter
      public static int sec_count=0; 
   
   		/**
         *  This is the method of the ActionListener interface that has to be overwritten.
         *
         * @param event The ActionEvent's event that is thrown when the time period has been reached.
         */
       public void actionPerformed(ActionEvent event) {
      	 
         int temp = TicTacToeTimer.MAX_TURN_TIME - sec_count*1000;
      			
         if ( temp < 0 ) {
            sec_count=0;
            javax.swing.JOptionPane.showMessageDialog(miFrame, "¡¡ Se ha acabado el tiempo !!" );
         			
            ((TicTacToeTimer)miFrame).changeTurn();
         
         }
         else {
          
            ((TicTacToeTimer)miFrame).labelTimer.setText("Tiempo restante : "+temp/1000);
         		
            sec_count++;
         }
      			
      			
      			
      	 
      }
   
   
   }