Día 12, práctica doce.

       Aqui volvemos a nuestra cita con el blog. Vale, si, ha estado descuidado cosa de 15 días pero esperamo que entendais queridos amigos que hemos estado bastante atareados como suponemos que lo hayais estado vosotros.

       Después de esta pequeña disculpa pasamos a exponeros la práctica 12 y pese a lo que a lo mejor queriais lo vamos a hacer un poco “por encima”. Más detalles tendreis en otras asignaturas posteriores por lo que os explicaremos cosas básicas y para el que quiera hacer algo más avanzado ya sabeis, paciencia, no hay otra ciencia.

       Para la creación de reproductores es necesario la utilización de la denominada JMF(Java Media Framework). En nuestro caso queremos crear un reproductor en una ventana y que tenga alguna opción de control. Podemos utilizar 4 clases: Final, Reproductor, Interfaz y Reloj.

      - La clase Final será la que inicialice todo y solamente contendrá el main().

      - La clase Reloj implementa aspectos correspondientes al tiempo de la reproducción y su visualizacion.

      - La clase Interfaz será la que cree la ventana y todos sus componentes: JMenuBar, JMenu, JScrollBar, JLabel y JButton.La apariencia de la interfaz es esta:

       Además esta clase es la que gestiona los eventos generados por los comandos de la interfaz.

       – La clase Reproductor que sera la que contenga los métodos de respuesta a los eventos antes citados y a los eventos generados por el player. Como métodos descripitivos citaremos:

• inicializar(URL url)

   try{
   mdPlayer = Manager.createPlayer(u); //Manager es clase “factoria” para el resto
   mdPlayer.addControllerListener((ControllerListener) this);
   mdPlayer.realize(); //pasa el player a estado realizado
   }catch(IOException e){}
   catch(NoPlayerException e){}

Otro día más y otro menos, para que llegue el examen, hoy toca revisar nuestros conocimientos acerca de los eventos….primero el profe hace una introducción acerca de que son y para que sirven.

Pues bien, un evento sirve para realizar acciones mediante, teclado, ratón

Ejercicio 1:

Nos piden que hagamos un programa que tenga un botón que cada vez que se pulse imprima un texto por la salida estándar.

public class Simple00GUI extends JFrame implements ActionListener{
   
       public Simple00GUI(){
        
         JFrame frame = new JFrame(“Evento Botón”);
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         JButton b= new JButton(“Boton”);
         //botón escuchador
         b.addActionListener(this);
         frame.getContentPane().add(b,BorderLayout.CENTER);
         frame.pack();
         frame.setVisible(true);
      }
     
      public void actionPerformed(ActionEvent evento){
         System.out.println(“Boton pulsado”);
      }
     
      public static void main (String args[]){
         Simple00GUI s= new Simple00GUI();
      }
   }

Ejercicio 2:

class SimpleGui01 extends JFrame implements ActionListener{
  
      JLabel etiqueta;
     
       public SimpleGui01(){
     
         JFrame frame = new JFrame(“Simle 01″);
        
         etiqueta=new JLabel(“Etiqueta”);
         etiqueta.setOpaque(true);
         etiqueta.setBackground(Color.MAGENTA);
         JButton boton=new JButton(“Púlsame”);
         boton.addActionListener(this);
         JPanel panel=new JPanel();
         panel.setLayout(new GridLayout(2,1));
         panel.add(boton);
         panel.add(etiqueta);
         frame.getContentPane().add(panel);
         frame.setVisible(true);
         frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
         frame.pack();
      }
  
       public void actionPerformed(ActionEvent e){
         if(etiqueta.getBackground().equals(Color.MAGENTA)){
            etiqueta.setBackground(Color.CYAN);
         }
         else{
            etiqueta.setBackground(Color.MAGENTA);
         }
      }
       public static void main(String args[]){
     
         SimpleGui01 gui=new SimpleGui01();
     
      }

Ejercicio 3.

Este nos llevo un poco más de tiempo, pues nosotros queríamos hacer con eventos, lo de de leer por pantalla, pero el profesor nos sugirió este camino, pues era más sencillo. Así pues el resultado fue:

   import java.awt.*;
   import java.awt.event.*;
   import javax.swing.*;
   import java.io.*;
 
