El juego que nos hemos aventurado a hacer es un “PUZZLE”. Como todo el mundo sabe, el objetivo es completar una imagen que se muestra al inicio de la partida, antes de que se agote el tiempo. La interacción con el usuario se hará mediante el ratón y en la zona de juego que es la siguiente:

 Hemos formada nuestro juego con 9 clases, que son las siguientes:

- PantallaPrincipal: es la que contiene el main y, por ello, la que se ejecuta en primer lugar. Desde aquí podrás acceder, pinchando sobre los botones correspondientes, a la pantallaInstrucciones (creando un objeto de la misma al pulsar el botón “Instrucciones”), elegir un nivel (creando un objeto de la pantallaNivel), ir a la pantalla de juego (creando un objeto de PantallaJugar) o cerrar toda la ejecución (con un System.exit(0)).

- PantallaInstrucciones: crea una ventana que muestra una serie de normas a seguir en el juego. Además contiene dos botones que te permiten salir (pues esta ventana no se puede cerrar mediante la cruz de la misma) o ir a la pantalla de juego.

- PantallaNivel: su función principal es dar un valor a las variables que controlan el número de piezas y el tiempo disponible para completar el puzzle, según el nivel que se seleccione. No se puede salir sin hacer clic sobre el botón “OK”, pues hemos anulado la función del botón X del Jframe mediante el siguiente código en el constructor: this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE)

- PantallaJugar: es la clase que define la pantalla de juego. Un Jlabel situado en la parte superior, te irá mostrando la información que necesitas en cada momento. Esta clase incluye un Timer que actualiza a cada segundo el tiempo restante que te queda para lograr completar el puzzle y un método pintar( ) que coloca las piezas en su sitio inicial. Los botones de abajo te sirven para definir los cambios en el funcionamiento que quiera hacer el usuario: empezar una nueva partida (llama al método pintar e inicializa el Timer), consultar la pista (crea un objeto de la clase BotonPista), resolver (muestra la solución y finaliza tu partida), comprobar las piezas que lleva bien colocadas (llama al método comprobar polución de la clase Sñlgoritmos), salir (cierra limpiamente el programa con un System.exit(0)) y cambiar de nivel (crea un objeto de PantallaInstrucciones).

- BotonPista: cuando el botón “Pista” de la pantalla de juego es pulsado, se crea un objeto de esta clase que implantará una ventana con la imagen que debes formar. También contiene un Timer para controlar su desaparición al cabo de 5 segundos. Cada vez que se pulsa disminuye el tiempo que te queda en 10 segundos como penalizacion.

- Algoritmos: clase auxiliar que implementa varios métodos que se utilizarán en PantallaJugar. Entre ellos están:

- comprobarSolucion ( ): comprueba si la colocación de las piezas que has puesto en el tablero se corresponde con la correcta, con la imagen bien formada. Si es así te mostrará un mensaje de enhorabuena, y si no te dirá cuantas piezas tienes bien colocadas. Esto se hace gracias a un array donde vamos almacenando que pieza hay en cada posición. Se comprueba a cada segundo si el tablero está completo (no falta ninguna pieza por colocar, bien o mal, en él), utilizando el Timer de la clase PantallaJugar, para que si es así se llame a este método.

- crearAleatorios ( ): crea números aleatorios que se almacenarán en variables para controlar cual es la imagen y el orden de las piezas en cada partida. Por tanto la imagen que aparece al empezar una partida y el orden de las piezas, es aleatorio.

- Audio: define el comportamiento de cualquier objeto de sonido, pues deberá  ser de tipo Audio, esta clase esta basada en los ejemplos de teoría. Para que un sonido se reproduzca, tan solo deberás poner nombreObjetoAudio.player.star( ) en el lugar correspondiente y después pararlo cuando querar (por ejemplo al pulsar un botón) con nombreObjetoAudio.player.star( ).

- EventosPiezas: esta clase define el funcionamiento de las piezas de la pantalla de juego. Para ello hemos implementado de MouseListener, y en el método mouseClicked(MouseEvent ev) hemos añadido la funcionalidad que deseábamos que  realice cada pieza al pinchar sobre ella con el ratón. Hay que recordar que aunque no se utilicen, hay que poner todos los métodos que contiene el Mouse Listener.

