Día 11.0

•Mayo 25, 2008 • 1 comentario

Práctica 12: JMF

 

El profesor nos dijo que antes de comenzar con la práctica volviéramos a mirar el ejemplo hecho en clase (la clase Mi_Reproductor) e intentáramos comprenderlo bien.

 

El Ejercicio 1 se puede completar con este ejemplo, ya que el funcionamiento es el mismo que el de la clase Mi_Reproductor sólo que utilizamos el archivo : video.mpeg.

 

Ésta clase (ahora llamada Ejercicio1)  hereda de JFrame e implementa de ControllerListener , suponemos entonces que va a utilizar elementos de control.

 

  • Atributos:  
  1. Player player = null; //Reproductor, como su propio nombre dice lo que hace es reproducir, no tiene una imagen, es un objeto.
  2. Component visualComponent = null; // Componente de reproducción del vídeo, éste si que tiene representación real, una parte de la ventana será destinada para esto (similar a un Jpanel).
  3. Component controlComponent = null; // Controles, también tiene representación visual. (play/pause/stop…).
  4. Component progressBar = null; // Barra de progreso.
  5. String MEDIAFILE = “file:video.mpeg”; //  Localiza el archivo

 

Cuestión: ¿ cómo sabemos que el Player está preparado?

            El Player avisa lanzando cierta información, tiene varios estados.

 

  •  Constructor:
  1.  Sobre el panel principal establezco un “Layout”.
  2. Para crear el Player utilizo:        a) url  b) manager

      3. Tenemos que identificar nuestro fichero mediante un objeto de la clase URL (Uniform Resource Location)

      4. Debemos especificar en qué lugar está nuestro fichero

URL url = null;

url = new URL(MEDIAFILE);

 

Trabajar con URL requiere conocer qué tipo de excepción puede generar:

  • MalformedURLException e : URL no valida

Para activar el Player:

Player crea una entidad que denomina Manager :

 

                        player=Manager.createPlayer(url);

 

Para saber en qué estado está el Player, una opción es añadir un ControllerListener: controla los estados por los que va pasando el Player, ahora el control del Player pasa directamente al método ControllerUpdate().

 

                        player.addControllerListener(this);

 

 

Manager también tiene sus excepciones:

  •  Lectura/Escritura
  • NoPlayerException : o existe el reproductor

Importante: éstas excepciones las requiere Java

 

 

Una vez que ya hemos controlado los errores podemos activarlo:

 

                        player.start(); // Comienza la reproducción.

 

 

  • Método controllerUpdate (…):

 

           public synchronized void controllerUpdate(ControllerEvent event){

 

            }

 

  1. Comprobamos que el reproductor está “vivo”
  2. ¿Qué evento se ha producido?

 

- Comprobamos si el evento es una instancia de (instanceof) RealizeCompleteEvent: hereda de ControllerEvent. Sólo cuando el Player esté realizado, cuando tenga un objeto de ésta clase como evento podré hacer:

 

            getContentPane().add(“Center”,visualComponent);

            contenedor.add(“Center”,controlComponent);

 

Hasta que no éste realizado no los puedo visualizar.

 

-Comprobamos si el evento  es una instancia de EndOfMediaEvent: también hereda de ControllerEvent. Si ha terminado de reproducir el archivo ponemos de nuevo el tiempo a cero y volvemos a activar el Player :

                       

                        player.setMediaTime(new Time(0));

                        player.start();

 

-Comprobamos si el evento es una instancia de ControllerErrorEvent: t ambién hereda de ControllerEvent. Si se produce un error de control se lanza un mensaje.

 

  • Y ya por último, el Método “main”:

 

            public static void main (String[] args) {

           

            Ejercicio1 reproductor = new Ejercicio1();

           

            reproductor.setSize(100, 100);

            reproductor.setVisible(true);

           

            }

 

 

Ejercicio 2 : “Crea ahora a partir de este reproductor uno que permita que el usuario decida qué ha de suceder cuando el vídeo llega a su fin (volver a reproducir o no)”

 

Para ello, utilizando la clase anterior, tenemos que modificar el método controllerUpdate(…) , y concretamente cuando el evento es una instancia de EndOfMediaEvent.

 

Para crear un diálogo simple y estándar utilizamos un  JOptionPane del tipo “question” con las opciones “si” o “no”.

Una página muy útil donde vienen todos los tipos de JOptionPane explicados, con ejemplos y en castellano es:

 

http://ji.ehu.es/lmalonso/sw/java/bib/tutorjava/html/ui/swingcomponents/dialog.html

 

Cuando finalice el video primero se mostrará el mensaje , si la opción elegida es “si” volvemos a reproducir  (como estaba antes), si la opción es “no” : paramos el Player, liberamos los recursos y cerramos la ventana (acabando la aplicación).

 

Código:

 

else if (event instanceof EndOfMediaEvent){

                       

int n = JOptionPane.showConfirmDialog(this, “¿Quiere volver a reproducir?”,”Reproducir”,JOptionPane.YES_NO_OPTION);

                       

if (n == JOptionPane.YES_OPTION) {

 

                                    player.setMediaTime(new Time(0));

                                    player.start();

                        }

 

                        else if (n == JOptionPane.NO_OPTION) {

 

                                                player.stop();

                                                player.deallocate();

                                                System.exit(0);

                        }

}

 

 

Ejercicio 3: “añade dos botones que permitan acceder directamente a dos escenas

 

Una escena comienza a los 6 segundos y otra a las 12 segundos. Para controlar esto tendremos que utilizar el método:

 

                        setMediaTime(new Time(double seconds));

 

Éste método tiene como parámetro un objeto de la clase Time que a su vez tiene como parámetro en su constructor  un double (que serán los segundos).

 

Para éste ejercicio creamos dos botones “escena 1” y “escena 2” que los inicializamos y los añadimos al panel principal en el constructor. También les asignamos el escuchador.

 

Utilizamos la clase de los anteriores ejercicios y añadimos, como clase anidada , la clase:

 

                        class Manejador implements ActionListener

 

En ella, si el evento producido corresponde con el botón “escena 1” pondremos el tiempo a 6 segundos y reproducimos.

