Espero que paseis un buen verano todos toditos………………

Alitas.Button

Bueno no hay mucho que comentar creemos que al ser una practica de AUTOEVALUACION, los que la hayamos hecho ya juzgaremos el nivel que tenemos, pero si nos permitís, vamos a llenar el cuestionario intentando ajustarnos a la opinión de la mayoría, para ello hemos mirado también varios factores como el gran nivel de videojuegos que se han hecho en este curso o como los contenidos de los post o simplemente las mil y un consultas que todos nos hemos hecho a todos (contando con los profes).

Antes de despedirnos de esta asignatura queremos agradecer a todos nuestros compañeros y profes por el apoyo brindado, en especial a Raquel, Pachi, Juanlu, Aurora, Maria, etc… sentimos dejarnos algunos nombres… sin mas os deseamos a todos un aprobado o mas que os lo merecéis.

Igual que dice la práctica de que no será muy guiada este comentario intentará ser breve y conciso.

            Vamos primero a responder a las primeras preguntas sobre el API :

Javax.media.format, tiene una serie de clases para tratar los diferentes formatos de audio y video que pueden soportar los player,  Javax.media.util,  tiene dos métodos para convertir un video en una imagen awt y poder tratarla. Desde nuestro punto de vista nos parecen más relevantes las siguientes clases del API, con los métodos que comentamos de cada clase, Manager  ( createPlayer), Player (start), getControlcomponent, getVisualComponent),  Controller (getControll, close deallocate).

EJERCICO DE LA PRÁCTICA

Para realizar el reproductor los primero, tienes que importar una serie de clases, a parte de las de javax.swing.*, deberás importar bastantes de javax.media.*, y algunas para capturar Excepciones (java.net.*, java.io.*), sino cuando intentes compilar te lo irá recordando.

La parte del frame, el contenedor y que tipo de layout utilizar los obviamos, solo comentar que deberemos añadir dos “Component” el visualComponent y el controlPanelComponent.

Para crear el Player podemos hacerlo de dos formas:

1ª. Con un URL.

