Universidad Carlos III de Madrid

En este ejercicio debes finalizar la calculadora que empezaste a programar en la práctica anterior. Utiliza tu solución a dicha práctica como punto de partida. Si no tienes el código a mano, utiliza la solución oficial que se ha publicado para dicho ejercicio.

Para simplificar el problema, esta versión de la calculadora sólo debe trabajar con números enteros. Por tanto, deshabilita en la interfaz el botón ".", de tal forma que no sea pinchable.

Se te proporciona la lógica interna de la calculadora ya programada en la clase CalculatorLogic que se muestra a continuación, pero necesitarás enlazarla adecuadamente con tu interfaz gráfica. Esta clase dispone de métodos públicos para que, cada vez que el usuario pulse un botón, se lo comuniques. Además, tras comunicar cada pulsación debes invocar al método getDisplay(), que te indicará qué debes mostrar en la pantalla de la calculadora.

/**
 * Class that implements the logic of a basic calculator for integer
 * numbers.
 *
 */
public class CalculatorLogic {
    public static final int OPERATOR_NONE = 0;
    public static final int OPERATOR_SUM = 1;
    public static final int OPERATOR_SUB = 2;
    public static final int OPERATOR_MUL = 3;
    public static final int OPERATOR_DIV = 4;

    private int accumulator;
    private int currentOperand;
    private int currentOperator;
    private boolean operandAvailable;

    /**
     * Creates a new instance of the calculator logic. In its initial
     * state the calculator displays just a zero, the value of its
     * internal accumulator is also zero and there is no operator
     * pending to be applied.
     *
     */
    public CalculatorLogic() {
        pressReset();
    }

    /**
     * Returns the information that should be shown at the display of
     * the calculator for its current state.
     *
     * @return The information to be shown at the display.
     *
     */
    public String getDisplay() {
        String display;
        if (operandAvailable) {
            display = Integer.toString(currentOperand);
        } else {
            display = Integer.toString(accumulator);
        }
        return display;
    }

    /**
     * Notifies that the user has pressed a button with a digit.
     *
     * @param digit The digit the user has pressed (0 to 9).
     *
     */
    public void pressDigit(int digit) {
        currentOperand = currentOperand * 10 + digit;
        operandAvailable = true;
    }

    /**
     * Notifies that the user has pressed a button with an operand.
     *
     * @param operator The operand expressed with one of the constants
     *                 OPERATOR_ADD, OPERATOR_SUB, OPERATOR_MUL or
     *                 OPERATOR_DIV.
     *
     */
    public void pressOperator(int operator) {
        if (operandAvailable) {
            performPendingOperation();
        }
        expectNewOperand(operator);
    }

    /**
     * Notifies that the user has pressed the "=" button.
     *
     */
    public void pressEqual() {
        if (operandAvailable) {
            performPendingOperation();
        }
        expectNewOperand(OPERATOR_NONE);
    }

    /**
     * Notifies that the user has pressed the "C" button, which removes
     * the last digit that was typed by the user.
     *
     */
    public void pressDelete() {
        currentOperand /= 10;
        if (currentOperand == 0) {
            operandAvailable = false;
        }
    }

    /**
     * Notifies that the user has pressed the "AC" button, which
     * resets the state of the calculator to its initial state
     * (display 0, accumulator 0, no pending operators.)
     *
     */
    public void pressReset() {
        accumulator = 0;
        expectNewOperand(OPERATOR_NONE);
    }

    private void expectNewOperand(int operator) {
        currentOperator = operator;
        currentOperand = 0;
        operandAvailable = false;
    }

    private void performPendingOperation() {
        switch (currentOperator) {
        case OPERATOR_NONE:
            accumulator = currentOperand;
            break;
        case OPERATOR_SUM:
            accumulator += currentOperand;
            break;
        case OPERATOR_SUB:
            accumulator -= currentOperand;
            break;
        case OPERATOR_MUL:
            accumulator *= currentOperand;
            break;
        case OPERATOR_DIV:
            accumulator /= currentOperand;
            break;
        }
    }
}

En este ejercicio programarás una interfaz gráfica en que los ojos de un muñeco deben seguir la posición del cursor cuando este se encuentre dentro de la ventana. El programa debe tener una apariencia similar a la siguiente:

El contorno exterior del ojo se está dibujando como un círculo de radio 60. La pupila tiene radio 10. Su posición depende de la posición del cursor dentro de la ventana: debe estar siempre sobre la recta que une el cursor con el centro del ojo, a exactamente 30 píxeles de este último. A continuación se muestra un ejemplo:

Como puedes observar en el esquema que se muestra a continuación, si se conocen las coordenadas del centro del ojo (O), las coordenadas del cursor (C) y la distancia d = 30 píxeles, calcular la posición en que se debe situar la pupila (X) consiste en resolver un problema de semejanza de triángulos rectángulos:

    private void drawCircle(Graphics g, int x, int y, int radius, Color color,
                            boolean filled) {
        int posX = x - radius;
        int posY = y - radius;
        g.setColor(color);
        if (filled) {
            g.fillOval(posX, posY, 2 * radius, 2 * radius);
        } else {
            g.drawOval(posX, posY, 2 * radius, 2 * radius);
        }
    }

Apartado 4

Ahora queremos que, cuando el cursor abandone el área del panel, el muñeco muestre una cara de enfado como se ve en la imagen siguiente, y que recupere la sonrisa cuando el cursor vuelva a entrar. Examina la API de MouseListener para saber cómo detectar cuándo entra o sale el cursor.

En este ejercicio vamos a utilizar un juego conocido, el "Tres en Raya", como ejemplo de Interfaz Gráfica de Usuario (GUI) que integra la correspondiente Gestión de Eventos.

Apartado 1

Implementa en Java el tablero de un tres en raya, tal y como se presenta en la figura. Para ello crea una clase TicTacToe y haz uso de las clases JFrame, JPanel , JLabel y JButton del paquete javax.swing y de las clases BorderLayout y GridLayout del paquete java.awt. Incluye un atributo denominado player en tu clase para mantener el turno del jugador e implementa los métodos get y set correspondientes. Finalmente, implementa un método main que te permita probar esta clase