Si el evento corresponde con el botón “escena 2” el tiempo será de 12 segundos.

 

Obviamente estos dos botones se podrán utilizar en todo momento de la reproducción.

 

Código del método actionPerformed(…) :

 

public void actionPerformed(ActionEvent e)
    {
        if(e.getSource() == escena1){
                     player.setMediaTime(new Time(6.0)); //El tiempo debe ser de tipo double
                     player.start();
  
         }
        else if (e.getSource() == escena2) {
                    player.setMediaTime(new Time(12.0));
                    player.start();
  
          }

    }

 

 

Día 10.0

•Mayo 21, 2008 • 1 comentario

Práctica 10: Procesos

Para ésta práctica el profesor (nosotras vamos al turno de tarde la mayoría de las veces) nos explicó un poco de qué iba la práctica, pero nos dijo que antes de comenzar con esto era mucho mejor que comprendieramos bien qué son y cómo manejar los EVENTOS.

Así que ese día cada grupo nos pusimos con nuestro juego centrándonos en el tema de eventos y con el profesor a nuestra disposición.

Entonces sólo nos queda decir:

BIENVENIDOS AL SPORE CUBES

Que es como comienza nuestro videojuego. Se llama “Spore Cubes” . Por el nombre a lo mejor no sabéis cuál es, así que os ponemos un enlace con el juego real (el nuestro ha quedado más o menos parecido ;-) ):

http://www.juegosdiarios.com/juegos/Spore-Cubes.html

Se trata de ir eliminando grupos de casillas que sean del mismo color , parece sencillo pero casi nadie llega a dejar la cuadricula vacía.

Al principio sólo contábamos con lo que sabíamos de RDA asi que nuestro juego tenía un array bidimensional de “chars” .

Había cuatro símbolos en lugar de colores: ‘o’, ‘#’, ‘*’, ‘+’

El array se rellenaba con estos símbolos aleatoriamente. Para eliminar los grupos pedíamos las coordenadas por teclado, luego teníamos un metodo que comprobaba las que eran iguales y las borraba (para este método utilizamos recursividad, así que hasta que no lo dimos en clase las casillas no se eliminaban bien).

Luego hicimos un método que bajaba las casillas que quedaban por encima de las eliminadas y otro que juntaba las columnas cuando alguna se eliminaba por completo. Éste último nos costó mucho, es más hemos conseguido que funcione bien ahora.

Pero bueno ya era “jugable”, además iba mostrando el número de casillas que aún quedaban y al finalizar podías volver a jugar.

Eso fue lo que entregamos al principio. Luego en clase empezamos ya a dar SWING y fue cuando empezamos ha agobiarnos un poco. No sabíamos si lo que habíamos hecho (que su tiempo nos llevó, como a todos) serviría ahora para algo, no teníamos ni idea de cómo ibámos a “mezclar” nuestro juego con todo lo de las pantallas , botones…. Y ahora en vez de comparar simbolos tendríamos que comparar COLORES!

Decidimos empezar entonces con la introducción al juego: la pantalla principal con la opción de “ayuda” y la opción de “jugar”, así por lo menos podíamos ir entendiendo lo de los paneles, los botones, cómo colocarlos y modificarlos, etc.

La opción de ayuda abre una ventana donde están las instrucciones del juego, para ello utilizamos un JOptionPane (con el método showMessageDialog() ), así la ventana ya está hecha y nosotras sólo tenemos que poner el texto que queremos que muestre.

Para el tablero vimos que podíamos hacer un array de botones y  poder utilizar nuestros métodos modificandolos un poco ( al final resultó fácil, sólo teníamos que obtener el color de la casilla y guardarlo en un objeto Color, y ya podríamos compararlas).

Y finalmente para trabajar con eventos pusimos directamente el método:

actionPerformed(ActionEvent e)

 dentro de la clase (para ello nuestra clase tiene que implementar la interfaz ActionListener).

Comparamos el objeto donde ocurrió la acción con los elementos del array y guardamos esas coordenadas:

 for (int filas =0;filas<MAX_FILAS;filas++){
            for (int columnas=0;columnas<MAX_COLUMNAS;columnas++)
            {
  if (e.getSource()==botones[filas][columnas]){
     i=filas;
  j=columnas;
  
  }

 }
 }

Y con esa info llamámos a los métodos.

También tenemos un contador de los bloques que quedan (aztualizamos la etiqueta cada vez que se produce una acción) y tanto si ganas como si pierdes se muestra un mensaje, también utilizando un JOptionPane .

Por último tenemos las opciones de “salir” o “reiniciar” que se pueden utilizar en cualquier momento de la partida.

Y el resultado es:

 

 INTRODUCCIÓN:

TABLERO:

 

 

 

Día 9.0

•Mayo 9, 2008 • 1 comentario

Práctica 9

 Interfaces Gráficas en Java: Swing

 Ejercicio 1:

  •  programa HelloWorldGUI: ésta clase tiene un único método, el método main, pero utiliza otros métodos que pertenecen a las clases: Jframe, Jpanel y Jlabel, que pertenecen al paquete javax.swing.

 Los métodos utilizados son:

setDefault®Jframe

add® container

get®JFrame

setSize® Window

setVisible® Window

  •  programa HelloWorldGUIBig: para hacer la ventana 4 veces más grande escribimos:

        frame.setSize(400,200);

  •  programa HelloWorldGUIColor : para que una etiqueta sea de color azul utilizamos:

        label.setBackground (Color.blue);

        label.setOpaque(true);

  •  programa HelloWorldGUIDelayed: la ventana tarda un tiempo en ejecutarse.

