Ejercicio 3 VERANO
Agosto 10, 2008
Enunciado Ejercicio 3
El ejercicio 3 consiste en programar un pequeño videojuego. El videojuego transcurre en un cuadrado elaborado por 4 paredes. Dentro de el habrá una pelota rebotando en las paredes. Y también una pequeña porción de pared que controlará el jugador defendiendo la pared inferior (evitando que la pelota rebote en ella). Es decir, que tendrá que rebotar en esa porción de pared. Condiciones que debe tener el juego:
- El entorno gráfico estará formado por dos paneles. En uno aparecerá el juego y en el otro una etiqueta que muestre la cuenta de los rebotes que lleva la pelota.
- Nada más ejecutarse el juego éste se iniciará y aparecerá la pelota en movimiento.
- El jugador controlará con el teclado la porción de pared pudiento ésta moverse a izquierda y derecha.
- En el otro panel aparecerá la puntuación. Esta puntuación irá creciendo de uno en uno y contará los rebotes de la pelota con la pared o con la porción de pared.
- El juego finalizará cuando la pelota toque la pared inferior del cuadrado.
//CLASE PANTALLA//Fdo. Alejandro Turrión Pérez
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.Color.*;
public class Pantalla extends JFrame implements KeyListener,ActionListener{
//Este va a ser el tablero de juego
private JLabel casillas[][];
//Contenedor que contendra el juego y el panel de puntuaciones
private Container contenedor;
private JPanel tablero;
private JPanel puntuacion;
private JLabel puntos;
//a,b,c marcaran la posicion del muro q se mueve
int a;
int b;
int c;
//pelotaX y pelotaY nos dice donde esta la pelota
int pelotaX;
int pelotaY;
Timer timer;
int segundos;
//este atributo nos dice cual es la direccion de movimiento que lleva la pelota
int ultMov;
boolean primerMovimiento=false;
int contador=0;
// configurar GUI
public Pantalla(){
super( ” Rebotessss” );
tablero = new JPanel ( new GridLayout(21, 21) );
puntuacion = new JPanel ();
puntos = new JLabel(“Puntos”+Integer.toString(contador));
puntuacion.add(puntos);
// crear y agregar labels
casillas = new JLabel[21][21];
this.addKeyListener(this);
pelotaX = 10;
pelotaY = 13;
a = 9;
b = 10;
c = 11;
segundos=0;
timer = new Timer(100,this);
for(int i=0;i<21;i++){
for(int j=0;j<21;j++){
casillas[i][j]=new JLabel();
tablero.add(casillas[i][j]);
casillas[i][j].setOpaque(true);
if(i==0 || j==0 || j==20 || i==20){
casillas[i][j].setBackground(Color.BLACK);
}
else{
casillas[i][j].setBackground(Color.WHITE);
}
if (i==18 && (j==a || j==b || j==c))
casillas[i][j].setBackground(Color.BLACK);
}
//this.visualizar();
}
contenedor = getContentPane();
contenedor.setLayout(new GridLayout(1,2));
contenedor.add(tablero);
contenedor.add(puntuacion);
casillas[pelotaX][pelotaY].setBackground(Color.RED);
timer.start();
this.visualizar();
} // fin del constructor
public void visualizar(){
setSize( 600, 350 );
setVisible( true );
}
//Metodo que se ejecuta cuando se crea un evento producido por el teclado. Primero en ejecutarse
public void keyPressed(KeyEvent e)
{
switch (e.getKeyCode())
{
case KeyEvent.VK_LEFT :
if(a==1){
}
else{
casillas[18][a-1].setBackground(Color.BLACK);
casillas[18][c].setBackground(Color.WHITE);
a=a-1;
b=b-1;
c=c-1;
}
break;
case KeyEvent.VK_RIGHT :
if(c==19){
}
else{
casillas[18][a].setBackground(Color.WHITE);
casillas[18][c+1].setBackground(Color.BLACK);
c=c+1;
b=b+1;
a=a+1;
}
break;
}
}
public void keyTyped(KeyEvent e)
{
// Metodo segundo en ejecutarse
e.consume();
}
// Metodo tercero en ejecutarse
public void keyReleased(KeyEvent e){
e.consume();
}
public void diagArribIzq(){
casillas[pelotaX][pelotaY].setBackground(Color.WHITE);
casillas[pelotaX-1][pelotaY-1].setBackground(Color.RED);
pelotaX = pelotaX-1;
pelotaY = pelotaY-1;
//Guardamos la direccion que lleva
ultMov = 1;
}
public void diagArribDcha(){
casillas[pelotaX][pelotaY].setBackground(Color.WHITE);
casillas[pelotaX-1][pelotaY+1].setBackground(Color.RED);
pelotaX = pelotaX-1;
pelotaY = pelotaY+1;
ultMov = 2;
}
public void diagAbajIzq(){
casillas[pelotaX][pelotaY].setBackground(Color.WHITE);
casillas[pelotaX+1][pelotaY-1].setBackground(Color.RED);
pelotaX = pelotaX+1;
pelotaY = pelotaY-1;
ultMov = 3;
}
public void diagAbajDcha(){
casillas[pelotaX][pelotaY].setBackground(Color.WHITE);
casillas[pelotaX+1][pelotaY+1].setBackground(Color.RED);
pelotaX = pelotaX+1;
pelotaY = pelotaY+1;
ultMov = 4;
}
public void fin(){
System.out.println(“Has perdido feo”);
timer.stop();
System.out.println(contador);
}
//Metodo que ejecuta los eventos creado por el timer
public void actionPerformed(ActionEvent e){
if(primerMovimiento==false){
this.diagArribIzq();
primerMovimiento=true;
}
if (ultMov == 1){
if((pelotaX-1) == 0 && (pelotaY-1) == 0){
this.diagAbajDcha();
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
}
else{
if((pelotaX-1) == 0){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagAbajIzq();
}
else{
if((pelotaY-1) == 0){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagArribDcha();
}
else
this.diagArribIzq();
}
}
}//fin ultMov=1
if (ultMov == 2){
if((pelotaX-1) == 0 && (pelotaY+1) == 0){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagAbajIzq();
}
else{
if((pelotaX-1) == 0){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagAbajDcha();
}
else{
if((pelotaY+1) == 20){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagArribIzq();
}
else
this.diagArribDcha();
}
}
}//fin ultMov=2
if (ultMov == 3){
if(((pelotaY) == a || (pelotaY) == b || (pelotaY) == c) && pelotaX+1==18){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagArribIzq();
}
else{
if((pelotaY-1) == 0){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagAbajDcha();
}
else{
if((pelotaX+1) == 20){
this.fin();
}
else
this.diagAbajIzq();
}
}
}//fin ultMov=3
if (ultMov == 4){
if(((pelotaY) == a || (pelotaY) == b || (pelotaY) == c) && pelotaX+1==18){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagArribDcha();
}
else{
if((pelotaY+1) == 20){
contador++;
puntos.setText(“Puntos”+Integer.toString(contador));
System.out.println(contador);
this.diagAbajIzq();
}
else{
if((pelotaX+1) == 20){
this.fin();
}
else
this.diagAbajDcha();
}
}
}//fin ultMov=4
this.visualizar();
}
public static void main( String args[] )
{
Pantalla aplicacion = new Pantalla();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
}
Conceptos del ejecicio 3
- Este ejercicio ejercita la capacidad de abstracción al resolver un problema complejo. El como afrontarlo, organizar y planificar su solución.
- Se trabaja el entorno gráfico de un programa ayudandose de los de Swins. Mediante frames, paneles, etiquetas grids, etc.
- Se ha practicado el uso de los eventos para interactuar con el juego, eventos keyListener, o eventos creados por la própia máquina, eventos ActionListener.
- Se ha tenido que usar la clase Timer para poder añadir la dimensión temporal a un programa.
- Se ha tenido que prácticar la elaboración de algoritmos que resuelvan las condiciones y problemas que definen el programa.
Ejercicio 2 – Verano
Agosto 3, 2008
Enunciado Ejercicio 2
El ejercicio 2 comienza programando un vector que almacene números enteros. Por lo tanto se creara una clase cuyos objetos seran vectores que alberguen una serie de números (para este ejercicio se programará de tal modo que al invocar un objeto de la clase MiVector se le pase de argumento un número entero, y este indicará la cantidad de números que tendrá el vector, e irán ordenados de menor a mayor). Tendrá un método imprimir que nos muestre en pantalla todos los números que contiene el vector uno debajo de otro.
Luego habrá que programar una pila estática que contenga objetos MiVector. Está pila se implementará mediante un array y métodos para apilar y desapilar de tal modo que el array se comporte como una pila LIFO. Se le añadirán métodos para saber si la pila esta llena o vacía. Y otro mñetodo para imprimir los vectores que contenga la pila. Es decir, un método imprimir que llame a cada método imprimir de cada vector que contiene.
Por último se programará una cola dinámica que contendrá las anteriores pilas que hemos programado. Tendremos que tener métodos para encolar y desencolar. Métodos para saber si la cola esta vacía (no necesitamos saber si está llena porque como es dinámica, puede ser del tamaño que queramos). Y aparte tendrá también su método imprimir que llamará al método imprimir de cada pila que contiene la cola.
Una vez que se imprime, la estructura de datos deberá quedar como antes de imprimir. Es decir, que debemos poder imprimir todas las veces que queramos, y debiera salirnos lo mismo, o variar según vayamos encolando o desencolando.
//Solución ejercicio 2
//Clase MiVector
import java.util.Vector;
import java.util.Enumeration;
public class MiVector{
private Vector miVector;
//Array de enteros que llenara el vector
private int[] numeros;
//Constructor.Se le pasa de argumento la cantidad de numeros que tendra el vector
public MiVector(int cuenta){
miVector = new Vector();
numeros = new int[cuenta];
//Metemos en el vector los numeros que guarda el array
for(int i=0;i<cuenta;i++){
numeros[i]=i+1;
String stringCuenta = numeros[i]+”";
miVector.addElement(stringCuenta);
}
}
//Metodo que añade un numero al vector
public void aniadeNumero(int numero){
String stringNumero = numero+”";
miVector.addElement(stringNumero);
}
//Imprimimos con ayuda de la clase enumeration
public void imprimir(){
System.out.println();
Enumeration e=miVector.elements();
while(e.hasMoreElements()){
String numVector=(String)e.nextElement();
System.out.println(numVector);
}
System.out.println();
}
}
//Clase Pila
public class Pila{
private int elementos;
//Array que forma la pila de vectores
private MiVector pila[];
private int indice;
public Pila (int elementos){
this.elementos = elementos;
//Iniciamos el indice a -1 porque esta vacia la pila
indice = -1;
//Creamos la pila de vectores
pila = new MiVector [elementos];
}
//Indica si la pila esta vacia
public boolean vacia(){
if(indice == -1)
System.out.println(“la pila esta vacia”);
else
System.out.println(“la pila NO esta vacia”);
return (indice == -1);
}
//Indica si la pila está llena
public boolean llena(){
if(indice == elementos-1)
System.out.println(“la pila esta llena”);
else
System.out.println(“la pila NO esta llena”);
return (indice == elementos-1);
}
//Inserta un elemento en la pila
public void apilar(MiVector vector){
indice ++;
pila[indice] = vector;
}
//Saca un elemento de la pila
public MiVector desapilar(){
MiVector vector = pila[indice];
indice–;
return vector;
}
//Metodo imprimir
public void imprimir(){
System.out.println(“Pila”);
for (int i=0; i<=indice; i++){
System.out.println(“Vector”+(i+1)+”:”);
//Llamamos al metodo imprimir del vecctor que alberga la pila
pila[i].imprimir();
}
}
}
//Clase Nodo
public class Nodo{
private Nodo siguiente;
private Pila pila;
//Cada nodo guarda una pila y la referencia al nodo que le sigue
public Nodo(Pila pila, Nodo siguiente){
this.pila = pila;
this.siguiente = siguiente;
}
public Nodo dameSiguiente(){
return siguiente;
}
public Pila damePila(){
return pila;
}
public void actPila(Pila P){
pila = P;
}
public void actSiguiente(Nodo N){
siguiente = N;
}
}
//Clase Cola
public class Cola{
//Estos dos nodos crearan las referencias
private Nodo ultimo;
private Nodo primero;
public Cola(){
ultimo = null;
primero = null;
}
public boolean vacia(){
return (primero == null);
}
public void encolar(Pila elemento){
//Si esta vacia
if(this.vacia()){
Nodo N = new Nodo (elemento, null);
primero = N;
ultimo = N;
}
//Si no esta vacia
else{
Nodo N = new Nodo(elemento,null);
ultimo.actSiguiente(N);
ultimo = N;
}
}
public Pila desencolar(){
//Nodo auxiliar
Nodo N;
//Si esta vacia
if(this.vacia()){
return null;
}
//Si solo hay un elemento
if(ultimo == primero){
N = primero;
primero = null;
}
//Si hay mas de un elemento
else{
N = primero;
primero = N.dameSiguiente();
}
return N.damePila();
}
public void imprimir(){
System.out.println(“ LA COLA”);
System.out.println(“—————————————-”);
if(this.vacia()){
System.out.println(“La cola esta vacia”);
}
//Nodo auxiliar que ira recorriendo la cola
Nodo aux = primero;
while(aux != null){
Nodo N = aux.dameSiguiente();
aux.damePila().imprimir();
aux = N;
}
}
//Metodo main para comproblar la aplicacion
public static void main(String args[]){
MiVector a = new MiVector(2);
MiVector b = new MiVector(4);
MiVector c = new MiVector(6);
MiVector d = new MiVector(8);
Pila pila1 = new Pila(4);
Pila pila2 = new Pila(4);
Pila pila3 = new Pila(4);
Cola laCola = new Cola();
pila1.apilar(a);
pila1.apilar(b);
pila2.apilar(c);
pila2.apilar(d);
pila3.apilar(a);
pila3.apilar(b);
laCola.encolar(pila1);
laCola.encolar(pila2);
laCola.encolar(pila3);
laCola.imprimir();
laCola.desencolar();
laCola.imprimir();
}
}
Conceptos del ejecicio 2
- En este ejercicio hemos aprendido a trabajar con las estructuras de datos básicas: vectores, pilas, colas y arrays.
- Hemos aprendido a diferenciar entre estructuras de datos estáticas (la pila) así como dináicas (la cola).
- Hemos tenido que programar algoritmos para convertir un array en una pila. Es decir, a conseguir que un array se comporte como nosotros lo programemos.
- En este ejercicio se practica la organización de datos, y hemos tenido que programar metodos de acceso a los datos para poder imprimirlos tal y como deseamos .
Ejercicio 1 – VERANO
Julio 27, 2008
Este ejercicio trata de crear una jerarquia de clases. En concreto nos piden que solo haya 4 clases y un interfaz, por lo que cuando compilemos solo debemos tener 5 archivos “.class”.
—————————————————————————
La primera clase que nos piden implementar se llama “Personaje”.
Nos dicen que no se crearán instancias de dicha clase por lo que entiendo que se trata de una clase abstracta. Contendrá un método abstracto, el método imprimir(), puesto que se dejará sin implementar.
Piden que como mínimo albergue atributos para guardar la vida, la fuerza, la inteligencia, la astucia y el vigor de cada personaje (puede tener más). Yo los entiendo como atributos numéricos (int). Además el atributo “vigor” nos dicen que tiene que ser común para todos los personajes, por lo tanto deduzco que es un atributo estático. Los atributos serán todos publicos.
En cuanto al constructor, tendrá que iniciar todos los atributos. Piden que además se tome nota del objeto que lo llamó. Tendrá que tener también métodos de acceso a los atributos, es decir, los get() y set().
—————————————————————————
La siguiente clase se llama “Guerrero”.
Esta clase deberá heredar de Personaje (extends). Añadiremos los atributos habilidad, punteria y uno que llamaré “cuentag”, que será estático puesto que se inicializa una sola vez, e irá contando cuantos guerreros se van creando. Como no se especifica manera de eliminar un guerrero, pues no he implementado como bajar esa cuenta, solo irá subiendo.
El contructor tendrá que llamar con “super” al constructor de Personaje, y además inicializar sus propios atributos. Y subir en uno el atributo cuentag.
Tendrá también que reescribir el método imprimir().
—————————————————————————
La clase “Maga”.
Se comporta igual que Guerrero pero añade alguna función.
La primera es que tendrá que implementar un interfaz, por lo que además de heredar de Personaje, implementará a Hechicero (implements).
El constructor igual que en Guerrero, pero para sus atributos.
El método imprimir() igual que en Guerrero.
Tendremos que añadir los métodos que se declaran en el interfaz Hechicero e implementar su función. En este caso se tratan de dos metodos que duplican el valor de los atributos magia y poder.
—————————————————————————
La interfaz “Hechicero”.
Simplemente se indicará que es un interfaz y se declaran los métodos doblarMagia() y doblarPoder().
—————————————————————————
La última clase se llama “Prueba” y es la que contiene el método main().
Daremos un valor al atributo Vigor, que como es estático, y el método setVigor() también, no tendremos problema en darle valor sin crear ningún objeto.
Después crearemos un objeto Maga e implementaremos un método que se llama personajeCambiado() que llamará al método imprimir del objeto personaje que se le pase como argumento.
———————————————————————————————————————————————————————————————————————————
//ATRIBUTOS
public String nombre;
public int vida;
public int fuerza;
public int inteligencia;
public int astucia;
public static int vigor; //Es estatico porque sera comun a todos los objetos
Prueba prueba = new Prueba();
//CONSTRUCTOR
public Personaje (String nombre, int vida, int fuerza, int inteligencia, int astucia) {
this.nombre = nombre;
this.vida = vida;
this.fuerza = fuerza;
this.inteligencia = inteligencia;
this.astucia = astucia;
}
//METODOS DAME
public int getVida(){
return vida;
}
public int getFuerza(){
return fuerza;
}
public int getInteligencia(){
return inteligencia;
}
public int getAstucia(){
return astucia;
}
public int getVigor(){
return vigor;
}
//METODOS PON
public void setVida(int vida){
this.vida = vida;
prueba.personajeCambiado(this);
}
public void setFuerza(int fuerza){
this.fuerza = fuerza;
prueba.personajeCambiado(this);
}
public void setInteligencia(int inteligencia){
this.inteligencia = inteligencia;
prueba.personajeCambiado(this);
}
public void setAstucia(int astucia){
this.astucia = astucia;
prueba.personajeCambiado(this);
}
public static void setVigor(int vigor1){
vigor = vigor1;
}
//METODO IMPRIMIR
public abstract void imprimir();
}
public class Guerrero extends Personaje{
//ATRIBUTOS
public int habilidad;
public int punteria;
public static int cuentag = 0;
//CONSTRUCTOR
public Guerrero (String nombre, int vida, int fuerza, int inteligencia, int astucia, int habilidad, int punteria){
super(nombre,vida,fuerza,inteligencia,astucia);
this.habilidad = habilidad;
this.punteria = punteria;
cuentag = cuentag + 1;
}
public int getHabilidad(){
return habilidad;
}
public int getPunteria(){
return punteria;
}
public int getCuentag(){
return cuentag;
}
public void setHabilidad(int habilidad){
this.habilidad = habilidad;
prueba.personajeCambiado(this);
}
public void setPunteria(int punteria){
this.punteria = punteria;
prueba.personajeCambiado(this);
}
public void imprimir(){
String str = “”;
str += “Vida = ” + vida + “\n”;
str += “Fuerza = ” + fuerza + “\n”;
str += “Inteligencia = ” + inteligencia + “\n”;
str += “Astucia = ” + astucia + “\n”;
str += “Vigor = ” + vigor + “\n”;
str += “Habilidad = ” + habilidad + “\n”;
str += “Punteria = ” + punteria + “\n”;
str += “Guerreros creados = ” + cuentag + “\n”;
str += “——————————” + “\n”;
System.out.print(str);
}
}
//———————————————————————
public class Maga extends Personaje implements Hechicero{
//ATRIBUTOS
public int magia;
public int poder;
public static int cuentam = 0;
//CONSTRUCTOR
public Maga (String nombre, int vida, int fuerza, int inteligencia, int astucia, int magia, int poder){
super(nombre,vida,fuerza,inteligencia,astucia);
this.magia = magia;
this.poder = poder;
cuentam = cuentam + 1;
}
//METODOS
public int getMagia(){
return magia;
}
public int getPoder(){
return poder;
}
public int getCuentam(){
return cuentam;
}
//————————————————————-
public void setMagia(int magia){
this.magia = magia;
prueba.personajeCambiado(this);
}
public void setPoder(int poder){
this.poder = poder;
prueba.personajeCambiado(this);
}
//————————————————————-
public int doblarMagia(){
this.magia = this.getMagia() * 2;
prueba.personajeCambiado(this);
return magia;
}
public int doblarPoder() {
this.poder = this.getPoder() * 2;
prueba.personajeCambiado(this);
return poder;
}
public void imprimir(){
String str = “”;
str += “Vida = ” + vida + “\n”;
str += “Fuerza = ” + fuerza + “\n”;
str += “Inteligencia = ” + inteligencia + “\n”;
str += “Astucia = ” + astucia + “\n”;
str += “Vigor = ” + vigor + “\n”;
str += “Magia = ” + magia + “\n”;
str += “Poder de Luz = ” + poder + “\n”;
str += “Magas creados = ” + cuentam + “\n”;
str += “——————————” + “\n”;
System.out.print(str);
}
}
//———————————————————————
public interface Hechicero{
//metodos declarados
public int doblarPoder();
}
//———————————————————————
Personaje.setVigor(20);
Maga riana = new Maga(“riana”,1,2,3,4,5,6);
}
public void personajeCambiado(Personaje personaje){
personaje.imprimir();
}
}
———————————————————————————————————————————————————————————————————————————
Conceptos del ejecicio 1
- En este ejercicio se han practicado los conceptos más básicos de herencia de clases, y jerarquía de clases.
- Hemos trabajado con clases abstractas, clases heredadas e interfaces, implementando métodos y constructores en base a esta jerarquía.
- También hemos visto el uso de los atributos y los métodos estáticos, haciendo uso de ellos cuando nos ha sido necesario.
- Hemos visto la utilidad de reescribir métodos de modo que se crea un código más eficiente.
- Y por último, se ha practicado la llamada a métodos de otras clases, es decir, la interactuación de clases, métodos y atributos de un conjunto de clases.
FINALIZACIÓN DEL JUEGO
Mayo 29, 2008
Presentación Juego JAVA
Simón, el teclado molón
Programadores: Alejandro Turrión Pérez
Inazio Lizuain Lilly
Este juego es el típico Simon, que consiste en repetir las “notas musicales” que nos irá dando el ordenador.
Hemos hecho algunos cambios: tenemos un teclado que según se tocan las notas (con el ratón) se va iluminando a la vez que suena. El ordenador nos muestra primero una secuencia y hay que repetirla en el mismo orden y en un tiempo definido.
Características del juego:
- El juego consta de una ventana dividida verticalmente en 3 zonas bien diferenciadas. La zona de arriba guarda los botones del menú, desde donde accederemos a los distintos paneles que puede mostrar el juego. La segunda, la central, es en la que aparece el teclado. Se puede decir que es la zona de juego. Y la tercera y última, la de abajo, muestra los mensajes que nos da el ordenador(puntuación,…)..
- La opción de Mejores Puntuaciones muestra las cinco mejores puntuaciones.
- La opción de Normas nos dice como jugar al juego.
- La opción de Salir, sale de la aplicación.
- La opción de iniciar nos deja empezar a jugar.
- Cuando se empieza una partida, el juego nos da a elegir con que personaje queremos jugar.
- Antes de cada secuencia, ya sea tocada por la máquina o por nosotros, nos avisará de si estamos preparados, y tendremos que contestar.
- Cuando nos toque repetir la secuencia, se nos mostrará en la zona de mensajes el tiempo que tenemos para tocar las teclas (un reloj).
- Si no se han dado las notas exactas, y en el mismo orden que las que toca la máquina, o el tiempo se ha acabado se perderá la partida. Su puntuación será guardada, y en caso de estar entre las cinco mejores, aparecerá en Mejores Puntuaciones.
- Las partidas se dividen en niveles y secuencias. Cada nivel alberga tres secuencias. La velocidad en la que repetir la secuencia (la del reloj) así como la puntuación que se obtiene ira en consecuencia al nivel y la secuencia en la que estemos. Esta es la manera en la que la dificultad va creciendo a lo largo del juego.
- El jugador podrá tocar el teclado aún sin encontrarse dentro de una partida.
Diagrama de Clases:
De vuelta por aqui…
Mayo 24, 2008
Bueno, tras una breve pausa, y tener esto olvidadillo debido a las muchas horas dedicadas a poner el juego en marcha, ya podemos decir que si! Hemos acabado el juego. Y lo mejor de todo: FUNCIONA!!! Pues eso, que volvemos a retomar esto.
Hoy mismo hemos terminado el juego y no hemos tenido mucho tiempo para dedicar a las prácticas. Solo las dos horas que se dedican a la semana en clase, y claro… no dan para acabarlas y poder comentarlas como es debido. De todos modos, el pequeño contacto que tuvimos con ellas nos abrieron los ojos del entorno gráfico en java y claro, tuvimos que aplicarlo al juego antes que a las prácticas. Que de todos modos, ahi estamos con ellas, y en breves tendreis un par de comentarios por aquí…
Venga. Un saludo.
Práctica 6
Mayo 5, 2008
Bueno, después de una temporadilla de parón, hemos retomado las prácticas ya ahí vamos.
En esta práctica lo unico que tenemos que hacer es una estructura cola de objetos tipo pieza de manera estática, es decir, con un array de tamaño conocido. El problema principal a la hora de programar los diferentes metodos de estas dos clases ha sido el intentar hacer un código lo más eficiente posible. Para ello en el método encolar, hemos necesitado unas variables que ayuden a delimitar la cabeza y la cola del array.
Principalmente, esto ha sido lo mas difícil y a pesar de que lo hemos intentado, probablemente habrá mas y mejores formas de programarlo. Nos reservamos el esfuerzo para la siguiente práctica que trata de programar lo mismo mediante colas dinámicas…Ahí esta el tema!
Práctica 5
Abril 3, 2008
Holas:
A ver, esta práctica ya está más entretenida. Eso si, los dos primeros ejercicios no molan nada de nada. Gracias a dios que tenemos paciencia, y decidimos saltarnoslos porque no había por donde pillarlos. No me extrañaría que mas de uno tirara la toalla antes de ver de que iba realmente la práctica. Estaría bien que se replantearan esos ejercicios y se hicieran mas masticables:
toString??
implementar public void guarda()??
FICHEROS??????
Buscaremos por ahi si algún grupo habla un poco de estos ejercicios.
LA PRÁCTICA:
En estos ejercicios hemos tenido que tirar un poco de intuición, avanzar sin saber muy bien por donde ibamos ni que implementaba que, y quien invocaba a quien, etc…
Con ayuda un poco del API y prestando mucha atención te vas empapando un poco de como mostrar pantallas, botones y demás.
Nos tuvo bastante entretenido el descubrir como funciona el método paint, por qué se ejecutaba si en ningún sitio veiamos llamadas al mismo. Y fijandonos en un parrafito de la práctica que no llamaba mucho la atención (hubiera estado bien que se remarcara), y viendo en la consola las trazas de depuración nos dimos cuenta de que es el propio ordenador el que ejecuta dicho método según sus necesidades. Así cuando maximizas la ventana lo ejecuta de una manera, luego al minimizar vuelve a ejecutar, etc etc. Tiene lógica.
Pasamos a comentar el último ejercicio y asi hablamos un poco de todo:
En este lo que hacemos es crear una ventana en la que aparecerán ciertos componentes graficos. Estos serán de tipo botón y menú, que irán almacenados en un array que declara la clase GUIContenedor. Por tanto lo primero que hacemos es pintar la ventana (ha sido ya creado un objeto ventana). Llamamos a su método paint y éste la pinta. Después el mismo método llama al paint de GUIContenedor y éste recorre un array en el que tenemos almacenados los botones y menues. Lo recorre llamando a cada método paint de cada componente.
Y de este modo hemos pintado la ventana con sus componentes.
Al principio creiamos que para pintar la ventana deberiamos llamar al método paint de la clase ComponenteGrafico, que al fin y al cabo pinta lo mismo, pero no supimos implementarlo. Tampoco sabemos si se podria haciendo un “doble super”. Si alguien lo sabe, que nos lo cuente.
Y hasta aquí hemos llegado. Mañana Práctica 6. A ver que tal!
Saludos, Inazio y Alex.
Practica 4
Marzo 27, 2008
Bueno, ya estamos de vuelta.
Esta practica la hicimos antes de semana santa pero la comentamos ahora.
Consiste en reescribir las clases de la “practica 3″ pero usando jerarquias de herencia. Unas clases heredan de las otras y esas cosas. De este modo ahorramos código en las subclases usando comando super, que hace referencia a la clase que esta por encima.
Super siemrpe tiene que estar al principio del contructor o dará error.
Ejercicio 1:
En este caso, la clase madre de todas es la clase Miembro. De ella heredarán todas las demás que creemos. Aquí sólo hay que implementar el contructor y el método toString.
Ejercicio 2:
Implementar el constructor llamando al de la clase Miembro con super, y asociar los atributos con los parámetros que quedan del contructor.
Seguir implementando el método toString. Igualmente, haciendo referencia al métedo toString de Miembro.
Para implementar este método tuvimos algunso problemas y nos ayudo usar una variable local que usamos imitando a las clases ya hechas por los profesores y que nos ayudo a tener mas ordenados los métodos.
Ejercicio 3:
Esto es más de lo mismo, implementar la clase Metodo, al igual que la anterior de atributo. La única diferencia esque tendremos qque hacer referencia a la clase Parametro.
Ejercicio 4:
Ahora toca implementar la clase Contructor. Esta hereda de Metodo logicamente, porque es un método. Especial, ya que no devuelve nada.
Ejercicio 5:
Ahora toca implementar la clase Clase. Esta es la más compleja, es la que recopila la información que le pasamos (una clase) y guarda todas las carácteristicas, atributos, metodos, parametros, etc, y las guarda en arrays de tipo objetc. En esta clase solo tenemos que implementar el método toString. Lo que tenemos que hacer es ir recorriendo los arrays ordenadamente, e ir imprimiendo.
El resto de la práctica consistirá en probar si todo lo que hemos hecho funciona.
YES!! funciona.
P/D: Creemos que ha sido una práctica un poco mal enfocada, ya que crea mucho lio, ademas no puedes ir probando las cosas hasta el final. Es un programa que no se llega a entender claramente.
Venga, nos vemos ya en las prácticas serias.
Practica 3
Marzo 13, 2008
En esta practica nos introduciomos ya en el maravilloso mundo de la programación orientada a objetos (POO).
El primer apartado, el apartado 0, era bastante sencillo. Nos daban una clase y teniamos que fijarnos en como estaba hecha, hacer unos objetos de dicha clase, y llamar a métedos desde fuera de esa clase, en fin, esas cosillas que vamos a estar utilizando constantemente.+
Ejercicio 1:
Aquí nos dan una clase (“Modificador”). Es una clase que contiene como atributos todos los tipos de modificadores que usa Java. Asocia estos modificadores a números enteros, de forma que luego, cuando ejecutemos, le pasamos como parámetro un número, que la clase lo usará como parámetro en su método toString, y nos dirá de que modificador estamos hablando. Suena un poco lioso, pero es bastante sencillo, solo hay que fijarse en el código un poquito.
Ejercicios 2 y 3:
Bueno, pues en estos ejercicios lo único que nos pedian era que, de las clases que nos daban (“Atributo”, “Metodo”,”Constructor”) implementaramos el código de sus respectivos constructores y el método toString que tenía cada clase.
El contructor fácil, solo asociar los parámetros a los atributos. Luego, desde la clase modificador creabamos objetos Atributo, Metodo y Constructor donde les pasabamos por parámetros los que tuviera definido sus contructores. De entre ellos, destacar el de modificador, que era un entero. Por tanto, en los métodos toString de las clases el parámetro modificadores lo pasabamos de las siguente forma:
Modificador.toString(modificadores)
Como ya os habreis percatado, hemos llamado al método toString de la clase Modificador, pero en ningún momento hemos tenido que crear un objeto de dicha clase. Esto sucede así porque su método toString es estático.
Práctica 2 denuevo
Marzo 6, 2008
Pues nos pusimos con el ejercicio 4 y nos ha servido ufffff, para cuanto nos ha servido!!
Éste trata de controlar las “excepciones” que nos genera una clase. Nos encontramos con diferentes tipos de excepciones.
Por ejemplo:
1- Out of Bounds Exception: nos apareció cuando llamamos a una posición de un array fuera de sus limites ( un array de 8 posiciones, y llamas a la posicion 10).
2- Null Pointer Exception: ésta nos aparecio al llamar a una posición de un array que estaba referenciada pero no instanciada (jejeje). Que sólo lo creamos pero no le dimos valores.
3- Arithmetic Exception: ésta sale cuando surge la “típica indeterminación matemática” (dividir entre cero y demás).
4- Exception: la clase de la que heredan las anteriores excepciones y todas las que faltan.
En el cath (que usamos para tratar las excepciones) es donde diferenciaremos que tipo de excepciónes tenemos, y podemos poner tantos como excepciones creemos que nos ocurrirán, y tratar a cada uno de forma diferente.
Cuando nos hemos puesto a compilar la clase ExcepcionApp que trae la práctica nos dio un error en “respuesta” debido a que no estaba inicializado. Lo hemos inicializado a “null”. Cuando ejecutamos nos dimos cuenta de que además de tratarse la excepción nos mostraba el valor de “respuesta” que era null. Lógicamente eso no está bien y lo hemos resuelto con un System.exit(1) al final del catch.
Nos ibamos a poner con el ejercicio 5 pero los ficheros… a ver si alguien nos cuenta un poco de que va el tema.
Nos vamos a comer.
