Ejercicio 3

ENUNCIADO

En este caso se trata de hacer un “mini-videojuego”, algo parecido al “arkanoid” pero sin ladrillos que romper. Simplemente el jugador debe mantener una pelota rebotando de pared en pared sin dejarla caer al suelo.

Tenemos un tablero de juego dividido en dos zonas:

            Área de juego: Habrá una pelota y un jugador que maneja una pala situada en la parte inferior mediante el teclado. Se trata de no dejar rebotar la pelota con el suelo, haciendo que rebote en la pala y vaya de una pared a otra. Si la pelota cae al suelo, significará que no hemos conseguido interceptarla con la pala y se acabará la partida.

            Área del contador: En esta parte del tablero, únicamente habrá un marcador que lleve la cuenta de cuantas veces ha rebotado la pelota en la pala.

La partida comienza en cuanto se abre la aplicación, es decir, en ese momento, nos encontraremos ya con la pelota rebotando de pared en pared.

SOLUCION

import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

public class RebotaLaPelota extends JFrame{

JPanel juego; //Panel de juego

JPanel marcador; //Panel del marcador donde sale el numero de rebotes.

JLabel rebotes;

int rebotes =0; [c1] //Contador del numero de rebotes

final int tamaño_x=500;

final int tamaño_y=300;

final int tam_casilla=1; [c2] //1pixel

JLabel tablero [] []=new JLabel [tamaño] [tamaño];[c3] 

int xpe=tamaño_x/2; //Coordenadas pelota

int ype=tamaño_y/2;

int direccion_pelota = 0;//Si vale 0=diagonal derecha arriba; 1=diagonal izda arriba;2=diagonal dcha abajo; 3=diagonal izda abajo

int xpa=250;//Coordenadas pala(249,250,251)

int ypa=280;

Direccion xpa=0[c4] ;

Timer velocidad; //Timer que controla la velocidad con la q se mueve la pelota

public RebotaLaPelota(){ //Constructor

super (“Rebota la Pelota”);

JLabel numrebotes=new JLabel (“ Número de rebotes en la pala:”); //Etiqueta con el número de rebotes de la pelota en la pala

marcador.add (numrebotes, BorderLayout. NORTH[c5] );

Juego =new Jpanel (new GridLayout (tamaño[c6] , tamaño));

Juego.setSize (tamaño * tamaño, tamaño * tamaño);

  for (int i=0, i<tamaño x; i++){ //Pinto todo el tablero de color blanco

    for (int j=0; j<tamaño [c7] y;j++){

Tablero [i][j]=new Jlabel();

Tablero [i][j].setOpaque(true);

Tablero [i][j].setBackground(Color.WHITE);

Juego.add (tablero[i][j]);

}

}

getContentPane().setLayout(new GridLayout(1,2));

getContentPane().add(juego);

getContentPane().add(marcador);

Escuchadores e1= new Escuchadores();

addKeyListener(e1);

velocidad =new Timer (250, e1);

velocidad.start();

}

public void DibujarPala(){

for (int k=xpa-1 ; k<xpa+1; k++){

 for (int m=ypa-1; m < ypa ; m++){

            tablero[k][m] =new Jlabel();

            tablero[k][m].setOpaque(true);[c8] 

            tablero[k][m].setBackground (Color.BLUE);

            Juego.add(tablero[k][m]);[c9]        

}

}

}

public void NuevasCoordenadasPala(int xpa, int ypa){

this.xpa=xpa;

this.ypa=ypa;

}

public void DibujarPelota(){

tablero[xpe][ype]=newJLabel();[c10] 

tablero[xpe][ype].setOpaque(trae);

tablero[xpe][ype].setBackground(Color.YELLOW);

Juego.add(tablero[xpe][ype]);

}

public static void main (String args[]){

RebotaLaPelota rlp= new RebotaLaPelota();

rlp.setDefaultCloseOperation (EXIT_ON_CLOSE);

rlp.pack();

rlp.setSize (600,600);

rlp.setResizable (false);

rlp.setVisible(true);

rlp.requestFocus();

[c11] 

}

public class Escuchadores extends KeyAdapter  implements ActionListener{ //Clase interna

public void KeyPressed(KeyEvent e){ //Eventos de teclado

int antigua_xpa=xpa;

int antigua_xpa+1=xpa+1;

int antigua_xpa-1=xpa-1;

char tecla=e.getKeyChar();

if ((tecla.equals(‘q’)){ //Que la pala se mueva hacia la izquierda porque he pulsado la q

if ( xpa-2>0){ //Compruebo que la próxima posición a la izquierda no es la pared.

xpa-1[c12] ;

else{

xpa+1;

}

[c13] tablero(antigua_xpa).setBackground(Color.WHITE);//Las coordenadas antiguas las pinto de blanco.

tablero(antigua_xpa+1)[c14] .setBackground(Color.WHITE);

tablero(antigua_xpa-1).setBackground(Color.WHITE);

tablero(xpa).setBackground(Color.BLACK);//Y las coordenadas nuevas las pinto de negro.

tablero(xpa+1).setBackground(Color.BLACK);

tablero(xpa-1).setBackground(Color.BLACK);

}

}

else  {//que la pala se mueva a la izquierda porque he pulsado la p

if (xpa+2<500){ //Compruebo que la próxima posición a la derecha no es la pared

xpa+1;

else{

xpa-1;

}

}

}

}

NuevasCoordenadasPala([c15] ); //Actualizamos las nuevas coordenadas de la pala una vez que se ha movido.

DibujarPala[c16] (); //Y dibujamos la pala en la nueva posición.

}

private void fin(boolean ganador){ //Si la pelota toca el suelo, finaliza la partida

if(ype+1>300){ //La pelota ha tocado el suelo

ganador==false;

velocidad.stop();

System.exit(0);

}

}

public void actionPerformed (ActionEvent e){ //Hacia donde se mueve la pelota y comprobación de que puede moverse hacia un lado u otro.

int antigua_xpe=xpe;

int antigua_ype=ype;

switch (direccion){ //Tengo 4 casos en los que la pelota puede moverse cuando está situada en el centro y empieza la partida:

 case 0: //Diagonal arriba derecha

if(xpe+1<500) { //Hago todas las comprobaciones de que la pelota pueda moverse arriba y a la derecha siempre y cuando la próxima posición no sea el techo o la pared derecha; y esto con todos los casos hacia donde podría moverse la pelota

if (ype-1>0){

              xpe+1;

              ype-1;

}

else {

xpe+1;

ype+1;

}

else{

 if (ype-1>0){

xpe-1;

ype-1;

}

else{

xpe-1;

ype+1;

}

}

}[c17] 

}

case1: //Diagonal arriba izquierda

if (xpe-1>0){

if (ype-1>0){

xpe-1;

ype-1;

}

else{

xpe-1;

ype+1;

}

else{ //x-1<0

 if(ype-1>0){

xpe+1;

ype-1;

else{

xpe+1;

ype+1;

}

}

}

case 2: //Diagonal abajo derecha

if (xpe+1<500){

if (ype+1<300){

xpe+1;

ype+1;

else{

xpe+1;

ype-1;

}

else{ //x+1>500

if(ype+1<300){

xpe-1;

ype+1;

}

}

else{

xpe-1;

ype-1;

}

}

}

if(ype+2=ypa){//Si choca con la pala

xpe+1;

ype-1;

numrebotes++;

}

case 3: //Diagonal abajo izquierda

if (xpe-1>0){

if (ype+1<300){

xpe-1;

ype+1;

}

else{

xpe-1;

ype+1;

}

else{

if (ype+1<300){

xpe+1;

ype+1;

}

}

else{

xpe+1;

ype-1;

}

}

if( ype+2=ypa){ //Si choca con la pala

xpe-1;

ype-1;

numrebotes++; [c18] 

}[c19]          

}

tablero [antigua_xpe,antigua_ype].setBackGround(Color.WHITE); //Pinto la antigua coordenada donde estaba situada la pelota antes de moverse de blanco.

tablero[xpe,ype].setBackGround(Color.YELLOW);//Y la nueva de amarillo.

DibujarPelota[c20] ();//Y la dibujo.

[c21] 

NOTA:

De nuevo, no han sido dos horas, sino dos tardes enteras y una mañana… y aun así, sigo sin tener claras unas cuantas cosas.[c22] 

Lo de conseguir que la pelota se moviera, ha sido lo más complicado y aun sigo sin saber si está bien. Lo he hecho con coordenadas, intentando comprobar que cada vez que vaya a chocar con alguna de las paredes, rebote justo en la dirección contraria. Y además, que borre la posición actual, es decir, que se pinte de blanco como está el resto del tablero, y que se pinte de amarillo la nueva posición donde se ha movido.[c23] 

Con la pala he hecho algo parecido, pero una cosa que no tengo clara, es si, en el método que lee los eventos de teclado, muevo la pala hacia la izquierda o la derecha, si habría que mover las tres coordenadas que ocupa la pala, o con mover la del centro, ya se desplazaría la pala entera. [c24] Por esta razón, he creado los métodos de dibujar pala y nuevasCoordenadasPala para que una vez que compruebo si la pala puede moverse hacia un lado u otro, se modifiquen las tres coordenadas de la pala y no solo una.

Puede que esté todo fatal, pero aun así, creo que me ha servido bastante de práctica, aunque solo haya sido para intentar pensar, muy detenidamente, y por mi misma, como intentar solucionar los problemas que se plantean, aunque creo que ha sido un ejercicio un poco “exagerado”.[c25] 

(El esquema anterior formaría parte del enunciado).

Queremos implementar una cola utilizando una lista enlazada, esto es, pudiendo enlazar un elemento (nodo) con el siguiente. Esta cola debe incluir sus métodos básicos para :

Ø      Encolar elementos (enqueue).

Ø      Desencolar elementos (dequeue).

Ø      Indicar si la cola está vacía.

Ø      Imprimir por pantalla todos los contenidos de la cola.

Esta cola no estará formada por enteros ni ningún otro tipo de datos, estará formada por pilas, es decir, cada nodo de la cola, será una pila (clase que habrá que crear aparte), que a su vez también deberá incluir sus métodos típicos para:

Ø      Introducir un elemento en la pila (push).

Ø      Extraer un elemento de la pila (pop).

Ø      Indicar si la pila está vacía.

Ø      Indicar si la pila está llena.

Ø      Imprimir por pantalla todos los contenidos de la pila.

Las pilas se deben implementar como arrays, los cuales en cada posición contendrán un vector que puedan almacenar una lista de elementos que en nuestro caso serán enteros. Es decir, con cada push que haga a la pila, insertaré un vector y con cada pop sacaré un vector.

El método imprimir de la cola supondrá:

Imprimir cada una de las pilas almacenadas en ella. A su vez, imprimir cada una de estas pilas significa imprimir todos y cada uno de los vectores que almacena. Por último, imprimir uno de estos vectores quiere decir imprimir, uno debajo de otro, todos los objetos que estén guardados en él, considerando que dichos objetos serán números enteros. Tras la impresión, la estructura de datos al completo deberá quedar tal y como estaba al principio.

  Solución del ejercicio

Ejercicio 1

ENUNCIADO

Se trata de crear un conjunto de clases que representen personajes de juegos de rol. En concreto habrá que crear 4 clases y una interfaz.

De las 4 clases, una de ellas será la clase de Prueba, otra la clase Personaje “genérica”, es decir, la que contiene las características básicas de todos los personajes y las dos restantes, serán dos clases personajes en concreto (Guerrero y Maga) que hereden de la clase personaje y que añadan alguna característica nueva.

La clase Maga, será la que tenga que implementar la interfaz Hechicero.

Clase Personaje:

           Contiene las características generales de todos los personajes. No se deben poder crear instancias de ella, lo que significa que debe ser abstracta. Los atributos que debe contener son : 

• Número de vidas del personaje.
• Fuerza.
• Inteligencia.
• Astucia.
• Vigor inicial: Esta característica tendrá en todo momento el mismo valor para todos los personajes, esto es, si alguno cambia su vigor, el nuevo valor cambiará para todos.

Y en cuanto a los métodos:

• Constructores varios: Además de inicializar la información del personaje, deberán tomar nota del objeto que los llamó, a fin de poder llamarlo más tarde.
  •  
    • Métodos de acceso a la información: Estos métodos, además, deberán notificar al método “personajeCambiado(Personaje)” del objeto que creo el personaje cada cambio que se produzca en la información del personaje.
    • Un método “imprimir()” sin implementar.

Clase Guerrero:

            Por heredar de la clase Personaje, contiene todo lo que hay en ella y además añade los atributos :   

• Habilidad.
• Puntería.
• Una variable que lleve la cuenta de cuantos guerreros hay en cada momento.

Y el método: 

•  
  • Un método para imprimir por pantalla toda la información del personaje.

Clase Maga:

            Por heredar de la clase Personaje, también contendrá todo lo que hay en ella y además añade los atributos: 

• Magia.
• Poder de la luz.
• Una variable que lleve la cuenta de cuantas magas hay en cada momento.

Y los métodos: 

• Un método para imprimir por pantalla toda la información del personaje.
• Esta clase deberá además implementar la interfaz “Hechicero”.

Clase de prueba:

            Será la clase que contenga el método main para comprobar que todo funciona. Este método de prueba dará un valor inicial al vigor de los personajes y después creará un personaje “Maga”.

            Además, debe incluir el método personajeCambiado(Personaje), que simplemente imprima por pantalla las características del personaje cambiado.

Interfaz Hechicero:

En cuanto a la interfaz que hay que crear , contendrá los siguientes métodos:  

• Doblar magia.
• Doblar poder de la luz.

SOLUCIÓN EJERCICIO 1 

CLASE PERSONAJE 

  public abstract class Personaje{ //Creamos la clase abstracta para no poder crear instancias de ella
  
      public int númerodevidas;
      public int fuerza;
      public int inteligencia;
      public int astucia;
      public static int vigorInicial;[JJ1] 
     
       public Personaje(){
         //Constructor vacío
     
      }
   
       public Personaje[JJ2] (int numerodevidas, int fuerza, int inteligencia, int astucia, int vigorInicial){  //Inicialización de los atributos
     
         this.numerodevidas=numerodevidas;
         this.fuerza=fuerza;
         this.inteligencia=inteligencia;
         this.astucia=astucia;
         this.vigorInicial=vigorInicial;
      [JJ3] 
      }
       public Personaje(){
        // tomar nota del objeto que los llamó, con el fin de poder llamarlo más tarde.
      }[JJ4] 
  

//Métodos de acceso[JJ5] 
      public void ponNumerodevidas(int numerodevidas){
         this.numerodevidas=numerodevidas;
      }
  
       public int Numerodevidas(){
         return numerodevidas;
      }
     
       public void ponFuerza (int fuerza){
         this.fuerza=fuerza;
      }
   

 public int Fuerza(){
         return fuerza;
      }
  
       public void ponInteligencia(int inteligencia){
         this.intelegencia=inteligencia;
     
      }
      
       public int Inteligencia(){
         return inteligencia;
      }
   
       public void ponAstucia(int astucia){
         this.astucia=astucia;
      } 
       public int Astucia(){
         return astucia;
      }
       public void ponVigor(int vigor){
         this.vigor=vigor;
      }
       public int Vigor(){
         return vigor;
      }
   
       public abstract void imprimir(){  //Método imprimir sin implementar  
      }[JJ6] 
  
   }

public class Guerrero extends Personaje{  //Hereda de la clase personaje

            public int habilidad;

            public int puntería;

            public int numeroGuerreros[JJ7] ;

public Guerrero(int habilidad, int puntería, int numeroGuerreros[JJ8] ){

super (numerodevidas, int fuerza, int inteligencia, int astucia, int vigor);

this.habilidad=habilidad;

this.puntería=puntería;

this.numeroGuerreros=numeroGuerreros;

}

//Métodos de acceso

       public void ponHabilidad(int habilidad){
         this.habilidad=habilidad;
      }
       public int Habilidad(){
         return habilidad;
      }
       public void ponPunteria(int puntería){
         this.punteria=punteria;
      }
       public int Puntería(){
         return puntería;
      }
       public void ponNumeroGuerreros(int numeroGuerreros){
         this.numeroGuerreros=numeroGuerreros;
      }
       public int numeroGuerreros(){
         return numeroGuerreros;
      } 

public void imprimir(){  //Método que imprime todas las características del personaje Guerrero.

System.out.println(“Datos:”+númerodevidas,+fuerza,+inteligencia,+astucia,+vigorInicial,+habilidad,+punteria,+numeroGuerreros);

}

}

CLASE MAGA

public class Maga extends Personaje implements Hechicero[JJ9] {  //Hereda de la clase Personaje e implementa la interfaz Hechicero.

            public int magia;

            public int poderDeLaLuz;

            public int numeroMagas;

 public Maga(int magia, int poderDeLaLuz, int numeroMagas){

super (numerodevidas, int fuerza, int inteligencia, int astucia, int vigor);

            this.magia=magia;

            this.poderDeLaLuz=poderDeLaLuz;

            this.numeroMagas=numeroMagas;

}

       public void ponMagia(int magia){
         this.magia=magia;
      }
       public int Magia(){
         return magia;
      }

       public void ponPoderDeLaLuz(int poderDeLaLuz){
         this.poderDeLaLuz=poderDeLaLuz;
      }
       public int PoderDeLaLuz(){
         return poderDeLaLuz;
      }

       public void ponNumeroMagas(int numeroMagas){
         this.numeroMagas=numeroMagas;
      }
  
       public int NumeroMagas(){
         return numeroMagas;
      }

public void imprimir(){

System.out.println(“Datos:”+númerodevidas,+fuerza,+inteligencia,+astucia,+vigorInicial,+magia,+poderDeLaLuz,+numeroMagas);

}

CLASE PRUEBA

Public class Prueba{

        Public void personajeCambiado(Personaje p)[JJ10] { //Cambiamos el valor de cada característica del personaje.

p.ponnumeroVidas(1);

p.ponFuerza(100);

p.ponInteligencia(100);

p.ponAstucia(100);

p.ponVigorInicial(10);

}

    Public static void main(String args []){

Personaje maga1=new personaj[JJ11] e[JJ12] ; // Creamos un personaje maga

//Inicializamos los valores de un personaje maga.

Maga1.ponnumeroVidas(3);

Maga1.ponFuerza(50);

Maga1.ponInteligencia(75);

Maga1.ponAstucia(25);

Maga1.ponVigorInicial(0);

Maga1.ponmagia(50);

Maga1.ponPoderDeLaLuz(25);

Maga1.ponNumeroMagas(5);

System.out.println(“Numero de Vidas:”+maga1.dameNumeroVidas());

System.out.println(“Fuerza:”+maga1.dameFuerza());

System.out.println(“Inteligencia:”+maga1.dameInteligencia());

System.out.println(“Astucia:”+maga1.dameAstucia());

System.out.println(“Vigor Inicial:”+maga1.dameVigorInicial());

System.out.println(“Magia:”+maga1.dameMagia());

System.out.println(“Poder de la luz:”+maga1.damePoderDeLaLuz());

System.out.println(“Numero de Magas:”+maga1.dameNumeroMagas());

}

}

INTERFAZ HECHICERO

public interface Hechicero{

   public void doblarMagia(int magia){

magia=magia*2;

  }

  public void doblarPoderDeLaLuz(int poderDeLaLuz){

poderDeLaLuz=poderDeLaLuz *2;    

  }

} 

Se trata de colgar aquí, en el blog, las soluciones a los ejercicios propuestos cada semana durante 4 consecutivas. En las “instrucciones” se nos especificó que lo tendríamos que colgar entre el viernes por la tarde y el domingo por la tarde, asi que aquí estamos. Pero tenemos una dudilla: la forma de colgarlo, no se puede hacer tipo correo con adjuntos y tal, y colgando las imágenes escaneadas (para quien lo haya escaneado) sería un entrada increiblemente grande en la que dudo que se pueda sacar algo en claro, por lo que…Necesitamos una respuesta, ¿Qué hacemos con respecto al tema del blog y las soluciones?

Nota: podriamos crear una cuenta en gmail por ejemplo con usuario y contraseña que conozcamos todos y así todos tendriamos acceso y pordriamos ver los adjuntos, tanto imagenes escaneadas como documentos word…¿Qué os parece?

No hemos escrito antes, porque a las dos últimas sesiones de las prácticas decidimos no ir a clase y hacerlas en casa…(por eso de que perdemos más tiempo en ir y volver que en estar allí).

La práctica 12 trataba sobre JMF…(aquel gran desconocido de  OCA), es decir, lo vemos muy por encima y te recomiendan utilizarlo en nuestros videojuegos…, bueno pues nuestra recomendación particular y personal es que copieis y pegueis el código siguiente:

import

java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.lang.String;
import java.net.URL;
import java.net.MalformedURLException;
import java.io.IOException;
import javax.media.*;
public class Mi_Reproductor extends JFrame implements ControllerListener{
String MEDIAFILE = “file:tren.mpeg”;
//Reproductor
Player player=null;
//Componente de reproducción del vídeo
Component visualComponent=null;
//Controles
Component controlComponent=null;
//Barra de progreso
Component progressBar=null;
public Mi_Reproductor() {
getContentPane().setLayout(new BorderLayout());
URL url = null;
try{
//Se crea URL para el archivo
if ((url = new URL(MEDIAFILE)) == null)
System.err.println(“No se puede construir URL para el archivo”);
//Se crea el reproductor
player=Manager.createPlayer(url);
player.addControllerListener(this);
}
catch (MalformedURLException e){
System.err.println(“URL no valida”);
}
catch (IOException e){
System.err.println(“Excepcion de Lectura/Escritura”);
}
catch (NoPlayerException e){
System.err.println(“No existe reproductor”);
}
player.start();
addWindowListener(new EscuchadorVentana());
}
public synchronized void controllerUpdate(ControllerEvent event){
//Comprobamos que el reproductor está “vivo”
if (player == null) return;
//Qué evento se ha producido?
if (event instanceof RealizeCompleteEvent){
//Se añade el componente de visualización del reproductor y el de control
if((visualComponent = player.getVisualComponent()) != null)
getContentPane().add(“Center”,visualComponent);
if ((controlComponent = player.getControlPanelComponent()) != null)
getContentPane().add(“South”,controlComponent);
validate();
}
else if (event instanceof EndOfMediaEvent){
player.setMediaTime(new Time(0));
player.start();
}
else if (event instanceof ControllerErrorEvent){
player = null;
System.err.println(((ControllerErrorEvent)event).getMessage());
}
}
public static void main (String[] args) {
Mi_Reproductor reproductor = new Mi_Reproductor();
reproductor.setSize(100, 100);
reproductor.setVisible(true);
}
public class EscuchadorVentana extends WindowAdapter {
public void windowClosing (WindowEvent e) {
if (player != null) {
player.stop();
player.deallocate();
}
System.exit(0);
}
}
}

 No os olvideis de importar el paquete javax.media (propio de JMF) y de capturar todas las excepciones a las que puede dar lugar la creación de un reproductor de audio o video.  Este código lo que hace es,pues eso básicamente, crea un reproductor sencillo y lo único que te quedaría por hacer sería crearlo,inicializarlo y pararlo donde tu quisieras, es decir, hacer la llamada a .start() y .stop().

En cuanto a la última práctica…el examen del año pasado…¿que decir de él? Pues que si lo hubieramos aprobado a su debido tiempo, no estaríamos aquí repitiéndolo. Os dejamos la solución en vuestras manos, por eso del secreto profesional…(y porque lo hemos intentado y no tenemos muy, muy clara la solución ) y si tenéis sugerencias y formas “rápidas e inteligentes” de resolverlo, no dudéis en comunicarnoslas.

Un saludito!!!

Creemos que no será mucho y vamos a intentar hacerlo ahora, por eso de quitarnoslo ya de encima…pero bueno.

En cuanto a la práctica, todo lo que nos dió tiempo a hacerlo en clase ya lo hemos hecho en casa (el examen se acerca y no se puede dejar pasar ni una sola oportunidad de prácticar programando un poquito…)

El ejercicio 1, 2 y 3 son muy parecidos solo que cambiando algunos detalles : Lo que hacemos es crear una clase que contiene un Frame, un panel y los objetos etiqueta y botón. Para el primer caso, creamos el escuchador de botón (que en este caso es Action Listener, tener cuidado que no siempre es así…ya que para eventos de ratón está el MouseListener o el KeyListener en otros casos…==>API) y creamos una sentencia System.out.println (“Has pinchado el botón”) para que te lo muestre por la salida estándar.

En el segundo caso lo que haremos será añadir a la etiqueta las características de cambiar el color de fondo, esto es:

etiqueta.setOpaque(true);

etiqueta.setBackground (Color.blue);

Una vez hecho esto, en el escuchador del botón indicaríamos que queremos que la etiqueta cambie de color cada vez que lo pulse : boton.addActionListener (new botonActionListener (etiqueta));

Para el ejercicio 3, esto último se quedaría igual y además para que cuando el usuario pulse “enter” también se cambie el color de fondo de la etiqueta, hacemos, primero una sentencia capaz de leer de teclado (InputStreamReader) rodeada de excepciones (try-catch, ya que todo lo que introduzcamos por teclado puede producir errores) y luego recorremos un bucle que nos imprima una sentencia cada vez que pulsamos enter en la que se indica el nombre del thread que está produciendo la acción ( Thread.currentThread().getName).

Lo de la base de datos…ufff miedito nos da solo de escucharlo ya que me huele a examen del año pasado y con lo cual no trae buenos recuerdos… Tenemos que ser sinceros y reconocer que nos hemos ayudado de la práctica del año pasado, aún asi, hemos intentado hacerla por nosotros mismos y lo que hemos hecho más o menos ha sido crear un vector en el que se incluyen un nombre y un nº (NIA). Esto serán registros, es decir, iremos añadiendo al vector registros que cada uno se compone de un nombre y un nº:

Base_datos.insert(registro);

registro=new Registro (“Pepito Gonzalez Flores”,1);

y así sucesivamente con todos los que quieras añadir al vector.

Luego utilizamos los siguientes métodos:

Base de datos nueva()==>Crea la base de datos, los registros e introduce éstos en la base.

String toString()==> Convierte los registros a cadena y me los devuelve imprimiendolos de esta forma.

Synchronized String query (int NIA) ==>utilizamos hilos dentro de este método para realizar una espera mientras se busca un nombre en la base de datos cuando introducimos el NIA.

abortQuery()==> Paraliza la búsqueda del nombre que queremos.

insert(Registro) ==> inserta un nuevo registro en la base de datos.

Chicos no es nada fácil, no sé si os habrá quedado algo claro aquí (ni siquiera sabemos si está completamente bien lo que hemos hecho) pero os recomendamos que no os quedeis con dudas en esto ya que, como bien he dicho antes, el año pasado tuvimos que crear (o hacer el intento al menos ) una base de datos en el examen.

La segunda base de datos que se pide no la hemos terminado, pero sería algo como la anterior añadiendo un botón como el del ejercicio 2 y en el método abortQuery habría que indicar que se parara la búsqueda cuando pincharamos este botón.

Lo del Notepad ya lo dejamos para otro momento, necesitamos seguir haciendo otras cosillas, asi que mientras el momento se acerca…dos consejos:

1- Estudiar muuuuuuuuuuuuuuuuuuuuuchooooooooooooooooo.

2-No os pongais nerviosos, aunque teneis que saber que no será fácil…:( (siento deciroslo así de clarito)…

Un saludooo

M&G

Nosotros algo hemos tenido que entender del tema para poder hacer nuestro juego, ya que hemos necesitado hacer un hilo para que nos “durmiera” un proceso, es decir, un hilo es una forma de separar la ejecución de un programa. Divide las tareas que quieres que se ejecuten por separado. [Aun así, no os recomendamos su uso!!].

Asi que bueno, hemos optado por dejar la práctica un poco de lado e intentar acabar de una vez por todas nuestro juego (solo nos queda hacer una ventanita que saque las instrucciones e incluir JMF). De todas formas, intentaremos mirarnos la práctica en casa, por eso de que exista la posibilidad de que alguna mente malvada nos meta hilos en el examen…

P.D-Este post “cortito”, vale por el resto de post “largos” que ya tenemos en nuestro blog.

Le hemos enseñado nuestro videojuego con los nuevos cambios (los nuevos cambios que hacen que por fin funcione…que si, que si!!!que ya funciona!!!).Hemos hecho algo raro (hay una sentencia que hemos copiado tal cual) porque lo de los hilos no lo llevamos muy bien. Hemos tenido que definir un objeto runnable y un método run en el que hemos incluido lo que ya teníamos (nuestro bucle que muestra los colores). Justo despúes tenemos que arrancar el hilo con un start.

En cuanto a la práctica…por fin empezamos con SWING…(ya había ganitas eehh??) y empezamos a entender “la magia” de la programación (como buenos ingenieros) )==>queda desmitificada!!

En el primer ejercicio se nos da el código de una interfaz gráfica en la cual vemos lo que hace cada cosa y cada sentencia. Crea un marco y una etiqueta, y tratamos de cambiar el color de la etiqueta utilizando los métodos setOpaque(true) y setBackground(); para cambiar el tamaño modificamos el método setSize…

En el ejercicio dos se nos pide modificar la clase HelloWorldGUI (del 1º) haciendo que ignore el mensaje de cierre del manejador de ventanas (suponemos que modificando, quitando o algo similar la sentencia de EXIT_ON_CLOSE, pero no estamos seguros) o que no utilice ninguna decoración del manejador de ventanas, lo cual hacemos poniendo a true el método setUndecorated().

Además hemos estado indagando un poquillo en el API para ver que hacían todos esos métodos que se nos dan de la clase JFrame que permiten a la ventana comunicarse con el manejador de ventanas y viceversa.

En el ejercicio tres lo primero que hacemos es volver a cambiar el fondo de la etiqueta con setOpaque() y setBackground(), pero además cambiamos de color el texto que contiene utilizando el método setForeground()…y bueno,aquí nos hemos quedado, pero prometemos ser buenos y terminarlo en casa.

Además, es que, como la clase ha sido bastante…mmm…muy…mmm…del todo personalizada, pues hemos estado un ratillo hablando con Pablo sobre Bolonia y los Boloñeses…en fin, cosas que nos interesan a todos y que en cuanto alguien sabe algo(aunque sea lo más mínimo) intentamos tirar del hilo a ver si sacamos algo más en claro, ya que vemos nuestro futuro…negro, negro, negrísimo…

Un saludito y hasta la semana que viene…A nooooooooooo!!!!! Que es puente!!!!! (Que pena,verdad?) Seguro que el viernes de 9:00 a 11:00 estamos todos en nuestra casa haciendo la práctica de OCA como buenos alumnos…

En fin, hoy mi partner y yo hemos compartido tareas: Guille ha estado con Pablo y con nuestro, ya conocido y mundialmente famoso, problema del videojuego (timers,threads…) y yo he ido haciendo la práctica (si no, a este paso no ibamos a hacer ninguna). Pues no ha sido dificil del todo no?:

En el 1º ejercicio se nos pedía implementar una tabla hash con trucos para un videojuego…La verdad es que, con el código que nos dan de ejemplo en la clase de teoría, era bastante sencillito, es decir, te creas todos los trucos que quieras y los vas añadiendo a la tabla dandoles una clave y un valor para luego poder acceder a ellos fácilmente.

El 2º ejercicio está hecho y es sobre algoritmos recursivos. Nos dan los distintos métodos implementados y tenemos que saber que hace cada uno:

-Factorial: calcula simplemente el factorial de un número, multiplicando ese mismo por todos los anteriores (mayores que uno).

-p1: Imprime números por pantalla(primero uno, luego el anterior, el anterior… [p1 (a-1)]) hasta que llegue al cero. (p2 hace algo parecido)

-suma: se trata de un método recursivo que suma los elementos de un array de enteros. Utiliza una condición de salida para comprobar si nos encontramos en la última posición del array y si es así devuelve el dato que hay en esa posición, si no, devuelve el elemento actual.

-inverso: Como poder obtener el inverso de un número que nos den.

-fibonacci: aquí ya no llegamos, pero bueno, lo que hace este método es desarrollar la serie de fibonacci, es decir, si me pasan el nº 20 por ejempl, pues haría FIB(19)+FIB(18) (a no ser que el nº fuera un 1 o un 2)

El último ejercicio está en proceso…tranquilos que no se quedará en el olvido.

Y bueno…lo de los métodos, aceptamos sugerencias, consejos y correcciones, por supuesto, no estamos seguros al 100% de que hagan eso, pero creemos que si.

Hasta la semana que viene!!!!

¿Que qué nos pasa con el videojuego?

Pues según Pablo, Jorge y Jose Jesús nuestro problema viene de los hilos, es decir, al darle al botón de nueva partida generamos un evento y nuestro programa no ejecuta ningún evento más hasta que no acaba éste. Bueno pues nosotros queremos que empiece la partida y que además luego vaya mostrando los colores y cambiando el round según avancemos. ¿La solución? Pues algo así como partir el evento en tantas partes como necesitamos y utilizar un Timer para que se vaya ejecutando cada proceso el tiempo que queramos.

Y según Alberto…mmmm, copio y pego directamente lo que nos respondió al pedirle una tutoría:

Varias preguntas antes de que os paséis por aquí el viernes:

1) ¿Te gustaría recivir 500 correos al día, de diferentes personas y
sobre diferentes temas, todos ellos sin ningún texto descriptivo en el
asunto?

2) ¿Te gustaría recivir 500 correos al día, muchos de los cuales
pertenecen a una conversación común, pero que seán imposibles de
relacionar por que el que los manda no se molesta en mantener la
información de hilo en sus respuestas?

3) ¿Qué dicen los apuntes de la asignatura sobre lo que me estáis preguntando?

4) ¿En qué práctica se explica con detalle lo que me estáis preguntando?

5) ¿Qué dicen los libros de SWING sobre lo que me estas preguntando?

Las preguntas 1 y 2 son retóricas.

Si chicos si, aparte de poner reciVir con V, te falta al respeto (vacilándonos), y por supuesto se te quitan las ganas de ir a la tutoría (vamos, que no vamos a ir). Esto es justo lo que necesita un alumno en quinta convocatoria que busca ayuda:  si a un profesor (que como bien dice la palabra es profesor) que se supone que aparte de para explicar en clase, está para resolver dudas , no lo hace, o mejor dicho, no le apetece hacerlo…genial!;)[GRACIAS!!!!]

¡¡¡Apoyo compañeros!!!