- EventosTablero: se encarga de crear el movimiento de la zona del tablero de la pantalla de juego. Es una clase muy parecida a la anterior, sólo que describe otro comportamiento.

Pues estas son las pautas generales que hemos seguido para hacer el juego que… visto a si, no parece ni complicado xD pero os aseguro que ha dado mucho que pensar. Encima cuando ya parecía todo hecho porque compilaba, nos aparecían errores de ejecución o nos poníamos a jugar y hacía cosas que no debería… cada vez aparecían más problemas. Pero los fuimos resolviendo uno a uno con mucha paciencia y al final… ¡LO CONSEGIMOS!

Pero entre partida y partida de algunos juegos, conseguimos hacer algo:

Primer y único ejercicio (lo que no hace que la práctica sea corta):

1. Este punto es sencillo, lo más importante (y lo único que merece la pena comentar) es como va a crearse el evento en este caso. Lo primero es no olvidar poner el implements ActionListener. Para añadir nuestro botón (no todos los componentes se podrán añadir) a la interfaz  ActionListener (que se va a encargar de controlar los eventos) hay que poner:

nombreBoton.addActionListener (this);

(El this se pone si hemos heredado de JFrame y lo escribimos dentro del constructor, sino habrá que poner un objeto de tipo ActionListener) De este modo, cada vez que se pinche sobre este botón, se generará un evento. Los eventos son guardados en una cola y por ello el sistema los trata en orden de creación.

Una vez que ya tenemos esto, podemos definir el método actionPerformed que se ejecuta cada vez que se produce un evento sobre cualquier componente añadido al ActionListener. Este método quedará así:

public void actionPerformed(ActionEvent e){
  if (e.getSource( )== nombreBoton){
    System.out.println (“Se ha pulsado el Botón”);
  }

}

El  getSource(), devuelve el nombre del componente que ha producido el evento.

2. Es parecido al anterior pero, en lugar de observar el cambio que produce el evento en la consola, se visualizará en la misma ventana donde se produce el evento. Para esto hay que crear un label (no olvides añadirlo a un panel, para que se pueda ver, y hacer su fondo opaco, para que pueda cambiar de color) y cambiar la sentencia de antes que imprimía un mensaje por pantalla, por un código que haga lo pedido ahora; es decir, que cambie el color de fondo de nuestro label. Para ello, nos ayudaremos del setBackground (Color.BLUE).

3. Ahora sólo hay que añadir que cuando el usuario introduzca un “enter” por la consola, se cambie también el color de fondo de la etiqueta. Para hacer esto nos hemos ayudado de las clases de la práctica anterior que hacían algo parecido… y así fue fácil.

Con las preguntas que te hacen sobre los hilos en este punto, ya nos liamos y no conseguimos avanzar más, la verdad es que no se nos dan nada bien los hilos. Sabemos que en el punto anteriores el hilo que produce el cambio es sólo uno y por tanto el que tenga asignado JAVA por defecto pero ahora… ¿Qué es lo que pasa? ¿Hay dos hilos?.. Puff!!, vaya lío, habrá que trabajar más esto de los hilos a ver si conseguimos llevarnos bien con ellos.

Bye!!

Esta vez empezamos solucionando algunos problemillas del videojuego (que ya parece que va funcionando de verdad), así que no nos dio tiempo a hacer demasiado de esta práctica en clase. Esto fue todo lo que logramos:

Ejercicio 1: Simplemente  hay que ejecutar los tres programas que te dan para entender un poco esto de los hilos. Si no lo veis muy claro no os preocupéis demasiado porque no es algo que suela caer en el examen de OCA y se da a fondo en una asignatura de segundo, “Servidores de Información Multimedia”. Lo más importante es quedarse con la idea de que como Windows no es un Sistema Operativo Multiproceso, un mismo proceso (programa) no puede tener a la vez dos hilos en ejecución. Por esto la clase DingDongPoor no funciona bien porque no se pueden hacer más de una tarea simultáneamente (en este caso dormir durante un segundo y esperar a que se pulse ENTER).