    class SimpleGui02 extends JFrame implements ActionListener{
  
      JLabel label;
       public SimpleGui02(){
         super(“simple”);
         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
           
         JPanel panel=new JPanel();
         panel.setLayout(new GridLayout(2,1));
        
         label= new JLabel(“Etiqueta”);
         label.setOpaque(true);
         label.setBackground(Color.PINK);
        
         JButton boton=new JButton(“Púlsame”);
         boton.addActionListener(this);
        
         panel.add(boton);
         panel.add(label);
         this.getContentPane().add(panel);
         this.setVisible(true);
         this.pack();
      }
       public void actionPerformed(ActionEvent e){
    
         cambiaColor();
      } 
       public void cambiaColor(){
     
         if(label.getBackground().equals(Color.PINK)){
            label.setBackground(Color.red);
            System.out.println(Thread.currentThread().getName() +
                     “: <enter> detected… cambio de color”);    
         }
        else{
            label.setBackground(Color.PINK);
         }
     }
     
       public static void main(String args[])throws IOException{
     
         SimpleGui02 gui=new SimpleGui02();
        
         InputStreamReader input = new InputStreamReader(System.in);
         int c;
         try {
            while( (c=input.read())!= -1) {
               if (c == ‘\n’) {
                  System.out.println(Thread.currentThread().getName()+
                     “: <enter> detected… “);
               }
            }
         }
             catch (IOException e) {
               System.err.println(e);
               System.exit(1);
            }
      }
  
   }

Ejercicio 4.

Nos piden que hagamos un programa parecido al primero, pero que cuando se pulse cambia de color el botón y lo que nosotros hemos hecho es:

   import java.awt.*;
   import java.awt.event.*;
   import javax.swing.*;
    public class Simple03GUI extends JFrame implements ActionListener{
  
      JButton boton;
   
       public Simple03GUI(){
         super(“Simple03Gui”);
         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        
         boton = new JButton(“Pulsame”);
         boton.setOpaque(true);
         boton.addActionListener(this);
         this.getContentPane().add(boton,BorderLayout.CENTER);;
         this.setVisible(true);
        this.pack();
      }
     
       public void actionPerformed(ActionEvent e){
         if(boton.getBackground().equals(Color.PINK)){
            boton.setBackground(Color.CYAN);
            System.out.println(Thread.currentThread().getName() +
                     “:cambio de color”);
         }
         else{
            boton.setBackground(Color.PINK);
         }
      }
       public static void main( String args []){
       
         Simple03GUI s= new Simple03GUI();
      }
   }

Hasta el momento es todo lo que hemos hecho pero, aun así nos hemos puesto manos a la obra con los siguientes apartados, a lo largo de la semana modificaremos este post.

Un saludo.

Comienza otro día más y ya queda menos, hoy toca una de hilos, y os preguntaréis, pero si esto no entraba no? pues bueno eso decían, pero como dice mi abuela no te creas ni la mitad de lo que te digan, que luego llegan los palos. Asi toca revisar los apuntes, porque en clase no hemos visto nada y echarle valor. Bueno también nos ayuda un poco el profe de prácticas, que la verdad se esfuerza bastante en que entendamos algo tan complicado en tan poquito tiempo.

Ejercicio1.

Más de lo de siempre te ponen, un programilla te dicen que lo inspecciones, que lo ejecutes y compiles a ver lo que hace. Pues bien la clase Ding! lo que hace es mostrar por pantalla (“DING”) cada vez que pulses la tecla de intro, para la realización de este programa tienes que importar java.io.IOException ya que estas leyendo por teclado, el segundo apartado es un programa que muestra por pantalla también (“DONG”) pero esta vez através de un Thread. El apartado 3 digamos que es la suma de los dos anteriores, pero al ejecutarlo nos damos cuenta que el programa no funciona bien, y esto segun comento el profesor puede ser que un mismo proceso no puede estar a dos cosas a la vez, vamos parecido a un chico que si esta viendo la tele no puede estar hablando con la novia, porque no se entera ni de una cosa ni de otra….es broma no os cabreis chicos…pero es que el simil era bueno para entender esto.

Ejercicio 2

Ahora nos metemos un poco más el asunto, y ya hablamos de hilos.Primero diremos que es un Thread, para aquellos que no lo sepaís, o dudeis en su significado:

-Thread, es un flujo simple de ejecución dentro de un programa. Hasta el momento, todos los programas creados contenian un único Thread, pero un programa (o proceso) puede iniciar la ejecución de varios de ellos. En los Threads lanzados desde un mismo programa, la memoria se comparte, utilizando el mismo contexto y recursos asigandos al programa. Un Thread no puede existir independientemente de un programa, sino que se ejecuta dentro de un programa o proceso.

Ahora mostramos lo que a nuestro parecer hace la clase TwoThreads:

Class TwoThreads {

public static void PrintThreadName() {
//Dame el nombre del thread que se está ejecutando
System.out.println(Thread.currentThread().getName());
}
//Se crea un objeto de la clase Runnable y se implementa su método run()
public static void main(String args[]) {
Runnable r =
new Runnable() {
public void run() {
PrintThreadName();
}
};
//Creamos un Thread donde se le pasa como parametro el obtejo de la clase Runnable
Thread t = new Thread(r);
//LLamamos al metodos star()

t.start();

PrintThreadName();
}
}

Bueno vamos a explicar algunas cosas en detalle:

-start(), es un método de la clase Thread, que sireve para iniciar la ejecución. La llamada al método start() asigna los recursos necesarios al objeto.

-run(), este método es llamado por el start(). Es el corazón de cualquier Thread y donde tiene ludar la acción del Thread

Una vez se inicia la ejecución del Thread, el tiempo de la CPU se reparte entre todos los procesos y Threads del sistema. con lo cuál, se intercambian instrucciones del método main() con intrucciones del método run() entre otras.