URL url = new URL (http://www.it.uc3m.es/tsioca/practica12/video/video.mpg);

URL url = new URL (“file:video.mpeg”);

     (cualquiera de estos dos parámetros son válidos),

Player player =  Manager.createPlayer (url);

“ A continuación debemos capturar las excepciones oportunas”

            2ª. Con un objeto DataSource:

MediaLocator ml = new Medialocator (“file:video.mpeg”);

DataSource dt = new DataSource (ml);

Player player = Manager.createPlayer (dt);

“ A continuación debemos capturar las excepciones oportunas”

Siempre después de crear el player deberemos llamar al método    player.start();                  

Acordaros de añadirle al player el escuchador de eventos ( .addControllerListener( )).

El método que recibe estos eventos nos deberá comprobar al menos, cuando recibimos un evento de tipo  “RealizeCompleteEvent” porque este será el momento de pedirle los componentes de control y visual y añadirlos a la ventana, tras añadirlos a la ventan debemos poner este método  validate ( ),  es un método de Jframe que hereda de la clase Container y es necesario invocarlo siempre que se actualicen los componentes de un contenedor.

Con poco más deberíamos conseguir reproducir el video. Para poner una casilla de verificación podemos utilizar un  JCheckBox, el cual nos genera eventos a ser marcado que son capturados por .addItemListener.

Por último podemos añadirle dos botones en ellos aparecerán las imágenes que nos dan y que tenemos que asociarlas a dos intervalos del video,  no se si habrá una manera más fácil de empezar la reproducción del video en un punto determinado con algún método que le pases un entero y te empieze a reproducir el video en ese instante, nosotros hemos utilizado el método player.getDuration(), para obtener la duración del player y con el método mapTimeToFrame(t) de la clase FramePositioningControl, asociamos el tiempo de duración del video a un número de frames, con el método seek(int), saltamos al número de frame que le pasamos.

Mucha suerte a todos en el examen y sobre todo a los que están en 5ª, a por todas..

Seguimos con Swing e introducimos eventos, vamos a realizar algunos ejercicios muy simples ( los primeros). para ver como manejar los eventos que nos proporciona SWING, los eventos nos permiten que a través de una acción del usuario como puede ser pulsar una tecla o pinchar con el ratón sobre un botón, se ejecute un código que maneja esta acción de evento, ( Sin eventos no hay JUEGO)………….

Comentaremos los ejercicios :

En los primeros ejercicos son muy simples y unicamente necesitamos un botón, etiquetas y capturar los eventos del botón para que nos realice el cambio de color  del mismo botón o de la etiqueta, con este método obtenemos el nombre del Thread que se está ejecutando Thread.currentThread().getName( ). Como podemos comprobar el thread será AWT-EventQueue-0.

PUNTO_3

El Thread que realiza el cambio de color se llama AWT-eventqueue-0.

Hemos puesto el escuchador del KeyListener al  botón, ya que se lo añadiamos al frame y no nos funcionaba pero asi  boton.addKeyListener(…), sin problema.

PUNTO_5

Para este ejercicio utilizamos una Hashtable, que como sabemos nos permite asociar una clave a un datos en nuestro caso (NIA, nombreAlumno), enel constructor introduciremos unos cuantos datos de entrada, de manera que al ejecutarlo en la consola le pasamos un numero que corresponda a un NIA, y nos devolverá el nombre por la salida estandar.

Para el método String query(int) throws InterruptedException , hemos utilizado  thread.Sleep(), y para el  método void abortQuery() Thread.interrupted().

PUNTO_6

En este apartado utilizaremos la clase anterior DataBaseGUI, pero añadiremos todos los elementos de la interfaz gráfica que se nos piden, nosotros hemos utilizado un BorderLayout, colocando en las 5 posiciones los 5 elementos que necesitamos, con el Tread.Sleep(), que se produce para simular la busqueda en la base de datos, ya nos evita que podamos introducir otra busqueda mientras realiza la anterior.

PUNTO_7

En este ejercicio seguiremos prácticando con los diversos componentes y contendores que nos ofrece SWING para realizar Interfaces gráficas.

Ejercicio1:

Para todos los que hayan ejecutado todos los pequeños programas de este ejercicio habrán visto con claridad lo que en práctica son los procesos y más o menos como la CPU los gestiona. Aprovechando la asignatura de segundo “Servidores de Información Multimedia” os dejamos un pequeño esquema y un poco de conceptos que con seguridad os acabara formando la idea global de la gestión de procesos de la CPU.

ESTADOS DE UN PROCESO (MODELO BÁSICO):

- Ejecutándose: Proceso ejecutando instrucciones tendrá asignada la CPU.

- Listo: El proceso está listo en el procesador para iniciar o continuar

su ejecución.

- En Espera o Bloqueado: El proceso deja de competir por el procesador,

esperando un evento externo (terminación de una operación de

Entrada/Salida, sincronización con otro proceso, una señal, etc.).

Veréis que un Thread implicaría que el proceso pase de estar en “Ejecución” a estar en “Espera o Bloqueado” hasta que pase el tiempo que en el que duerme el proceso para poder volver al estado de “Listo”.

Notar que SIEMPRE que implementemos un Thread.sleep() hay que tratar excepciones con un try-catch.

Ejercicio 2:

Destacamos las diferencias entre los tres programas:

TwoThreads

Es necesario crear un objeto Runnable y arrancarlo (run()).

Se crea un objeto Thread para acceder a sus métodos como arrancarlo y pedir su nombre.

TwoThreadsSimple

Implementa la interfaz Runnable (ahorro de código).

Creamos una instancia de la clase TwoThreadsSimple y un Thread para arrancarlo.

TwoThreadsSimple2

Extendemos de Thread (mas ahorro de código).

Creamos una instancia de la clase TwoThreadsSimple2 y al extender de Thread este se convierte en uno.

Ejercicio 3:

En este ejercicio volvemos a ver como la CPU trata a los procesos, dichas formas son bastante complejas y no necesariamente ordenadas, ya que el objetivo es optimizar el uso del procesador, en el primer programa “RaceCondition” al ejecutarlo vemos que los resultados en pantalla son para nada previsibles.

El programa “RaceConditionSolved” es muy complejo y con seguridad gastara más recursos que su versión simple. Para simplificar como ha sido hecho resumimos:

• Se crean un vector para ordenarlos eventQueue.
• Creamos los 2 distintos Runnable 0 y 1.
• Se crea el método algorítmico eventDispacherRunnable para tratarlos
• Por ultimo el método main.

Ejercicio 4:

En este ejercicio, que casi parece una práctica entera, vamos a dar por sentada toda la base de Swing ya que como casi todos estamos con el juego supongo que estará más que visto.

TRUCO: Para los métodos que se piden…

• Aquí tenéis un ejemplo de invokeLater para updateGUI en la clase StroboscopicGUI:

"static void javax.swing.SwingUtilities.invokeLater(Runnable doRun)"

public static void updateGUI() {

SwingUtilities.invokeLater(

new Runnable() {

public void run() {

label.setForeground(foregroundColor);

label.setBackground(backgroundColor);

}

});

}

• Otro para invokeAndWait tambien para updateGUI en la clase BinaryCyclicCounterGUI

"static void javax.swing.SwingUtilities.invokeAndWait(Runnable doRun)"

public void updateGUI() {

try {

javax.swing.SwingUtilities.invokeAndWait(

new Runnable() {

public void run() {

for(int i=0; i<NLEDS; i++) {

if (leds[i].get())

labels[i].setBackground(ON);

else

labels[i].setBackground(OFF);

}

}

});

}

catch (InterruptedException e) {

updateGUI();

}

catch (java.lang.reflect.InvocationTargetException e) {

updateGUI();

}

}

CONSEJO: Tener claro el manejo de el “Event-dispaching thread” que se arrancara automáticamente cuando se llama la primera vez: setVisible(), show(), pack().

Pues ya hemos empezado con Swing, aunque imagino que el que lleve el juego un poco avanzado ya se habrá visto en la necesidad de empezar a usarlo, pero bueno vamos a comentar la práctica.

Tras una serie de comentarios sobre la importancia de poder disponer de una representación gráfica que interactúe con el usuario y los casos en los que esta puede no ser necesaria e incluso perjudicial pasamos a los ejercicios que se nos pide.

EJERCICIO_1

            Debemos copiar este texto y compilarlo veremos como aparece una etiqueta de texto en un JFrame, (muy simple), a comentar:

                En la calse “HelloWorldGUIColor”, tener en cuenta que debemos importar la clase Color, de “java.awt.color”, nosotros recomendamos importar “ java.awt.*   y javax.swing.* “ . También nos piden introducir un texto ( Try—catch) entre setSize y setVisible, lo que ocurrirá es que se retrasará en este caso 10 segundos la aparición de la imagen en pantalla.

¿Porque tenemos que hacer este casting?                                                     

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

java.lang.Object
  java.awt.Component                  
  java.awt.Container
  java.awt.Window   
  java.awt.Frame
            
   javax.swing.JFrame

java.lang.Object
  java.awt.Component
  java.awt.Container      
  javax.swing.JComponent
      
  javax.swing.JPanel

Esta es la razón de porqué debemos realizar el casting (JPanel), ya que getContentPane nos devuelve un container.

       (imaginaros una flecha ascendente en el primer cuadro y una descendente el el segundo, los problemas del word)

EJERCICIO_2

              Tenemos que entender los diferentes métodos del manejador de ventanas del JFrame, a Comentar:

              Si no incluimos “setDefaultCloseOperation()”, pulsando el aspa desaparecerá la pantalla pero el programa seguirá ejecutándose debemos pulsar “ Control+ C “. Si ponemos “setUndecorated(true)” no tendremos el marco del frame con su aspa, ni minimizar y maximizar pantalla, por lo que para cerrar la ejecución de esta clase deberemos recurrir a “ Control+ C “.

Para el punto 4. un consejo el método:

 JFrame.setDefaultLookAndFeelDecorated(boolean b);

Lo debemos poner antes de crear el frame, si lo ponemos después no afecta sobre la ventana, NO se porque ocurre esto, si alguien lo tiene claro y quiere dejar un post explicándolo se lo agradeceríamos.

EJERCICIO 3

Vamos a ver como podemos ordenar varios componentes dentro de  un contenedor veremos que hay una forma manual (desaconsejable) y una forma automática a través de diferentes Layout; para tener acceso de forma rápida en el API a los diferentes Layout, buscar en All Clases, la clase LayoutManager, este Interface nos dará acceso al resto de Layout.

                La forma manual “NO COMENT”.

                Utilizaremos la forma automática manejando los diferentes Layouts que nos proporciona Java, podremos poner paneles sobre otros paneles con diferentes Layout, así conseguiremos las presentaciones deseadas.

Para centrar las etiquetas   label.setHorizontalAlignment(label.CENTER);

De los puntos 7. y 8. , comentar que el método  getScreenSize(), devuelve unas dimensiones ( ancho,alto), debemos crear una variable Dimension dimension; la cual recogerá lo que nos devuelva getScreenSize(), luego debemos tener dos variable ancho y alto de la pantalla que tomarán sus valores de dimension.getWidth()…..; OJO tenemos que hacer un casting “  = (int) dimension.getWidth(); “.

EJERCICIO 4

             Para este ejercicio hemos utilizado un GridLayout (20,1) de 20 filas y una columna si pones (20,0) también funciona, con un bucle for a la vez  que crea las etiquetas compara  si es par o impar y le da el formato apropiado. Tenemos que importar para crear los bordes:

import javax.swing.border.TitledBorder;

     import javax.swing.border.LineBorder;

             El último ejercicio consiste en utilizar todos los Layout vistos, para conseguir esta apariencia tenemos que hacerlo con orden y tener claro que va dentro de que. Espero no haberos aburrido mucho con el comentario y os veo después del puente.

Esta práctica se divide en tres ejercicios en el que se ha asignado un tiempo “orientativo” para cada uno…(je,je), vamos al grano.

Ejercicio_1.

Nos piden utilizar una tabla HasthTable para introducir unos datos ( trucos) y poder sacarlos por pantalla, nos dice que debe poder almacenar hasta diez, en nuestro método podemos introducir todos los trucos que queramos, sin límite, a continuación mostramos nuestro código, que permite introducir todos los trucos que deseemos y nos imprimirá en pantalla el truco ( sin límite “memoria dinámica”).

public static void main (String args[]) {

// Insertamos los valores en la colección.

for (int i=0; i<tamaño; i++) {
String clave = (String) args [puntero];
String valor = (String) args [puntero+1];
ht.put (clave,valor);
// imprimimos los valores
String D = (String) ht.get (clave);
System.out.println (D);
puntero +=2;

}             
}

Podríamos usar otras estructuras de datos como la clases Vector, Stack; pero HasthTable tiene una gran ventaja y es la posibilidad de acceder a un dato concreto a través de su clave sin necesidad de tener que recorrer toda la estructura ( o al menos para nosotros este recorrido está oculto).

Ejercicio_2

El ejercicio 2 no merece más comentario, analizamos el código de cada método que usa recursividad intentando averiguar que es lo que va a hacer, si alguien tiene algún problema con alguno en concreto que nos lo diga y lo intentamos explicar.

Ejercicio_3

Este ejercicio está muy chulo en nuestro método, si completa una fila, escribiría “Línea completa”, si encuentra una celda sin pintar escribiría “línea incompleta” y pasaría a la siguiente fila, (no seguiría comprobando las siguientes celdas de la fila);  al llegar a la última fila vuelve a empezar por el principio, claro, para que funcione deberíamos tener el array pintado, pero creo que funcionaría, haber si el profe le da un vistazo y nos da su opinión (seguro que se puede hacer mucho mejor)…..y para muestra un botón.

char tablero [][]=new char[10][7];
public void recorrerColumna (int a,int b){

if (a<10){

if (tablero[a][b]!= null && b<7 ){
System.out.print (“0″);

if (b==6){
System.out.print (” Linea completa \n”);
recorrerColumna (a+1,0);
}
else
recorrerColumna (a,b+1);

}
else{
System.out.print (” Linea incompleta \n”);
recorrerColumna (a+1,0);
}

}
else
recorrerColumna (0,0);

Pensemos en un tren con vagones de carga, los vagones transportan cualquier “objeto” en su interior igual que lo hacen en java los nodos,  cada vagón esta “enganchado” al que tiene delante, si hay que sacar un vagón del medio, solo tendríamos que re-enganchar los vagones que quedan.

Comprendiendo que los nodos son “vagones” donde transportamos nuestros objetos y que para enlazarlos tenemos que referenciarlos (engancharlos) al que esta delante ya sabemos como trabajan los nodos.

Destacable en esta practica:

Implementar un cola de objetos con nodos, si nos basamos en la implementación explicada en clase tipo pila, necesariamente tenemos que añadir un puntero y modificar su implementación, tendremos los mismos métodos de pila funcionando como cola.

A continuación mostramos nuestro código para “ListaNodos.java” del EJERCICIO 1 Y 2, veréis que necesitáis implementar antes la clase “Nodo.java”:

   public class ListaNodos{

      Nodo Primero;    //Nodo que apunta al primero en cola

      Nodo Ultimo;     //Nodo que apunta al ultimo en cola

      Nodo Recorrido;  //Nodo auxiliar para recorrer la cola

      int n;           //Variable auxiliar contador

      public ListaNodos(){

         Primero = null;

         Recorrido = null;

         Ultimo = null;

         n=0;

      }

      public void Insertar(Pieza p){

         Nodo N;

         N = new Nodo(p,Ultimo);

         if(n==0){

            Primero=N;

         }

         else{

            Ultimo = N;

         }

         n++;

      }

      public Pieza Sacar(){

         Recorrido=Ultimo.Siguiente();

         for(k=0; k<n; k++){

            Recorrido=Recorrido.Siguiente();

            k++;

         }

         Primero=Recorrido;

         n–;

         return Recorrido.Siguiente();

      }

      public boolean Vacia(){

         return (n=0);

      }

      public Pieza Actual(){

         Pieza p = null;

         if (Recorrido!=null)

            p = Recorrido.Elemento();

         return p;

      }

      public Pieza Primero(){

         return Primero.Elemento();

      }

      public Pieza Siguiente(){

         Pieza p=null;

         if (Recorrido!=null){

            p = Recorrido.Elemento();

            Recorrido = Recorrido.Siguiente();

         }

         return p;

      }

   }

TRUCO Y CONSEJO:

El funcionamiento de la clase ListaNodos (funcionando como cola) es muy sencillo, unicamente al aplicar la definicion de iterador tendremos que añadir un puntero para señalar el “principio” de la cola y el fin “ultimo”. Darle un repaso hasta que lo tengáis claro, también hemos encontrado muy útil este link que aclara la idea de las Listas enlazadas.

EJERCICIO 1:

Utilizamos la clase Cola vista en teoría  con todos sus métodos tal y como viene en los apuntes, para implementar un array tipo char unidimensional de piezas.

private char arraypiezas [] = new char [5];

Esta estructura de datos nos facilitara una serie de métodos (encolar (), desencolar (), llena (), etc.).

EJERCICIO 2:         

En el ejercicio 2 crearemos una clase Pieza la cual será la clase base de otras (PiezaL, PiezaT, etc).  La clase Pieza debe tener implementados los métodos que sean comunes a todas las piezas y que estas heredarán al extender de la clase base como por ejemplo:

protected  void rotarIzquierda(){

}

* Método de rotar pieza será igual para cualquier pieza.

TRUCO Y CONSEJO:

También implementamos un método en la clase Pieza  abstracto:

protected abstract void crearPieza();

Este método lo hemos declarado abstracto obligando así  a que cada clase que herede deba implementarlo y cada implementación será diferente al ser figuras distintas.

El constructor de Pieza (clase base) obligara a cada pieza a crearse llamando al método particular de cada una de ellas pero que ha sido obligada implementar.

public Pieza ( ){

array = new char[3][3];

crearPieza();

}

Bueno esperamos que os haya servido de algo,  recordar que se acepta cualquier tipo de consulta por algo estamos en quinta jejeje.  Hasta el viernes.