Ejercicio 2: Los hilos se representan en Java mediante la clase Thread y para poder trabajar con ellos debemos crear objetos de esta clase y utilizar sus métodos, uno de ellos es el start() que nos permite lanzar el hilo. Los objetos de la clase Thread no son exactamente hilos, sino secuencias de control que van a controlar a los verdaderos hilos. Una vez que controlamos esto, vamos a analizar las clases que nos dan:

Clase TwoThreads: Creamos en el main un objeto Runnable que se arranca mediante el método run (). Este método llama al PrintThreadName( ) que imprime el nombre del hilo actual, es decir el main, que es lo que nos aparece escrito por consola al ejecutarlo.

El constructor del objeto Thread es el siguiente : Thread (Runnable target), por esto le ponemos como parámetro el objeto Runnable que hemos creado.

Clase TwoThreadsSimple: Hace exactamente lo mismo que la clase anterior pero implementar la interfaz Runnable, lo que nos ahorra el tener que crear un objeto Runnable. Ahora el parámetro del constructor del objeto Thread, será un objeto se nuestra clase que, como implementa de Runnable, es de este tipo.  

Clase TwoThreadsSimple2: También hace lo mismo que las dos anteriores. La diferencia es que ahora heredamos de la clase Thread y no tenemos que crear ni un objeto de la clase Runnable, ni de la case Thread. Ahora al crear un objeto de la clase TwoThreadsSimple2, le podemos aplicar directamente los métodos de Thread.

Ejercicio 3: Hay que saber que la pega de usar multithreading es que no sabemos exactamente el orden en que van a ser ejecutados ni cuando van a ser interrumpidos para realizar otro. Esto se comprueba al ejecutar la clase RaceCondition donde va imprimiéndose un grupo de 1 tras otro grupo de 0 sin dibujar siempre la misma forma.

Y justo aqui fue cuando llegaba la hora de irse, echamos un vistazo a la clase RaceConditionSolved pero no sacamos mucho en claro. Sabemos que ahora tenemos  el objeto Runnable eventDispacherRunnable que controla que el primer hilo no esté ejecutándose en ese momento antes de dejar trabajar al segundo. Pero no entendemos muy bien como consigue hacer esto. Nos pasaremos por algunos blogs, haber si se os ha dado mejor a vosotros.

Ejercicio 1: Primero voy a explicar lo que hace cada línea del código dado:

 1 import javax.swing.JFrame;
 2 import javax.swing.JPanel;
 3 import javax.swing.JLabel;
 
 4 class HelloWorldGUI {
 5   public static void main(String args[]) {
 6      JFrame frame = new JFrame(“HelloWorldGUI window title”);
 7      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

 8      JPanel contentPane = (JPanel) frame.getContentPane();
 9      JLabel label = new JLabel(“Hello World!”);
10     contentPane.add(label);
 
11     frame.setSize(100,50);
12     frame.setVisible(true);
13   }
14 }

Líneas 1,2 y 3. Importan las clases JFrame, JPanel y JLabel para poder crear en nuestra clase objetos de las mismas.

Línea 6. Crea un objeto de la clase importada JFrame llamado frame al que se le pasa como parámetro “HelloWorldGUI window title”. Esto lo que hará es que aparezca este texto en la barra superior (a la izquierda de los botones de minimizar, maximizar y cerrar) de nuestro Jframe o ventana (para que nos entendamos en nuestro lenguaje).

Línea 7. Este método de la clase Jframe consigue que al pulsar sobre el botón cerrar de nuestra ventana (el de la cruz de toda la vida), el programa se cierre de forma limpia, como ocurría con un System.exit(0);

Línea 8. Crea un objeto de la clase importada JPanel llamado contentPane. En este caso nuestro panel es uno específico que ocupa casi toda la ventana. Siempre es necesario crear algún tipo de panel porque si no añadimos nuestros componentes (labels, botones…) a un JPanel no se podrán visualizar ni colocar en un JFrame. Un label (o botón) se añade a un panel mediante la línea de código 10.