 En el apartado dos, nos piden que veamos la diferencia entre el programa, TwoThreads y TwoThreadsSimple, en este segundo lo que hace es implementar el interface Runnable, y redefinir el método run() de esta interfaz, luego tan solo creariamos un Thread pasandole como parametro la propia clase , para que llamase a start().

TwoThreadsSimple tts = new TwoThreadsSimple();
Thread t = new Thread(tts);
t.start();

En el apartado tres lo que hace es extender de la clase Threads, así no tiene que crear un objeto y puede invocar el método star() desde el propio objeto de la clase

TwoThreadsSimple2 tts2 =new TwoThreadsSimple2();
tts2.start(); 

 Ejercicio 3.

En este ejercicio, al ver el código que nos dan, pensamos que al ejecuatarse saldrían primero una tira de ceros  y luego  los unos, pero estabamos equivocados, ya que cuando utilizamos hilos, no sabemos el orden de ejecución como tampoco sabemos cuanto tiempo le va a dedicar a ese proceso, y esto lo que le sucede a este proceso.

La solución que nos dan en el siguiente apartado, emplea vectores, y por lo que hemos visto, lo que hace es meter en un vector las ordenes que le queremos dar y así sacarlas en el orden que queramos. No estamos muy seguros de esto, pero creemos que es así, de todas formas si nos equivocamos nos gustaria que los profes nos lo digeran, para no tener está idea equivocada.

Ejercicio 4

En el primer apartado nos dicen que hagamos un programa que que imprima por pantalla “WHITE”, 2 segundos después “BLACK”, 2 segundos después “WHITE” y así sucesivamente. Nosotros hemos hecho lo siguiente:

  import java.io.IOException;

public class StroboscopicText {
    String s;
public StroboscopicText(){
  cambiar();
}
public void rotar(String s){
   if(s.equals(“WHITE”)){
     s=“BLACK”;
     System.out.println(s);
   }
}
public void cambiar(){
   try {
     while(true) {
        Thread.sleep(2000);
        s=“WHITE”;
        rotar(s);
        System.out.println(s);
     }
   }
   catch (InterruptedException e) {
      System.out.println(“Interrupted while sleeping”);
}}