DUDA: no sabemos cómo interrumpirla para que salte la excepción.

 Ejercicio 2:

  •  programa HelloWorldGUIDeaf: nos piden cómo hacer que la ventana nos ignore cuando intentamos cerrarla. Buscamos en el API información sobre el método setDefaultCloseOperation(…) para ver qué opciones tiene aparte de lo que en los otros programas le hemos pasado como parámetro (EXIT_ON_CLOSE). Encontramos entonces: DO_NOTHING_ON_CLOSE, así que escribimos en nuestro programa:

 frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

 Ahora la única forma de cerrar la ventana es escribir en la línea de comandos: Ctrl+C    (es la que nosotras conocemos)

  •  programa HelloWorldGUIUndecorated: para que no se utilice ninguna decoración del manejador de ventanas utilizamos el método: setUndecorated(boolean true).

 frame.setUndecorated(true);

  •  programa HelloWorldGUIDecorated: que utilice el “Look and Feel” por defecto de Java en vez de el del manejador de ventanas: usamos de nuevo el método anterior para que no utilice ninguna decoración y luego le añadimos nosotros otra con el método getRootPane() y setWindowDecorationStyle(…):

    frame.setUndecorated(true);

    frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);

 

 Ejercicio 3: Los paneles como contenedores de elementos gráficos

 1. programa CompassSimple:

Para que la etiqueta sea de color negro:                  label.setBackground (Color.black);

                                                                                    label.setOpaque(true);

 

Para que las letras del texto de la etiqueta sea blanco:  label.setForeground(Color.white);

 

 Para que  la ventana quede maximizada al tamaño completo de la pantalla buscamos en el API info sobre el método setExtendedEstate(int state) que modifica el estado de la ventana.  Encontramos la opción “MAXIMIZED_BOTH “que maximiza tanto en horizontal como en vertical:

                        frame.setExtendedState(JFrame.MAXIMIZED_BOTH);

 

 2. programa CompassSimple: tenemos que crear cuatro etiquetas que se diferencien en el color de fondo y de letra. Esto se hace igual que en el programa anterior, cuando hemos modificado la etiqueta.  El problema es situar las etiquetas,  ya que nos piden que estén colocadas según las directrices: “North”, “South”, “East”, “West”.

 

Para ello podríamos colocarlas según coordenadas, pero es mucho más cómodo y rápido utilizar una “plantilla”, es decir uno de los Layouts.

 

Para éste caso utilizamos el BorderLayout que coloca los elementos  según  posicionamiento geográfico (justamente lo que necesitamos).

 

Primero creamos un objeto de BorderLayout:

BorderLayout plantiya= new BorderLayout(0,0); // le pasamos al constructor como parámetro el espacio que queremos que deje entre las etiquetas, en este caso no hemos dejado huecos.

 

Luego lo colocamos dentro del panel:

                        JPanel contentPane = (JPanel) frame.getContentPane();

                        frame.setLayout(plantiya);

Y podemos luego ir colocando las etiquetas del modo:

                        contentPane.add(etiqueta1, BorderLayout.NORTH);

                        contentPane.add(etiqueta2,BorderLayout.SOUTH);

 

 

 

 3. Cuestión: Cuando creas una etiqueta, ¿Qué alineado horizontal tiene por defecto su texto? ¿Y vertical?

Horizontal: por defecto queda a la izquierda.

Vertical: por defecto queda centrado (así que algo que nos ahorramos).

 

 

4. programa CompassBetter: tenemos que centrar el texto de las etiquetas. En las etiquetas que corresponden a “West” y a  “East”, que son  las que quedan a los lados y de forma vertical, no hace falta que centremos su texto ya que , como hemos dicho antes, se hace por defecto. Para las otras dos utilizamos el método: setHorizontalAlignment(…); y le pasamos como parámetro la constante CENTER :

                        etiqueta1.setHorizontalAlignment(JLabel.CENTER);

 

 

5. programa CompassMuchBetter : añadimos una nueva etiqueta que será una imagen e irá colocada en el centro. El código para crear una imagen:

 

 

                        Icon imagen= new ImageIcon(“arrow.jpg”);

                        JLabel etiqueta5 = new JLabel(imagen);

Luego la colocamos en el centro:

                        contentPane.add(etiqueta5,BorderLayout.CENTER);

 

 

6. programa CompassMuchBetterSmall: sustituimos el método JFrame.setSize() por el método JFrame.pack() que ajusta el tamaño de la ventana al tamaño mínimo necesario.

 

 

7. programa HelloWorldGUICentered : para que la ventana aparezca en el centro de la pantalla utilizamos el método setLocation(int x, int y), nosotras únicamente le hemos pasado como parámetros dos coordenadas para que quede más o menos centrada.

 

 

8. Éste apartado no lo hemos sabido hacer.

 

 

 Ejercicio 4:

Para colocar 20 etiquetas en formas de columna podíamos utilizar un GridLayout o un BoxLayout, nosotras hemos usado el primero, que se utiliza como un array bidimensional (tiene forma de “parrilla”).

 

Como en el ejercicio anterior primero hemos creado un objeto de GridLayout , a su constructor se le pasa como parámetros las filas y las columnas (en este caso 20 filas, 1 columna).

 

Luego íbamos creando las etiquetas según sean pares (con fondo negro y letras blancas) o impares (con fondo blanco y letras negras). Seguidamente de crear una etiqueta la vamos colocando en el GridLayout.

 

Por último ajustamos la ventana al tamaño de los elementos. No hemos sabido colocar el un borde al panel.

Código:

class Ejercicio   {
    public static void main(String args[]) {

JFrame frame = new JFrame(“HelloWorldGUI window title”);

 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  GridLayout plantiya= new GridLayout(20,1);

  JPanel contentPane = (JPanel) frame.getContentPane();
  frame.setLayout(plantiya);
  
  for(int i=0; i<20; i++){
  
  if(i%2 == 0){
  
  JLabel etiqueta1 = new JLabel(“etiqueta”+i);
  etiqueta1.setForeground(Color.white);
  etiqueta1.setBackground (Color.black);
  etiqueta1.setHorizontalAlignment(JLabel.CENTER);
  etiqueta1.setOpaque(true);
  contentPane.add(etiqueta1);
  }
  
  else {
  
  JLabel etiqueta2 = new JLabel(“etiqueta”+i);
  etiqueta2.setForeground(Color.black);
  etiqueta2.setBackground (Color.white);
  etiqueta2.setHorizontalAlignment(JLabel.CENTER);
  etiqueta2.setOpaque(true);
  contentPane.add(etiqueta2);
  }
 }
 
         frame.setVisible(true);
   frame.pack();
   
   }
   
}