Línea 9. Crea un objeto de la clase importada JLabel llamado label que es capaz de mostrar texto (el pasado como parámetro) dentro de una ventana.

Línea 11. Le da un tamaño a nuestra ventana de (100, 500) pixeles. Por tanto si queremos que el tamaño de nuestra ventana sea 4 veces más grande (como nos piden en el punto 5), tan sólo habría que cambiar esta línea de código por:

frame.setSize(400,200);

Línea 12. Este método de la clase JFrame, mostrará (hará visible) nuestra ventana si su valor es true. Si ponemos false, se creará nuestra ventana pero no la veremos.

Para lograr que el fondo de la etiqueta sea de color azul, como nos pedían el punto 6, hay que añadir al código anterior:

label.setOpaque(true);
label.setBackground(Color.BLUE);

Lo que conseguimos con esto es: el método setOpaque, puesto a true, pone el fondo de la etiqueta opaco para que se vea (hay que hacer esto primero porque, por defecto, el fondo es invisible y aunque cambies su color no lo verás si no lo pones) y el método setBackground añade al fondo de la etiqueta el color indicado. No debes olvidar añadir al principio de la clase un import java.awt.Color; para usar la clase Color.

Además, también podemos cambiar el color de las letras de la etiqueta, por ejemplo a blancas, mediante este otro método:

label.setForeground(Color.WHITE);

O se puede incluso cambiar la fuente y el tamaño de la letra:

label.setFont(new Font(“Arial”,Font.BOLD,20));

Pasando al punto 7, vemos que la clase Thread es capaz de controlar la ejecución del programa. Concretamente el método sleep(long millis), hace que el hilo que se encarga de ejecutar nuestra ventana se duerma (cese temporalmente la ejecución) durante el tiempo, en milisegundos, especificado. Por esto, al añadir el nuevo código, nuestro hilo de ejecución espera 10 segundos (que es igual a 10*1000 milisegundos) desde que lo ejecutamos desde la consola hasta que realmente empieza a trabajar y a crear  nuestra ventana.

Respecto al punto 9, no me pareció raro que siga funcionando el programa después de que se ha terminado el código del método main() (para mí lo raro es la pregunta xD), porque cuando termina el main de pintarnos la ventana no hay ninguna sentencia que le mande cerrar o terminar, por ello se sigue viendo hasta que le das al botón cerrar. Esto se comprueba al hacer el punto10 donde, como era de esperar, si añades al final del main la sentencia System.exit(0); ni siquiera te da tiempo a ver la ventana (aunque si se ha creado) pues según termina de pintarse se cierra el programa.

Ejercicio 2: Para ignorar el mensaje de cierre del manejador de ventanas se utiliza la sentencia:

frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

Para cerrar la ventana de otra manera se me ocurre poner un botón “SALIR” que cuando lo pinchas provoca un System.exit(0) pero no creo que sea a lo que se refiere aquí porque aún no hemos visto botones, así que acepto ideas xD.

Otra cosa que se trabaja en este ejercicio es el método:

JFrame.setDefaultLookAndFeelDecorated(true);

que genera una barra superior en la ventana más bonita y con más utilidades y en cambio:

frame.setUndecorated(true);

elimina la barra que viene por defecto y no aparece ninguna.

Ejercicio 3: Algunos datos importantes que he sacado al hacer este ejercicio son:

- Para añadir y colocar componentes dentro del contentPane:

contentPane.add (nombreComponente, BorderLayout.ALINEACIÓN);

donde ALINEACIÓN puede tomar los valores de: CENTER, EAST, WEST, NORTH y SOUTH.

- Para colocar en texto dentro de la etiqueta, por ejemplo al centro, vertical y horizontalmente:

nombrelabel.setHorizontalAlignment (JLabel.CENTER);

nombrelabel.setVerticalAlignment (JLabel.CENTER);  

- Añadir una imagen a un Jlabel:

ImageIcon nombreimagen = new ImageIcon (“imagen.jpg”);

 JLabel nombrelabel = new JLabel(nombreImagen);