  Los siguientes apartados ya nos los llegamos hacer, pero si sacamos un rato, no dudeís que lo haremos y colgaremos aquí nuestros resultados.

Día nueve, novena práctica.

Hoy comenzamos un nuevo día, con una práctica totalmente distinta a las vistas ahora, además con un imprevisto más, cambio de profesor… aunque la verdad, no hemos notado la diferencia porque ambos profesores llevan una dinamica de clase bastante parecida y se les entiende bastante bien a los dos.

Al comienzo de la clase, el profesor nuevo, que la verdad no me acuerdo como se llamaba, nos ha explicado en que consistía la práctica y para que servía lo que ibamos a implentar hoy. Luego nos ha dejado un tiempo y hemos ido comentado los distintos ejercicios.

Bueno vamos al lio, que sino nos enrollamos como persianas.

Ejercicio 1

Nos mandan copiar, unas lineas de código de las cuales nos van hacer unas preguntillas.

Apartado2. Nos saltamos el uno porque, es ejecutar y compilar el programilla y si a éstas alturas alguien no sabe hacer eso, mal va… En éste apartado nos piden que enumeremos los nombres de los objetos que se crean, pues bien, vamos haya:

-objeto frame de la clase JFrame

-objeto contentPane de la clase JPanel

-objeto label de la clase JLabel

Apartado3.Métodos. Los métodos a los que se llama en estas linea de codigo son:

-setDefaultOperation — éste método pertenece a la clase javax.swing.JFrame; y sirve para tratar operaciones de ventana. Se define como:

public void setDefaultOperation(int Operation), como operaciones podemos meter las siguientes:

DO_NOTHING_ON_CLOSE

HIDE_ON_CLOSE

DISPOSE_ON_CLOSE

EXIT_ON_CLOSE

Cada una de ellas realiza una acción diferente con la ventana

-setSize()— éste método pertenece a la clase java.awt.Component y se utiliza para redimensionar el tamañode  los distintos componentes, su definición es:

public void setSize(int width, int heigth)

-getContentPane()—método por defecto de la clase javax.swing.JFrame, éste método se utiliza para añadir el Panel que existe ,por definición, ya en la clase JFrame, su código es:

public Container getContentPane()

-add()— método de la clase java.awt.Container, al igual que el anterior sirve para añadir los componentes que se les pasa como parámetros, con la diferencia que éste es el génerico y el otro solo lo puede utilizar esa clase en concreto, su código es:

public Component add(Component comp)

-setVisible()—método perteneciente a la clase java.awt.Component , este se útiliza para que el elemento en cuestión pueda ser visible o no dependiendo de su booleano

public void setVisible(boolean b)

Por último comentamos que también exiten los métodos constructores JLabel( String srt) y JPanel(String srt) de las clases JLabel y JPanel respectivamente, aunque no entramos en detalle.

Apartado4. Aquí se nos pide, que comentemos el código dado, lo que vamos hacer es ponerlo e ir comentando cada linea

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;

class HelloWorldGUI {
public static void main(String args[]) {
      
/**Se crea un objeto de la clase JFrame*/
JFrame frame = new JFrame(“HelloWorldGUI window title”);
/** al objeto creado le asigna la acción de poder cerrarse si pulsamos su aspa*/ 
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
/**Se crea un objeto de la clase JPanel al cual añadimos el frame que hemos creado*/
JPanel contentPane = (JPanel) frame.getContentPane();
/**Se crea un objeto de la clase Jlabel*/
JLabel label = new JLabel(“Hello World!”);
/**añadimos la etiqueta*/
contentPane.add(label);
/**redimensionamos el tamaño de la ventana*/
frame.setSize(100,50);
/**le damos las orden de que este componente sea visible*/
frame.setVisible(true);
}
}
 

 Apartado5. Nos pide que hagamos un nuevo programa en el que el tamaño de la ventana sea 4 veces mayor, para ello cambiamos los parámatros del método setSize() quedando:

frame.setSize(400,200); 

Apartado6.Crear un programa que cambie la etiqueta de color.En éste tuvimos algunos problemas, pues no nos mostraba lo que deseabamos.  Hasta que dimos con la solución.Las lineas de código que añadimos al programa fueron:

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

La primera sirve para cambiar el color a la etiqueta, y la segunda es para que muestre la etiqueta con el color indicado, ya que por defecto este método de la clase javax.swing.JComponent esta a false y muestra la etiqueta transparente, pero en las subclases como la que nosotros implementamos suelen ser true , esto fue lo que más nos costo hasta el momento, pues no sabiamos que existia este método.

Apartado7,8,9.Metemos el siguiente código a nuestro programa HelloWorldGUI :

try {
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            System.err.println(“Unexpected interruption while sleeping:”);
            System.err.println(e);
            System.exit(1);
        }

Al compilar y ejecutar nos damos cuenta de que éstas líneas sirven para que el programa duerma durante el tiempo que indica el método