Tampoco sabemos cómo hacer el último apartado.

 

Saludos!! 

 

 

Día 8.0

•Mayo 6, 2008 • Dejar un comentario

Práctica 8:

Ejercicio 1:

Tenemos que implementar un programa que permita insertar al memos 10 trucos para un videojuego utilizando una tabla hash.

Para ello utilizamos la clase ya hecha EjemploHashTable y escribimos 10 trucos, como por ejemplo:

ht.put(“V”,”VIDA INFINITA”);

Éste método put(…) tiene como parámetros la clave y el vamor al que corresponde, así con introducir la clave podemos acceder rápidamente al truco, en este caso “vida infinita”.

Para recuperar los valores pedimos la clave por teclado y mostramos por pantalla el truco al que corresponde. Podemos acceder a todos los trucos que queramos (de los 10) hasta que la palabra introducida no se corresponde con ninguna de la lista. Nuestro código es:

String truco =  “”;
  String x;
  BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in)); 
  do
  {
   System.out.println(“Por favor, introduzca truco”);
   
          truco=teclado.readLine();
   
   
     x = (String)ht.get(truco);
     System.out.println(x);
  }
  while(truco==”4″||truco==”8″||truco==”Ctrl”||truco==”Alt”||truco==”V”||truco==”B”

||truco==”I”||truco==”N”||truco==”D”||truco==”9″);

 

PROBLEMA: Hemos utilizado un Do while para que siga pidiendo claves por teclado mientras la palabra sea una de las de nuestra tabla, pero al ejecutarlo sólo nos deja introducir una clave y se acaba el programa, es como si no hiciera caso del do while. ¿Por qué?

 Ejercicio 2:

1. Factorial: método al que se le pasa como parámetro un número y devuelve su factorial. Si el número que le pasamos es 1 no hace más operacines y nos devuelve el 1. Con cualquier otro número lo multiplica por su anterior y asi va disminuyendo y multiplicando hasta llegar a uno. La operación que hace recursivamente es la de llamar al número anterior.

2.Método p1(…): método al que se le pasa como parámetro un número entero y no devuelve nada, sólo muestra por pantalla ese número y todos los anteriores hasta llegar a cero, y entonces imprime “FIN”. Recursivamente va llamando a los numeros anteriores.
Por ejemplo si el número que le pasamos como parámetro es el 5 mostrará por pantalla:
5
4
3
2
1
FIN

3.Método p2(…): método al que se le pasa como parámetros dos números enteros y no devuelve nada. Lo que hace es ir disminuyendo el primer número (a) en una unidad y el segundo (b)va tomando como valores la suma de los dos. Cuando “a” llega a cero el programa imprime el valor final de “b”. Recursivamente va dismuniyendo “a” y dando nuevos valores a “b”.
Por ejemplo si a=4 y b=5 :
    a=4|b=5

    a=3|b=9

    a=2|b=12

    a=1|b=14

    a=0|b=15 valor final de b, que muestra por pantalla.

4. Método suma(…): método que va sumando todas las posiciones de un array empezando por el primero hasta el último. Tiene como parámetros el array que vamos a utilizar, un índice que empieza en la primera posición (cero) y el tamaño total del array o número de elementos que puede tener. Recursivamente el índice va aumentando una posición, y así ir sumando los elementos, hasta que toma el valor del tamaño del array menos uno.

 
5. Método fibonacci(…): la serie de fibonacci es : 1, 1, 3, 5, 7… es decir, salvo para el 1 y el 2, es la suma de los dos números anteriores a nuestro número. Por ello este método hace esa suma y utiliza la recursividad para llamar a los dos anteriores.

/
6. Método inverso(…): para conseguir el inverso de nuestro número este método divide el número entre diez y muestra su resto. Mientras nuestro número sea mayor que diez vuelve a llamar al método recursivamente (pero ahora el número estará dividido entre 10 y redondeado a un entero).Por ejemplo si nuestro número es el 312:

    312/10 el resto es 2 y el resultado es 31
    31 es mayor que 10 asi que vuelvo a calcular pero ahora con este número

    31/10 el resto es 1 y el resultado es 3
    3 no es mayor que 10 asi que acabo.

    Por tanto los restos han sido: 2-1-3 (inverso de 312).

Ejercicio 3:

Representamos el juego del tetris utilizando una matriz bidimensional rellena de caracteres.

Hemos dividido el problema en dos métodos:

  • boolean compruebaFila(..) : éste método devuelve un boolean y comprueba si una celda es distinta de vacio , si es asi el contador aumenta. Comprobamos recursivamente todas las celdas de la fila. Al final el contador tendrá un valor, si el valor corresponde con el número de celdas totales de la fila el método devuelve true.

int x=0;
int y=0;
int cont=0;
boolean borrar;