Os aconsejo guardar la imagen en la misma carpeta donde esta clase para evitar poner la dirección entera de localización de la imagen que es más lioso. De este modo vale con indicar sólo el nombre con su extensión correspondiente (jpg, gif…). No os olvidéis poner import javax.swing.ImageIcon; para poder usar iconos.

-Para que una ventana no se pueda maximizar:

frame.setResizable (false);

- Para crear una ventana con el tamaño mínimo posible pero donde aparezcan todos los componentes, se utiliza:

frame.pack( );

He comprobado si se puede poner esto y un frame.setSize(x,y) a la vez. No me ha dado error pero no tendría mucho sentido poner el setSize ¿no?, porque saldrá con el tamaño mínimo igual.

Ejercicio 4: Os pongo el código que he hecho en el punto 1 porque lo he comprobado con el de las soluciones y no se parece mucho. Es más sencillo, pero también funciona xD

import javax.swing.*;
import java.awt.*;
import java.awt.Color;
import javax.swing.border.TitledBorder;
import javax.swing.border.LineBorder;

class BorderTest {
 
  static JPanel contentPane;
 
 public static void main(String args[]) {
    JFrame frame = new JFrame(“Border Test”);
    JFrame.setDefaultLookAndFeelDecorated(true);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    contentPane=(JPanel)frame.getContentPane();
    contentPane.setBorder(new TitledBorder (new LineBorder(Color.BLACK, 1), “contentPane(GridLayout)”));

    contentPane.setLayout(new GridLayout(20,1));

     JLabel label[]=new JLabel [20];_
     for(int a=0; a<2; a++){
       label[a] = new JLabel(“Label “+a);
       label[a].setOpaque(true);
       label[a].setHorizontalAlignment(JLabel.CENTER);
       label[a].setVerticalAlignment(JLabel.CENTER);
       contentPane.add(label[a]);
       if (a==0 | a==2 | a==4 | a==6 | a==8 | a==10 | a==12 | a==14 | a==16 | a==18){
          label[a].setBackground(Color.WHITE);
          label[a].setForeground(Color.BLACK);
       }else{
          label[a].setBackground(Color.BLACK);
          label[a].setForeground(Color.WHITE);

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

En el punto 2 me he atascado (vaya en el último punto de toda la práctica, casi lo consigo jejejee) porque al ejecutar la clase que te dan, me da un error: exception in thread “main” java.lang.UnsupportedClassVersionError: LayoutManagerShowTeacher <Unsupported major.minor.version 49.0> ¿Qué significa esto? Es que yo y el inglés…. ¿Es que necesito una versión superior a la que tengo instalada?… ¡¡¡Espero vuestra ayuda!!!

Jo! Vaya post más largooooooo, a ver si al final va a ser mejor no ir a clase y currarse la práctica en casa… bueno, lo mejor será hacer las dos cosas si queremos aprobar. ¡¡Nos vemos por clase!!

Aunque ya hace tiempo que hicimos esta práctica, la recordamos porque no fue muy complicada, bueno… por eso y porque siempre guardamos todo lo que hacemos por mínimo que sea. Venga, que no nos enrollamos más y vamos al grano:

Ejercicio 1: Lo primero que hicimos, como siempre, fue buscar por apuntes de clase e Internet lo que era una  tabla Hash, o Hash Table que queda más elegante. Llegamos a la conclusión que se utiliza frente a listas, array, vectores… porque el tiempo de búsqueda es muy pequeño independientemente del número de elementos que contenga. Además no necesita que se defina ni último ni primer elementos. Todo esto crea una gran ventaja, se consigue un gran rendimiento con una implementación bastante sencilla.

Para realizar este ejercicio, tan sólo hay que tener en cuenta estos conceptos:

- Se debe importar java.util.* que es donde se encuentra la clase Hashtable.

- La tablaHash relaciona una clave con un valor, esto se consigue mediante el siguiente método: put (Object clave, Object valor). En este ejercicio, tras crear una Hasttablese, sería:

Hashtable ht = new Hashtable (10);

// Se podría indicar la longitud o no.
ht.put(“primero”, “Descripción del primer truco”);

ht.put(“segundo”, “Descripción del segundo truco”);

// Esto repetido hasta insertar todos los valores deseados

- El método get (clave), devuelve el objeto valor asociado a la clave especificada. Hay que tener en cuenta que este objeto es de tipo Object y como nosotros queremos imprimirlo después, vamos a hacer una transformación a tipo String. Esto sería:

String truco = (String)ht.get(“primero”);

Esto crea un String llamado truco con el valor de “Descripción del primer truco” que podemos imprimir por pantalla fácilmente poniendo dentro del main:

System.out.println (truco);

Ejercicio 2: No vamos a explicar uno por uno todos los métodos recursivos que nos dan porque es siempre lo mismo. Preferimos intentar dar las claves comunes de cualquier método recursivo.

La recursividad en un método se produce cuando se vuelve a llamar a este mismo método desde dentro del mismo. Lo más importante es tener en cuenta estas dos cosas para evitar tener un bucle infinito.

1. Crear una condición de parada: que cuando se cumpla devuelva un valor o salga del método.

2. Todos los métodos recursivos que nos muestran, tienen uno o más parámetros. Cuando hacemos una llamada al método desde dentro del mismo, debemos actualizar los parámetros pues si pasáramos siempre los mismos valores de estos, siempre nos haría lo mismo, creando así un bucle infinito.

Y esto fue todo lo que hicimos, a lo más difícil no nos dio tiempo… ¡ahora entiendo porque dijimos que esta práctica fue fácil! (jejejee)

La práctica consistía en utilizar un vector (lista dinámica) en lugar del array (lista estática) que empleamos en la anterior. La ventaja de crear un Vector para sustituir a un array, es que nuestra dimensión pasa a ser ilimitada y, además, se logra ahorrar memoria. Esto último se debe a que, si la dimensión de un array es x e introducimos menor número de elementos, tenemos algunas posiciones del array con valor null (no hay elementos en ellas) y nos están ocupando un espacio en memoria que no utilizamos. El concepto teórico de lo que es una cola dinámica está más o menos claro, pero a la hora de llevarlo a la práctica…

Tras bajarnos las soluciones de la práctica anterior para ir modificando sobre ellas, nuestro primer pasito fue poner la siguiente secuencia para poder utilizar vectores:

import java.util.Vector;

Después sustituimos el array por un Vector:

Vector elementos = new Vector (numElementos +1);

Aquí surgió la primera duda: ¿Por qué asignamos una dimensión al Vector si se supone que es infinito? (Ups, pues parece que tampoco la teoría estaba muy clara) Tras comernos un poco la cabeza, averiguamos que al crear un Vector, se le puede indicar un números de elementos inicial (que no su longitud) o no indicarle nada. Entonces se nos ocurrió que, en este caso si se indicaba para lograr hacer un Vector circular, de ahí también el +1. Aunque la verdad, no nos termino de convencer esto así que si alguno lo tiene más claro… ayudarnos, please!

Tras esta pequeña reflexión, pensamos que el método llena( ) no tendría mecho sentido para un Vector que no tiene límite de longitud por eso decidimos borrarlo. Aquí nos atascamos, intentamos compilar pero, como ya esperábamos…. ¡Error!

Ojeamos los apuntes de clase esperando encontrar algo que nos ayudara. Nos dimos cuenta de que se necesitaría también crear una clase Nodo que consiga crear las referencias al siguiente elemento y establecer así un orden. Pero no nos dio tiempo a intentarlo.

Y esto fue todo, esperaremos a que pongan las soluciones para mirárnoslo bien, que este tema está un poco confuso. Pero no nos desanimemos, miremos el vaso medio lleno, lo bueno es que la siguiente práctica no nos puede salir peor (en el peor de los casos igual de mal).

¡¡Nos vemos en la siguiente práctica!! En la que esperamos no sufrir tanto. xD

Al llegar, (y como hacemos siempre) miramos la longitud de la prácticas y para nuestra sorpresa vimos sólo dos ejercicios ¿motivo de alegría porque son pocos, o de acojone porque, si sólo hay dos, deben ser muy complicados? Mejor sería dejar a parte estas cuestiones que no conducen a ningún lado, y ponerse con ello.

El primer paso para programar un juego es ponerse a pensar las clases, métodos, atributos… que vamos a necesitar implementar. Hacer esto lo primero te ayuda bastante, y no lo que hacemos nosotros que somos de los que se ponen a programar como locos, y a ver que va saliendo, cuya consecuencia es que luego te das cuenta de que había otra manera mejor de hacerlo y te toca volver a empezar (experiencia propia). Así que ya sabéis, una buena planificación de lo que vamos a tener que programar es tener gran parte del problema resuelto.

Las clases, con sus métodos correspondientes, que tendrá el Tetris serán:

Clase Pieza: Se trata de una clase abstracta que nos va a indicar los métodos que van a definir una pieza. Estos son:

- quienSoy: devuelve el tipo de pieza que es: cuadrado, ele, T…

- posición: devuelve las coordenadas x e y en las que está la pieza dentro de la pantalla.

- mover: describirá el movimiento que hace la pieza.

- pintar: muestra la pieza por pantalla.

De esta clase heredaran la clase PiezaL, PiezaCuadrado… que especifican el comportamiento de cada pieza según del tipo que sean. Ejemplo: en la clase PiezaCuadrado el método quienSoy deberá devolver, Cuadrado.

Clase Cola: Sirve para crear los métodos que van a controlar el array de Piezas, donde se irán almacenando éstas tras ser creadas. Esta clase contendrá los métodos que intervienen en el comportamiento de un array, vistos en clase de teoría: encolar, desencolar, vacia y llena. Además tendrá dos métodos, primero y ultimo, que nos devolverán un int que indique la posición del array donde se encuentra el elemento primero o último respectivamente.

Clase Main: Como su nombre indica, es la clase que va a contener el main. Es la encargada de:

1. Crear el array Piezas.

2. Crear una pieza de un tipo concreto. Por tanto, el constructor de la clase Pieza debe tener un parámetro “tipo” donde se indique que tipo de pieza es.

3. Encolar la pieza usando el método Cola.encolar()

4. Pintar la pieza para poder visualizarla por pantalla.

Nos vemos el próximo viernes que… ¡La aventura del Tetris continúa!

Introducción: Esta parte es para aclarar algunos conceptos. Primero nos aparece esa palabra tan extraña (que además viene en negrita lo que indica que va a ser importante) polimorfismo. Como en la práctica viene todo puesto con palabras muy técnicas, esto es lo que sería en una definición de andar por casa (como diría la profesora de Mate). El polimorfismo consiste en averiguar a qué método nos referimos si en nuestro programa hay varios con el mismo nombre. Esto sucederá en dos ocasiones:

1. Sobrecarga de métodos: Se distinguen por el o los parámetros que se le asignan a cada uno. Probaré a explicarlo mejor con un ejemplo:

public String toString ( ){ …}

public void toString ( int numero){ …}

Es posible crear los dos con el mismo nombre porque si ponemos nombreObjeto.toString( ); sabemos que se referirá al primero que es el que no tiene parámetros y si ponemos nombreObjeto.toString(4); será una referencia al segundo cuyo tipo de parámetro es compatible.Creo que esto también se puede hacer con Constructores.

2. Sobreescritura de métodos: Esto es lo que hicimos en la práctica anterior usando Herencia, se sabe que toString ejecutar cada vez según el tipo de objeto que llama a este método. Si ponemos atributo1.toString, donde atributo1 es un objeto de la clase Atributo, se ejecutará el toString que aparezca en la clase Atributo.

Otro concepto importante a conocer es una Clase Abstracta. Es aquella que sirve como base para sus clases derivadas, aquí van a aparecer los métodos (también abstractos) que deben implementarse en todas ellas. Se debe tener en cuenta que no se pueden crear objetos de las clases abstractas.

El interfaz es lo que se nos ha explicado en clase como contrato, una especificación de las funciones que deben cumplir los objetos. Sólo pueden tener métodos abstractos aunque no hace falta indicarlo con la sentencia abstract en ellos, pues se pone por defecto. 

Ejercicio 1: Aquí nos dimos cuenta de la importancia que tiene manejarse bien por el API. Algo que aún tenemos un poco pendiente pero es que… ¿a nadie se le ha ocurrido traducirlo entero? Por lo demás, solo consiste en comprobar que, como todas las clases derivan de la clase Object donde se define el método toString(), cada vez que trabajemos con una cadena de caracteres (un String) se va a invoca este método por defecto. Por ello, aunque borremos la sentencía  toString() de todos los sitios, el resultado será  el mismo que en la práctica anteior. 

Ejercicio 2: En este ejercicio sufrimos un poco de stress, eso de poder almacenar la información en un fichero… nos daba un poco de respeto. Luego nos chivaron que se puede conseguir con el método write y, aunque otra vez había que acudir a nuestro querido API, lo logramos hacer teniendo en cuenta las especificaciones de este nuevo método. 

Ejercicio 3: Por fin comenzamos con la interfaz gráfica, eso de que vayan saliendo ventanitas y cosillas de esas ya nos gusta más XD. Nos quedamos en la primera parte, en la de colorear un rectángulo de amarillo. No fue muy difícil, como te dan la clase medio hecha tan sólo tienes que utilizar los métodos paint( ), pintaBorde( ) y pintaFondo( ). 

Aunque no nos dio tiempo a hacer más, habrá que mirarse lo que queda, que esta parte es muy importante para hacer el Videojuego. Si, nosotros somos unos de los locos que lo estamos intentando y esperemos que no se quede sólo en un intento. Bye!

Los ejercicios 1,2,3,4 son para entender el concepto de “Herencia”, pero la herencia que consiste en heredar un apartamento en Torrevieja que nuestra tía-abuela segunda ganó en el “Un, dos, tres”…, no, esta herencia no, sino la herencia en Java. La herencia en Java consiste en compartir código entre clases que tienen un comportamiento parecido. Es decir, se puede crear una clase (clase derivada) a partir de otra ya hecha (clase base) y compartir las opciones de esta última con la primera y, además, poder añadir otras opciones propias de la nueva clase. Se debe tener en cuenta que la clase derivada heredará todos los métodos y atributos excepto el constructor que es propio para cada clase.

Centrándonos en lo que nos mandaban hacer en esta práctica, como ya nos daban las clases medio hechas, tan sólo había que completar el constructor usando el super y añadir al método toString los atributos particulares de cada clase (sin olvidar utilizar también el super para heredar el toString de la clase Miembro con los atributos comunes). Nosotros os aconsejamos crear un objeto de cada clase y comprobar por pantalla el toString de cada una.Por otro lado, nos parece buena idea que se hagan las mismas clases que en la práctica anterior, así podemos comparar las dos maneras de hacerlo y comprobar que, efectivamente (por si alguno no se lo había terminado de creer), se ahorra código usando la herencia. 

Nosotros llegamos hasta el ejercicio 5. En primer lugar desciframos en lo que consiste el  instanceof, que permite saber si un objeto pertenece a una clase determinada devolviendo true o false. Además conseguimos hacer el getAtributos(). Como he leído en algunos Blogs que no algunos no llegasteis hasta aquí, os pongo lo que hicimos nosotros, aunque la garantía de que este bien no supera el 70%. 

public Atributo[ ] getAtributos() {
   Atributo arrayAtributos[]= null;
   int contador=0;
  for (int i=0;i<miembros.length;i++){
   if (miembros[i] instanceof Atributo){
     arrayAtributos [contador] = (Atributo)miembros[i];
     contador++;
   }
  }
   return arrayAtributos;

}
 

Admitimos opiniones de todo tipo (aunque preferiblemente buenas) sobre esta idea. Otra cosilla importante, fijaros en (Atributo)miembros[i] porque es necesaria esta conversión de tipo, pues no todos los miembros son Atributos.

¡¡Hasta la próxima apañeros!!

Nota: no olvidéis hacer los ejercicios complementarios para casa XD (esta novedad añadida) y terminar la práctica, que me apuesto una bandeja de torrijas a que nadie la terminó.