  Thread.sleep(10*1000);

Tras ese tiempo, se visualiza la ventana, realmente el código para éste caso no tiene mucha importancia, pero es cierto que en muchas aplicaciones es muy utilizado y puede ser muy útil.

Apartado10. Si añadimos al programa anterior la siguiente línea:

System.exit(0);

lo que ocurre es que inmediatamente después de que se visualice la ventana, se cierra en el acto.

Ejercicio2

Apartado1.Buscamos en el API los métodos que nos pedían.

-setVisible(boolean b). Sirve para mostrar u ocultar la ventana

-setLocation(int x, int  y).Sirve para mover la ventana en la posición que nosotros queramos, teniedo en cuenta que la posicíon normal que es a la izq  arriba. Sabiendo esto podremos dar coordenadas para ubicar la ventana donde deseemos

-setUndecorated(boolean b). Éste método desactiva o permite decorar el cuadro, pero solo se puede usar si el cuadro se muestra.

-setExtendedEstate(int state). Se utiliza para maximizar o minimizar ventanas.Las posibles opciones son:

·        NORMAL: sin estado especial

·        ICONIFIED: minimizar la ventana

·        MAXIMIZED_HORIZ: la ventana ocupa el máximo lugar horizontalmente

·        MAXIMIZED_VERT: la ventana ocupa el máximo lugar verticalmente

·        MAXIMIZED_BOTH: la ventana ocupa el máximo lugar hacia todos lados

-setDefaultLookAndFeelDecorated(boolean b).Esto lo que haces es activar el Look&Feel, y logramos que nuestra ventana se vea bonita y además que se muestre igual en cualquier sistema operativo.

-setDefaultCloseOperation(int operation). Ya lo hemos explicado anteriormente

Apartado2.Hacemos el siguiente programa y para terminar el proceso tendriamos que presionar las teclas CTRL+C , ya que le hemos dicho que no se cierre al presionar el aspa.

class HelloWorldGUIDeaf {
public static void main(String args[]) {
      
JFrame frame;
JPanel contentPane;
JLabel label;  
frame = new JFrame(“HelloWorldGUIDeaf”);
frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
     
contentPane = (JPanel) frame.getContentPane();
label = new JLabel(“Hello World!”);
contentPane.add(label);     
frame.pack();
frame.setVisible(true);
}
}

  Como podemos ver este método solo es efectivo si antes no ha sido decorada esta ventana, pues si no este no haría caso a ésta línea de ejecución.

 Apartado4.En el apartado nos piden que hagamos un programa que utilice el LOOK&FEEL, por eso utilizamos el método de setDefaultLookAndFeelDecorated con la condición a true.  

Para los cambios en la etiqueta usamos este código:

  label.setBackground(Color.BLACK); — > Cambia el color a la etiqueta
  label.setOpaque(true); — > Hace opaca la etiqueta
  label.setForeground(Color.WHITE); — >Cambia el color de la letra de la etiqueta

Para los cambios en la ventana hemos usado:                      

frame.setExtendedState(frame.MAXIMIZED_BOTH);

Pero como alternativa a el podemos usar también los siguientes:                   

frame.setSize(frame.MAXIMIZED_HORIZ, frame.MAXIMIZED_VERT);

frame.setSize(frame.getExtendedState(),frame.getExtendedState()); 

Apartado2. Modificamos la clase anterior a  partir de  la clase Container y su método

        Public void add(Component comp, Object contraints)

 Donde Object contraints, expresa la disposición del componente, en nuestro caso la etiqueta.

Apartado3. El alineamiento por defecto de una etiqueta, es:

        Alineamiento X por defecto=> Left_alignment

        Alineamiento Y por defecto=> Center_alignment

Apartado4. Para poder alinear una etiqueta en el centro usamos los siguientes métodos de la clase JLabel:

label.setVerticalAlignment(JLabel.CENTER);

label.setHorizontalAlignment(JLabel.CENTER);