public boolean compruebaFila(int x,int y,int cont,char[][]cuadricula){

 if(y< cuadricula[0].length){
  
  if(cuadricula[x][y]!=’ ‘){
      cont++;
     if(cont==10) {
            borrar=true;
         }
      else if(cont<10){
 
               borrar=false;
            }

  compruebaFila(x,y+1,cont,cuadricula); //Llamamos de nuevo al metodo pero aumentando una columna
   }
   return borrar;
 
 }

  • void borra(…) : éste método llama al método anterior y si ha devuelto true borra toda la fila. Luego recursivamente hace lo mismo con todas las filas ( es decir, primero comprueba con el método anterior si todas las celdas estan llenas y si es asi las borra).

  public void borra(int x,int y,char[][]cuadricula){
 
if(x< cuadricula.length){
 
 if(compruebaFila(x,y,cont,cuadricula)==true){

 for(int m=0;m<cuadricula[0].length;m++){
  
   cuadricula[x][m]=’ ‘;
 }
  }
 
  borra(x+1,y,cuadricula); //Vuelvo a llamar al método aumentando una fila
}
}

 

La Práctica 9 está también terminada, asi que en estos días la publicaremos.

Saludos!

Día 7.0

•Abril 27, 2008 • 1 comentario

Práctica 7:

 

Ejercicio.1:

En esta práctica hemos tenido bastantes problemas porque al principio no entendiamos muy bien lo que nos estaban pidiendo, al empezar como nos decía que hicieramos una lista dinámica decidimos probar a hacer la práctica con alguna clase de listas dinámicas previamente implementadas como la clase Vector o Stack pero nos dimos cuenta que asi no llegabamos a ningún lado y lo probamos haciendo una clase Nodo y una clase Lista, nos costó bastante hacer la clase Lista ya que tuvimos bastantes problemas para insertar las piezas y llamar de un nodo al siguiente, es decir,hacer un recorrido.

La clase Nodo es bastante sencilla, esta clase tiene 2 atributos uno es el Pizas pieza y otro es el Nodo siguiente, con su respectivo construtor y métodos de acceso pon() y dame(). Al principio de ésta clase debemos poner import Piezas.*; ya que vamos a usar la clase piezas implementada en la práctica anterior ya que los componentes que van en la clase Nodo son piezas.

La clase Lista es mas complicada; en ella debemos tener en cuenta que hay una pieza que va a ser la primera y que hay un recorrido, cada vez que insertamos una pieza el recorrido tiene que apuntar al siguinte y el primero tiene que quearse en la primera pieza insertada en la lista.

El código de la lista es el siguiente:

import Lista.*;

public class Lista{

    Nodo Primero;

    Nodo Recorrido;

    pubic Lista(){

        Primero=null;

        Recorrido=null;

    }

    public void insertar(Pieza p){

        Primero=new Nodo(p,Primero);

   }

   public void Recorrido(){

      Recorrido=primero;

   }

  public void insertaSiguiente(){

     Pieza p=null;

     if(Recorrido!=null){

         p=Recorrido.Elementos();

         Recorrido=Recorrido.Siguiente();

   }

   return p;

 }

 public piezaActual(){

    Pieza p=null;

    if(Recorrido!=null){

         p=Recorrido.primero();

   }

   return p;

}

 Ejercicio. 2:

Los iteradores pueden ser utilizados en cualquier colección de Java, en clase vimos el ejemplo en la clase Vector.

En éste caso los utilizamos para acceder a los elementos, es decir que usamos iteradores en vez de utilizar los métodos propios de la clase.

Para ello primero necesitamos los siguientes paquetes y clases:

impor java.util.Enumeration;

Luego tenemos que indicar que nuestra colección va a implementar los métodos del interador por lo que creamos un objeto de Enumeration.

Y ya podriamos usar métodos como:

  • hashMoreElements() : indica si hay más elementos.
  • nextElement() : devuelve el siguiente elemento.

 

 

Día 6.0

•Abril 20, 2008 • 1 comentario

Estamos aún tratando de solucionar lo que nos quedaba de la Practica 5, pero como ésta ya la tenemos hecha mejor publicarla ahora y no retrasarnos más.

Práctica 6

Ejercicio 1

En éste ejercicio queríamos comprender bien el funcionamiento de una Cola y ver cómo podiamos aplicarla al juego del Tetris, concretamente a cómo ir colocando y mostrando las piezas.

Lo primero que hicimos fue tratar la Clase Cola con chars en vez de con objetos, encolar distintos simbolos y desencolandolos uno a uno.

Para ello modificamos la Clase Cola para que fuera una cola de chars y creamos un método nuevo que vaya encolando simbolos aleatorios, con el método Math.random().

Código del nuevo método:

public void rellenar(){
 
 double num;
 
 for(int i=0; i<numElementos; i++){

    num = Math.random() * 10;

    if (num >= 7.5)
     simbolo = ‘#’;

    else if (num >= 5.0)
     simbolo = ‘+’;

    else if (num >= 2.5)
     simbolo = ‘o’;

    else simbolo = ‘*’;

    this.encolar(simbolo);
 }
 }

Añadíamos a la clase el atributo char simbolo;  y en el contructor lo inicializábamos:

simbolo= ‘ ‘;     

El resto de los métodos ( vacia(), llena(), encolar(char simbolo), desencolar()…)quedaban prácticamente igual, sólo teniendo en cuenta que ahora era una cola de chars.

Para probarlo hicimos la Clase PruebaCola  :

public class PruebaCola
{
 public static void main(String[]args)
 {
  int elementos = 20;
  char simbolo=’_';
  double num;
  char x;
  
  Cola c = new Cola(elementos);
 
  c.rellenar();
  
 
 try
  {
   
  for(int i=0; i<elementos; i++){
  
   System.out.print(” “+c.desencolar());
  
 }
  } 
  
  catch (Exception ex)
  {
   System.out.println(“Error al sacar un char de la cola”);   
  }
  

  /*
  for(int y=0;y<elementos;y++)
  {
   System.out.println(c.desencolar());   
   System.out.println(” “);
  }
  
   }

Con ello podiamos ver como  alamacenaba:

 >> +  *  #  +  +  o  o  o  #  o  *  #  o  o  *  *  o  o  o  o

y luego iba desencolando:

 >> +  *  #  +      [...]

 Ejercicio 2

 Una vez entendido el mecanismo de una clase Cola, en el segundo ejercicio se propone hacer una Cola de Objetos. objetos de la clase Pieza.

Nuestra clase Pieza contiene como atributos: el nombre de la Pieza, el simbolo que la representa y la posición.

Los métodos son: quienSoy(), que nos devuelve el nombre de la pieza, mover(), que asigna una nueva posición, y el método toString() que muestra toda la info del objeto.

Código:

public class Pieza{

String nombre;
char simbolo;
int posicion;

public Pieza (String nombre, char simbolo, int posicion){

this.nombre=nombre;
this.simbolo=simbolo;
this.posicion=posicion;

}

public String quienSoy(String nombre){
return nombre;
}

public void mover(int posicion){

this.posicion=posicion;
}

public String toString(){

String x=”Soy una “+nombre+” en la posicion “+posicion+” representado por “+simbolo;

return x;
}
}

Nuestra clase Cola tomará objetos de la clase Pieza. Es muy parecida a la anterior sólo que ahora en vez de chars es de tipo Pieza (por ejemplo el array, el método desencolar devuelve un objeto, etc).

Código:

class ColaPieza
{

  private int numPiezas;
  private Pieza piezas[];
  private int indice;
   
    ColaPieza(int numPiezas)
        {
                this.numPiezas = numPiezas;
                indice = -1;
                piezas = new Pieza [numPiezas];
  }
  public boolean vacia()
        {
                return (indice == -1);
        }
        public boolean llena()
        {
                return (indice == numPiezas-1);
        }
        public void encolar(Pieza p)
        {
                indice ++;
                piezas[indice] = p;
        }
        public Pieza desencolar() throws Exception
        {
                Pieza pieza = piezas[0];
                for (int i=0;i<indice;i++) piezas[i] = piezas[i+1];

                indice–;
                return pieza;
        }
        public int numPiezas()
        {
                return indice+1;
        }
        public void imprimir()
        {
   for (int i = 0; i <= indice; i++)
   
    System.out.print(“\n”+piezas[i]);
    System.out.println();
   
        }
  
 }

Por último para probarla hicimos la clase PruebaPieza dónde únicamente creamos tres objetos de la clase Pieza los almacenamos en la cola y luego imprimimos lo que va desencolando:

public class PruebaPieza{

public static void main(String[] args){

Pieza p1= new Pieza(“Pieza L”,’L',1);
Pieza p2= new Pieza(“Barra”,’-',2);
Pieza p3= new Pieza(“Cruz”,’+',3);

int elementos = 3;

ColaPieza c= new ColaPieza(elementos);

c.encolar(p1);
c.encolar(p2);
c.encolar(p3);

try
  {
   
  for(int i=0; i<elementos; i++){
  
   System.out.print(“\n “+c.desencolar());
  
 }
  } 
  
  catch (Exception ex)
  {
   System.out.println(“Error al sacar un char de la cola”);   
  }

}
}

Imprime así cada objeto de la cola por orden, pero lo muestra a través de método toString() que habíamos creado. El resultado es:

>>
 Soy una Pieza L en la posicion 1 representado por L
 Soy una Barra en la posicion 2 representado por -
 Soy una Cruz en la posicion 3 representado por +

Día 5.0

•Abril 4, 2008 • 5 comentarios

Práctica 5:

Hola, ya estamos aquí otra vez comentando las prácticas, que cada día comentamos menos por cierto, como se nota que son  más difíciles…

En esta práctica hemos avanzado muy poco porque no nos dió tiempo a comprenderlo todo.

 Lo más importante ,de  al menos los 2 primeros ejercicios, es tener claro el concepto de polimorfismo que se manifiesta de varias formas:

La primera es la sobrecarga que en castellano significa crear varios métodos con el mismo nombre pero distintos parámetros.

La segunda es la sobreescritura que es cuando creamos un método en la clase base e implementamos su cuerpo en las clases derivadas de distinta forma según nos interese. Como por ejemplo en la clase Figura (que hicimos en la clase teórica) que contenía el método Área.

Si nos es así que alguien nos lo diga en un mini comentario. :-)

También es importante saber qué es un método abstracto, es aquel que no tiene implementación.

Y por último qué es un interfaz:  es un “contrato de comportamiento”, esto quiere decir que podemos crear múltiples clases que sigan un comportamiento definido en la clase interface simplemente poniendo la palabra reservada implements en la cabecera de la clase.

Ej:  interface Almacenable{

         void guardar(); //Este método no se implementa.

      } //Esta seria la clase interfaz

     class Clase implements Almacenable{}

//y esto es lo que escribiríamos en la cabecera de la otra clase

 Ejercicio 1 Sobreescritura del método toString().

     Utilizando las clases del ejercicio anterior teníamos que modificar el método toString utilizando la palabra super (herencia):

     Un ejemplo de esta modificación es:

     public String toString () {    

           String x=”ATRIBUTO :” +super.toString()+ ” TIPO = “+tipo;   

         return x;

 

Después en la clase Clase había que analizar que pasaba si escribiamos:

  str += miembros[i].toString();

en el método toString.

Lo único que pasaba es que en el array miembros cada elemento puede ser de tipo atributo, método o constructor y según sea , llama al método toString de la clase del tipo al que pertenezca en dicha posición del array.

Luego teníamos que buscar la clase object en el Api de java, donde te dice que todas las clases heredan de la clase Object.

Ejercicio 2  La interfaz Almacenable.

 

Tenemos una interfaz con un método al que se le pasa como parámetro un objeto de tipo fichero y queremos que este método almacene la información de la clase de cualquier objeto en un fichero.

Para poder implementarlo tuvimos que buscar en el Api un método que perteneciera al paquete java io y a la clase FileWriter y que a su vez, guardara en un archivo la información que le llega a dicho método, en este caso el String de la clase Clase:

public void guarda(java.io.FileWriter out){   

         try{

                out.write (this.toString());

               }

         catch(Exception e){

                  System.out.println(“ERROR”);

          }

}

Ya no pudimos hacer nada más ya que se acabó la clase y al profesor no le dió tiempo a explicarnos el tercer ejercicio y demás.

DUDA: Si hay alguien que sepa hacer componenetes gráficos que nos heche una mano.

Hasta la próxima.

 

 

 

 

Día 4.0

•Marzo 18, 2008 • 3 comentarios

Práctica 4 (Herencia):

En esta práctica se utilizan las clases de la práctica anterior aprovechando que entre ellas hay atributos y métodos comúnes, por tanto se necesita Herencia.

Ejercicio 1:

Cuestión: ¿Qué pasaría si se cambiara protected por private en nuestra jerarquía de clases?

-Un atributo declarado como “private” necesita métodos de acceso para poder acceder a él, y además no podría ser utilizado en herencia, por tanto se utiliza “protected” que es un término medio entre “public” y “private“.

En éste ejercicio se pide implementar la clase Miembro que será la clase “padre” de la que heredan las demás. Ésta clase contiene los atributos comúnes a todas ellas (nombre y modificador-utilizaremos aqui la clase Modificador de la anterior práctica-) con el constructor y el método toString.

-clase Miembro.java:

import java.lang.reflect.Modifier;

public class Miembro{

 public String nombre=null;
 public int modificadores=0;

public Miembro(String nombre,int modificadores){

 this.nombre=nombre;
 this.modificadores=modificadores;
}
public String toString() {
  return “Nombre: ” +nombre+” Modificador de acceso: “+  Modifier.toString( modificadores );
    }

También hicimos el “main” para probar la clase:

public static void main( String args[] ) {
  
    int modificador = Integer.parseInt(args[1]);
 String nombre=args[0];
 Miembro m=new Miembro(nombre,modificador);

    System.out.println(m.toString());
}
}

para ejecutarla introducimos dos argumentos, el primero se adjudica al nombre y el segundo (debera ser un número) al modificador, es decir si escribimos:

>java Miembro Nombre 5

el resultado será:

Nombre: Nombre Modificador de acceso: public protected  

Ejercicio 2:

Se pide hacer la clase Atributo que hereda de Miembro.

Cuestión:¿Cual es la palabra reservada de Java que se usa para hacer referencia a la clase base desde una clase derivada?

La palabra es “extends”

“public class Atributo extends Miembro”

-clase Atributo.java:

public class Atributo extends Miembro{

 public String tipo=null;
 
public Atributo(String nombre,int modificadores, String tipo){

 super(nombre,modificadores);
 this.tipo=tipo;
}
public  String toString () {
        String x=”ATRIBUTO :” +super.toString()+ ” TIPO = “+tipo;
  return x;

}
public static void main(String[]args){
   String n = args[0];
   String t = args[1];
   int m = Integer.parseInt(args[2]);
   Atributo a = new Atributo(n,m,t);
   System.out.println(a.toString());
}

}

También hicimos el main, ésta vez le pasamos tres argumentos en el orden: nombre, tipo y modificador.

Ejercicio 3:

Este ejercicio contiene la subclase Metodo que hereda de Miembro, y una clase ya hecha llamada Parametro que contiene el tipo de los parámetros que tendrá la clase método. Para ello se crea un array de parámetros.

El método toString es muy parecido al de la clase Clase de la anterior práctica ya que tenemos que ir llamando al método toString de cada uno de los elementos de un array (en este caso del array parametros).

-clase Metodo.java:

public class Metodo extends Miembro{

 public String retorno= null;
 Parametro[] parametros = null;
 
public Metodo(String nombre,int modificadores, String retorno, Parametro[] parametros){

 super(nombre,modificadores);
 this.retorno=retorno;
 this.parametros=parametros;
}
public  String toString () {
       String x=” “;
   
    x= x +”METODO”+ super.toString()+” TIPO DE RETORNO: “+retorno;
   
    for(int i=0; i<parametros.length; i++){
    x= x+”PARAMETRO (“+i+”)”+parametros[i].toString ();
    }
   
 return x;
}

}

 Ejercicio 4:

Según el enunciado la clase Constructor debe heredar de la clase Metodo, pero dado que un constructor no es un tipo de método y que además no tiene tipo de retorno (por eso se diferencian) el profesor nos dijo que lo pusieramos que herede de la clase Miembro directamente.

Esta clase queda por tanto muy parecida a la clase Metodo ya que también hace uso de la clase Parametro.

-clase Contructor.java:

import java.lang.reflect.*;


public class Constructor extends Miembro {
   
  Parametro[] parametros = null;
   
     public Constructor(String nombre, int modificadores, Parametro[] parametros ) {
   super(nombre, modificadores);
  this.parametros= parametros;
    }
   
 
    public String toString() {
 
 String x=” “;
 
 x= “CONSTRUCTOR : “+ super.toString();
 
    for(int i=0; i<parametros.length; i++){
    x= x+”PARAMETRO (“+i+”)”+parametros[i].toString ();
    }
   
 return x;
    }
   
}

Día 3.0

•Marzo 15, 2008 • 1 comentario

Práctica 3:

Hola a todos hemos tardado un poquito en poner esta práctica porque nos hemos quedado bastante atascadas en el ejercicio 4, porque no entendemos muy bien que es lo que tenemos que hacer exactamente y después de haber estado rayandonos y rayandonos nos hemos dado por vencidas, asi que si alguien nos puede ayudar le estariamos muy agradecidas.Bueno despues de esta confesión aqui os dejamos lo que hemos hecho:

Ejercicio 0: 

A la hora de contestar las preguntas no tuvimos ningún problema ya que bajo nuestro punto de vista eran bastante fáciles.

A continuación nos pedían la clase PruebaObjeto que era practicamente igual que la del examen de RDA:

        

      public classPruebaObjeto{             

    public static void main (String[]args){


                 Punto p1=newPunto(1.2,3.5);
                 Punto p2=newPunto(6.9,9.2);
                 System.out.println(p1.toString());
                 System.out.println(p1.getX()+”,”+p1.getY());
                 System.out.println(p1.distanciaAlOrigen());
                 System.out.println(p1.calcularDistancia(p2));
                 System.out.println(Punto.contador);
                 }
} Ejercicio 1:

En este ejercicio nos pedían hacer la clase pruebaModificador:


public class pruebaModificador{
                 public static void main( String args[] ) {
 
                          int modificador = Integer.parseInt(args[0]);                         
                          System.out.println(” El modificador de acceso de ” + modificador +” es “+
                          Modificador.toString(modificador) );                    
                       }
}

Una vez hecha teníamos que decir que creíamos que debería pasar si se mete un número mayor que las combinaciones posibles que se pueden hacer con los modificadores.Lo que ocurre es que sale una excepción del tipo FormatNumerExcepcion cuando introducimos en la consola un numero mayor o igual que 2^12( es decir 4096) ya que el numero máximo que puede tomar un numero entero es ese y sino se saldría de los límites establecidos.

Ejercicio 2:

En este ejercicio teníamos que crear la clase Atributo:

import java.lang.reflect.*;

public class Atributo {     
      public String nombre=null;
      public String tipo=null;
      public int modificadores=0;      
      public Atributo(String nombre, String tipo, int modificadores ) {
              this.nombre= nombre;
             
this.tipo=tipo;
              this.modificadores= modificadores;
        }

       public String toString () {
              String x=”ATRIBUTO : NOMBRE= “+nombre+” TIPO = “+tipo+” MODIFICADOR ACCESO = “+       Modificador.toString(modificadores);
             return x;
           }

//PUSIMOS EL MAIN PARA COMPROBAR SI ESTA CLASE HACIA LO QUE NOS PEDÍAN

      public static void main(String[]args){
           String n = args[0];
           String t = args[1];
           int m = Integer.parseInt(args[2]);
          Atributo a = new Atributo(n,t,m);
          System.out.println(a.toString());
       }
}

DUDA:en este ejercicio nos surgio una duda y es que no acabamos de entender por qué se puede llamar a la clase modificador directamente.
 

Ejercicio 3:

Aquí había que hacer la clase Metodo y Constructor:

Clase constructor:







import java.lang.reflect.*;
public class Constructor {   
      public String nombre = null;
      public int
modificadores;  
      public Constructor(String nombre, int modificadores) {        
         this.nombre=nombre;
         this
.modificadores=modificadores;  
   }     
    public String toString() {
         return “CONSTRUCTOR : NOMBRE= “+nombre+” MODIFICADOR ACCESO = “
+  Modificador.toString(modificadores);
    }
    Clase método






public class Metodo {     
      public String nombre = null;
      public int
modificadores;
      public String tipoRetorno = null
;     
      public Metodo(String nombre, int modificadores, String tipoRetorno) {
          this
.nombre=nombre;
          this
.modificadores=modificadores;
          this
.tipoRetorno=tipoRetorno;     
      } 
    
 public String toString() {      
       return “METODO : NOMBRE= “+nombre+” MODIFICADOR ACCESO = “+ Modificador.toString(modificadores)+” TIPO DE RETORNO = “+tipoRetorno;
  }
public static void main(String[]args){       
       String n = args[0];
       int
m = Integer.parseInt(args[1]);
       String r=args[2];
       Metodo s =
new
Metodo(n,m,r);
       System.out.println(s.toString());
   }
}

El metódo main lo pusimos para comprobar que el programa hacía lo que nos pedían.

Ejercicio 4:

clase “Clase.java”:

(parte a implementar)

   public Atributo[] getAtributos() {
        
        return atributos;
    }

    public Constructor[] getConstructores() {
         
        return constructores;
    }

    public Metodo[] getMetodos() {
         
        return metodos;
    }
   
    public String toString() {
 
 String x= “CLASE”+ nombre;
 
 for (int i=0; i<atributos.length; i++){
 
 x= x + atributos[i].toString();
 }
for (int j=0; j<metodos.length; j++){
 
 x= x + metodos[j].toString();
 }
 
for (int k=0; k<constructores.length; k++){
 
 x= x + constructores[k].toString();
 }
 
       
        return x;
  
    }

Día 2.1

•Marzo 11, 2008 • 1 comentario

Ahorcado

Publicamos ya nuestra solución, pero antes os mostramos las condiciones de nuestro juego:

-La palabra secreta no se la pasamos desde un fichero (ya que no sabemos hacerlo) asi que la pasamos directamente por teclado.

-No hemos utilizado excepciones

-Nuestro Problema: al ejecutar el juego vamos pidiendo las letras, se cuentan el numero de aciertos y fallos. El programa acaba cuando el numero de aciertos es igual al número de letras que tiene la palabra secreta, pero también debería acabar cuando el número de fallos es 6 y esto último no nos sale, aunque parece sencillo. También si la palabra secreta es “casa”, por ejemplo, no nos cuenta la segunda “a” como otra letra.

Os ponemos el codigo y haber si nos podriais decir qué cambiar, dode estan estos fallos, qué nos falta…

Clase Ahorcado:

public class Ahorcado{

String palabra;
char [] pal;
char letra;
int fallos=0;
int f=0;
int aciertos=0;

//Método que devuelve el número de letras que tiene la palabra

public int dameNumero(String palabra){

int e=palabra.length();

return e;

}

//Método que comprueba la letra introducida por teclado con cada una de las letras que forman la palabra

public void compruebaLetra(char letra, char[] pal){
for(int i =0;i<pal.length;i++){

    if(pal[i]==letra){
 int posicion=i+1;
 
 System.out.println(“Se encuentra en la posicion “+posicion);
 aciertos++;
 break;
      }else {
   
      f++;
      }
 
}
if(f>0 && f>=pal.length) {  System.out.println(“Fallastes”); fallos++; f=0;}

}

//Método que devuelve el número de fallos

public int fallos(){
return fallos;
}

//Método que devuelve el número de aciertos

public int aciertos(){
return aciertos;
}

}

clase Prueba:

import java.io.*;

public class Prueba{

public static void main (String args[]) throws IOException{

InputStreamReader conversor;
BufferedReader teclado;
String linea;
String palabra;
char letra;

int aciertos=0;
boolean correcto= true;
int x;
int y;

char [] pal;

conversor= new InputStreamReader (System.in);
teclado= new BufferedReader (conversor);
Ahorcado a=new Ahorcado();

System.out.println(“Introduzca la palabra”);

palabra=teclado.readLine();
pal= new char[palabra.length()];

for(int j=0; j<pal.length; j++){

pal[j]= palabra.charAt(j);

}

System.out.println(“\n\nEl numero de letras es “+ a.dameNumero(palabra));
do{

System.out.println(“\nIntroduzca la letra “);
linea= teclado.readLine();
letra= linea.charAt(0);

a.compruebaLetra(letra,pal);

x=a.aciertos();
y=a.fallos();

System.out.println(“\n Numero de aciertos: “+x);
System.out.println(“\n Numero de fallos: “+y);

if(y==6){ correcto=false; System.out.println(“GAME OVER”);}
}
while(correcto==true || x!=palabra.length());

System.out.println(“\n\nLa palabra correcta era:”+palabra);

}
}

Cris y Esther