 El primero establece la alineación del contenido de la etiqueta a lo largo del eje y, y el segundo a lo largo del eje X. 

Apartado5. Volvemos a modificar el programa para añadir una imagen en el centro, es muy similar a añadir etiquetas lo único que cambia que tienes que crear un Objeto imagen, inicializarlos y luego añadirselo a la etiqueta, para luego hacer lo mismo de siempre los pasos son:

 ImageIcon arrow;

arrow= new ImageIcon(“./arrow.JPG”);
label = new JLabel(arrow);
label.setOpaque(true);
label.setBackground(Color.WHITE);
label.setForeground(Color.BLACK);
label.setVerticalAlignment(JLabel.CENTER);
label.setHorizontalAlignment(JLabel.CENTER);
contentPane.add(label, BorderLayout.CENTER);

tener cuidado e importar en la clase el paquete javasx.swing.ImageIcon sino os dará error.

Apartado6. Con el método pack() aseguramos que la ventana se adecue al tamaño de los elementos.

Ejercicio4

Apartado1. Este ejercicio lo hemos hecho con un GridLayaout de  20×1, también hemos hecho un método para ver si es par o impar el cuál lo utilizamos para crear las etiquetas de una manera u otra con una estructura de if-else.

Apartado2. Si pudiera abrirlo lo haría pero como no, aquí hemos acabado

Bueno chic@s espero que os sirva de algo toda esta retaila de cosas, porque ojo lo que cuesta hacer está práctica yo no se que pretenden, si matarnos hacer OCA o que pero se tienen que dar cuenta que no es la única asignatura y que prácticas como ésta no se hacen en un ratito, lleva bastante tiempo y no esta muy bien explicada. Bueno nos vemos dentro de dos semanas.

Saludos Carlos y Lidia.

Comenzamos la clase, con una explicación de Alberto sobre recursividad, y tablas hash, por si alguno no ha ido a clase o simplemente no se entero ni del nodo. Para estos últimos, hacemos una breve explicación:

-Tablas hash: se tratan de estrucuturas de alamacenamiento, de las que puedes sustraer a partir de sus métodos información,como son sus objetos almacenados…son muy eficientes para búsquedas en base de datos, pero no combiene utilizarla en espacios reducidos de memoria, ya que consume muchos recursos.

-Recursividad: un método es recursivo si en el propio método, hace un llamamiento así mismo, con una condición de parada para que éste no sea infinito.

Ejercicio1.

Este ejercicio nos pide hacer a través de la tabla hash, una lista de trucos de videojuego. Creamos un objeto de tablas hash, ya que hoy nos piden que usemos las que nos proporciona el API, en el contructor inicializamos el objeto y hacemos referencia a un método que inicializa los trucos. Para probar que funcionaba creamos un método que devolvia la definición del truco, pasandole como parámetros el nombre del truco que se pide por linea de comandos.Con esto términamos el ejercicio 1.

Ejercicio2.

Se trata de estudiar el comportamiento del código que nos adjuntan, y responder a unas preguntillas bastante faciles.

-Pregunta1. Es tan solo del código de un factorial, que se puede ver más explicado en los apuntes de  teoría.

-Pregunta2. Este método para los que no lo sepan es una cuenta atrás, por cierto ya empieza la cuenta atrás para nuestro examen de oca….quedan “62 días” :-O

-Pregunta3. Es díficil de explicar con palabras, nosotros pensamos que suma al número b, el número a hasta que éste disminuye hasta 0, en ese momento se muestra por pantalla el valor final de b.

Nos quedamos aquí proximamente lo añadiremos. Además haremos alguna referencia a nuestro juego “Cutetris” y cuando digo cu, no es de cutre sino de cubos….

Un saludo Lidia y Carlos.

Esta en construcción.

Como ya viene siendo costumbre, tardamos unos días en publicar nuestras soluciones o dudas en el blog, espero que los profes no se cabreen y que tengan en cuenta el lio que tenemos con todas las asignaturas.

Pues bien en esta práctica, nos piden a partir de lo visto en teoría, sobre pilas y colas que hagamos un proyecto de tetris, y decimos proyecto porque la verdad con la ayuda que nos proporciona el enunciado de la práctica no podemos hacer mucho (asi que queridos profes sería muy bueno que miraseis estas prácticas y nos ayudaseis más), que al fin y al cabo son prácticas y son para aprender y con lo escueto que es el enunciado no podemos sacar lo que nos piden, como yo hay mucha gente…asi que si leis este post, espero q cambieís esto.

Bueno metiendonos al lio, segun lo que nos explico Alberto, teniamos que modelar una clase pieza de la cual heredarían las distintas piezas del tetris, eso parece fácil… pues solo tenemos que modelar el esqueleto de la pieza y luego en cada clase hija modelar el comportamiento de estás. Lo segundo era hacer la clase cola (queue) para almacenar nuestras piezas, fue sencillo, pues con ayuda de los apuntes de clase era cambiar solo algunas cosas,Mi duda es, yo intente poner excepciones en la clase cola, en lo métodos encolar(Pieza pieza), y desencolar(), pero luego tuve problemas a la hora de probarlo, me gustaría que si alguien ha hecho esta práctica utilizando excepciones como yo quería, nos lo explique, ya que tengo algunas lagunillas con las excepciones.

Bueno chicos, nos vemos en la proxima práctica.

Comienza un nuevo viernes en el aula informática,nuestro amado sitio para empezar el fin de semana previo a las vacaciones, yujuuu!!Por fin!!.

La práctica trataba de herencia y orientación a objetos. Hemos de decir que teniamos gran parte de la práctica hecha por lo que no nos costó arrancar y empezamos muy agilmente. Además era modificar las clases de la práctica anterior. Se creaba una jerarquía de herencia con ‘Miembro’ como clase base y ‘Atributo’ y ‘Método’ como clases derivadas. A partir de estas creamos las clases derivadas ‘Parámetro’, ‘Constructor’, ‘AnalizadorObjetos’ y ‘PruebaObjetos’.

Práctica aparte, el profesor en la primera hora de la clase nos explicó el mecanismo de herencia y nos puso un ejemplo para afianzar el concepto. Además nos explicó la diferencia de la clase String con la clase StringBuffer. String tiene un tamaño fijo para almacenar cadena de caracteres, en cambio, StringBuffer es de tamaño variable y por ello hacemos una llamada al método append() desde el método toString().

–>método append(): método de la clase StringBuffer que sirve para asociar a la base de datos un objeto padre.

Continuamos con la práctica hasta que llegamos a un punto en que no podíamos seguir y pese a nuestras llamadas al profesor este opto al final de la clase por tomarse vacaciones y dejarnos con nuestras dudas de la práctica y el juego. Esperemos que el próximo día no salgan corriendo(no comemos).

Esperamos que os haya servido de ayuda nuestro pequeño apunte didáctico.Un saludo. Lidia y Carlos

Sentimos deciros a todos los que ilusionadamente habeis entrado a  visitar nuestro blog que en esta práctica no hemos podido hacer mucho. La nota de una asignatura nos influye en gran manera. Ahora ponen SS,no quiero entrar en sus orientaciones políticas…

Ejercicio 1: Este ejercicio lo podemos resumir en un paso por la API(divino tesoro) a la clase Math.Si, sabemos que había que hacer otra cosa pero el retraso incial y nuestro estado de ánimo nos lo impidió

Ejercico 2: Trazas de depuración y aserciones. Básicamente fue el ejercicio con el que nos peleamos en la clase.Probamos el método dado y construimos la clase LogTrace que nos pidieron tras unos minutos de discusión. De esto pudimos sacar la conclusion de que funciona pero no vemos el uso inmediato.

Ejercicio 3: Se explica en clase el manejo de excepciones,capturas,etc. No avanzamos más allá de este ejercicio ya que parte del tiempo de la práctica estuvimos charlando con el profesor acerca de nuestra situación en la asignatura y respecto al juego el cual empezaremos en breves momentos.

Revisaremos la práctica y la anterior que no nos ha dado tiempo a hacerlo todavía. Comentaremos los resultados añadiéndolos en cada post. No prometemos que sea pronto, pero tampoco demasiado tarde.

Sin más nos depedimos. Se acabó el cuatrimestre. Enhorabuena si habeis aprobado y lo sentimos si habeis suspendido. Junio promete ser mejor.

Un saludo. Lidia y Carlos