Bueno, vamos a por la publicación del cuarto y ultimo ejercicio que trata de JMF, la verdad es que no tenia ni idea (y todavía ahora hay alguna) pero con este ejercicio me han quedado algo más claros los conceptos…..o al menos eso espero…jajaja…

Ejercicio 4

En esta ocasión se trata de realizar un reproductor de contenidos multimedia usando para ello los conocimiento básicos que de JMF hemos ida adquiriendo.

Para la realización del ejercicio deberemos de suponer dos cosas:

1º) Si al reproducir un fichero de audio le pido al placer que me dé la componente de video me devolverá un null.

2º) Para averiguar cuanto tiempo dura la reproducción de un fragmento de audio o de video lo haremos por el camino cutre para no tener que preguntar a la API de JMF; reproduciremos dicho fragmento, sin visualizarlo, y por medios ajenos al JMF mediremos cuanto tiempo ha tardado en reproducirse.(en mi caso lo he hecho llamando al getDuration de la clase duration porque no he conseguido saber como hacer para reproducir un fragmento sin que éste se vea, quizás porque tampoco he llegado a entender muy bien en que momento real se empieza a reproducir un archivo en las líneas de código que he podido ver de JMF).

Este reproductor, además, recibirá una lista de archivos por línea de comandos como argumentos de entrada y deberá imprimir por consola el nombre de cada archivo, si es de video o de audio y la duración.

Los archivos se pasarán de la siguiente manera a la hora de compilar:

Y a continuación la lista de archivos:

Después de esto deberá reproducir de forma cíclica (cuando pare deberá volver a empezar) el de menor duración, ya sea de audio o de video.

Para la realización de este ejercicio puede ayudarse de los siguientes métodos del API de JMF.

java.net
Class URL

java.lang.Object
  

java.net.URL

All Implemented Interfaces:

Serializable

getFile

public String getFile()

Gets the file name of this URL. The returned file portion will be the same as getPath(), plus the concatenation of the value of getQuery(), if any. If there is no query portion, this method and getPath() will return identical results.

Returns:

the file name of this URL, or an empty string if one does not exist

javax.media
Class Time

java.lang.Object
  |
  +--javax.media.Time

getSeconds

public double getSeconds()

Gets the time value in seconds.

Returns:

time value in seconds.

javax.xml.datatype
Class Duration

java.lang.Object
  

javax.xml.datatype.Duration

javax.media
Interface Duration

All Known Subinterfaces:

Controller, Demultiplexer, Player, Processor, Track

All Known Implementing Classes:

DataSource

getDuration

public Time getDuration()

Get the duration of the media represented by this object. The value returned is the media’s duration when played at the default rate. If the duration can’t be determined (for example, the media object is presenting live video) getDuration returns DURATION_UNKNOWN.

Returns:

A Time object representing the duration or DURATION_UNKNOWN.

Conocimientos empleados:

Basicamente en este ejercicio se trabaja casi en exclusiva con el API de JMF, asique es eso principalmente lo que hemos aprendido con este ejercicio, aunque he de decir, que al menos por mi parte no me ha quedado claro del todo, asique espero que con un par de cuestiones quede la cosa resuelta. ¿Alguien sabe por ejemplo como hacer que lea los archivos pero que no los reproduzca? Ahi queda eso por si alguien se anima a responder.

Bueno, a continuación os escribo mi solución de este ejercicio que consta unicamente de una clase:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.lang.String;
import java.net.URL;
import java.net.MalformedURLException;
import java.io.IOException;
import javax.media.*;

public class Reproductor extends JFrame implements ControllerListener{

String archivo;
long tiempo;//se intentara hacer con TimeMilliSecond
double duracion;
double duracionMin==10.000;//lo inicializo a un valor grande
Player player=null;
String tipoArchivo;
Component visualComponent=null;
Component controlComponent=null;
Component progressBar=null;

public Mi_Reproductor(String [] args) {

this.getContentPane().setLayout(new BorderLayout());
URL url = null;
try{

//Vamos leyendo uno a uno los elementos del array con los nombres de los //archivos y creando las url´s

for(int i =0 ; i<args.length; i++){
if ((url = new URL(args[i])) == null)
System.err.println(“No se puede construir URL para el archivo”);

archivo=url.getFile();
duracion=url.getDuration().getSeconds(); //getDuration() devuelve un objeto de la //clase Time
if(player().getVisualComponent()==null){
tipoArchivo=”audio”;
}else tipoArchivo=”video”;

System.out.println(“El nombre del archivo de”+tipoArchivo+”es:”+archivo+”, y su duración es: “+duracion+” segundos”);
if(duracion<duracionMin)
duracionMin=duracion;

}
//Aqui se busca cual es el archivo más corto para reproducirlo
for(int i=0; i<args.length; i++){
url=new URL(args[i]);
duracion=url.getDuration().getSeconds();
if(duracion==duracionMin){
player=Manager.createPlayer(url);
player.addControllerListener(this);
}

}
catch (MalformedURLException e){
System.err.println(“URL no valida”);
}
catch (IOException e){
System.err.println(“Excepcion de Lectura/Escritura”);
}
catch (NoPlayerException e){
System.err.println(“No existe reproductor”);
}

player.start();

this.addWindowListener(new ManejadorVentana());

}

//Manejador de los eventos

public synchronized void controllerUpdate(ControllerEvent event){

if (player == null) return; //Miramos si el player está “vivo”

if (event instanceof RealizeCompleteEvent){ //Si el reproductor ha entrado correctamente en estado realizado

if((visualComponent = player.getVisualComponent()) != null){

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

}else this.getContentPane.remove(visualComponent); //quita la componente visual //cuando devuelve null(audio)

if ((controlComponent = player.getControlPanelComponent()) != null)

this.getContentPane().add(“South”,controlComponent);

validate();

}else if (event instanceof EndOfMediaEvent){ //Si se ha alcanzado el final de contenidoMM que está reproduciendo

player.setMediaTime(new Time(0)); //”Rebobinamos” el contenidoMM
player.start(); //Volvemos a reproducir

}else if (event instanceof ControllerErrorEvent){ //Si se produce un error //indeterminado en la reproducción.

player = null;
System.err.println(((ControllerErrorEvent)event).getMessage());

}
}
public class ManejadorVentana extends windowAdapter{

public void windowClosing(WindowEvent e){

if(player!=null){
player.stop();
player.deallocated();
}
System.exit(0);
}
}

}

Pues hasta aqui los ejercicios veraniegos. Esperemos que nos sirvan para mucho y que tengamos todos la suficiente suerte como para que no nos echen de la carrera, hay que joderse, tanto sufrimiento ¿para qué?…..algún día lo sabremos….SUERTE!!!!

Bueno, pues aquí vamos con el tercero de esta serie de ejercicios veraniegos…la verdad es que creo que este es el que peor me ha salido de todos, además no he podido emplearle todo el tiempo que me hubiera gusado por diversos motivos, de todas formas hoy he seguido con el y me he puesto ha hacerlo en el entorno gráfico para poder llegar a acabarlo.

Ahi vamos con el enunciado:

En esta ocasión vamos a implementar una versión más sencilla del clásico juego Arkanoid.

Para ellos deberemos desarrollar cuatro clases.

En primer lugar la clase Pantalla donde se incluirán todos lo necesaría para crear una ventana dividida en dos.

Por un lado el lado derecho, que incluirán una pequeá frase detallando el objetivo del juego y un contador con el numero de rebotes conseguidos con la barra.

Por otro lado el izquierdo. En el ioncluiremos una cuadrícula de 20×30 que será en panel de juego.

El juego comenzará en el momento en que se arranque la aplicación.

En segundo lugar, la clase rebotador que deberá ser capaz de manejar una barra en la última linea de la cuadrícula que se mueva con el teclado de izquierda a derecha.

En tercer lugar implementaremos la clase bola que se encargará de los movientos diagonales de éstos teniendo en cuenta que deberá rebotar contra las paredes y el rebotador.

Por último, construiremos la clase Arranca, que contendrá el método main para iniciar la aplicación.

Conocimientos empleados:

-Herencia
-Algoritmos.
-swing.
-Manejar eventos
-Timer
//CLASE PANTALLA

import java.awt.*;
import java.swing.*;

public class Pantalla extends JFrame{

JPanel derecha, izquierda;
JLabel puntos;
JLabel etiquetaRebotes;
final int TAMAÑO_X = 20;
final int TAMAÑO_Y = 30;
Icon casilla, casilla_agua;
Icon rebotador;
JLabel tablero[][] = new JLabel[TAMAÑO_X][TAMAÑO_Y];
int rebotes;
int contador;

public pantalla(){

super(“Arkanoid”);

//Creacion del panel derecho.

JLabel instrucciones = new JLabel(“Consiga que la bola no caiga al agua”);
derecha = new JPanel(new BorderLayout());
derecha.add(instrucciones, BorderLayout.NORTH);
puntos = new JLabel(Integer.toString(rebotes));
derecha.add(puntos, BorderLayout.CENTER);
etiquetaRebotes = new JLabel(“REBOTES”);
derecha.add(etiquetaRebotes, BorderLayout.SOUTH);

//Creacion del panel izquierdo.

izquierda = new JPanel(new GridLayout(TAMAÑO_Y, TAMAÑO_X));

izquierda.setSize(TAMAÑO_X*TAMAÑO_Y, TAMAÑO_X*TAMAÑO_Y);

//Ciclo for para añadir posición del array y etiquetas de fondo

for(int i= 0; i<TAMAÑO_Y; i++){

for(int j= 0; j< TAMAÑO_X; j++){

casilla = new ImageIcon(“dibujos/casilla.jpg”);
tablero[i][j]= new JLabel(casilla);
tablero[i][j].setOpaque(true);
if(i==0 || j==0 ||j==19){
tablero[i][j] = new JLabel();
tablero[i][j].setBackground(Color.BLACK);
tablero[i][j].setOpaque(true);
}
izquierda.add(tablero[i][j]);
}
}
casilla_agua = new ImageIcon(“dibujos/casilla_agua.jpg”);
rebotador = new ImageIcon(“dibujos/rebotador.jpg”);

//Colocamos las casillas de la ultima fila.
for(int i = 0; i<8; i++){
tablero[29][i]= new JLabel(casilla_agua);
tablero[29][i].setOpaque(true);
izquierda.add(tablero[29][i]);
}
for(int i = 8; i<12; i++){
tablero[29][i]= new JLabel(rebotador);
tablero[29][i].setOpaque(true);
izquierda.add(tablero[29][i]);
}
for(int i = 12; i<20; i++){
tablero[29][i]= new JLabel(casilla_agua);
tablero[29][i].setOpaque(true);
izquierda.add(tablero[29][i]);
}

//Añadimos los paneles al contenedor.
this.getContentPane().setLayout(new GridLayout(1,2));
this.getContentPane().add(izquierda);
this.getContentPane().add(derecha);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setResizable(true);
this.setSize(TAMAÑO_X*TAMAÑO_X, TAMAÑO_Y*TAMAÑO_Y);
this.setVisible(true);
}

}

//CLASE REBOTADOR

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class Rebotador extends Pantalla implements KeyListener{

static int a=11;
static int b=8;

Rebotador(){

super();
}
public void keyTyped(KeyEvent e){}
public void keyReleased(KeyEvent e){}
public void keyPressed(KeyEvent e){

switch(e.getkeyCode()){

case KeyEvent.VK_RIGHT:
if(a==19){
}else{
a++;
tablero[29][a].setIcon(rebotador);
tablero[29][b].setIcon(casilla_agua);
b++;
}
break;
case KeyEvent.VK_LEFT:
if(b==0){
}else{
b–;
tablero[29][b].setIcon(rebotador);
tablero[29][a].setIcon(casilla_agua);
a–;
}
break;
}
}
}

//CLASE BOLA

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class Bola extends Pantalla implements ActionListener{

Timer timer;
int contador;
Icon bola;
int bolaX;
int bolaY;

Bola(){

super();
i=0;
bolaX=9;
bolaY=9;
bola = new ImageIcon(“dibujos/bola.jpg”);
timer = new Timer(500,this);
timer.start();
}
public void mueveDerechaAbajo(){

tablero[bolaY][bolaX].setIcon(casilla);
tablero[bolaY+1][bolaX+1].setIcon(bola);
bolaX++;
bolaY++;
}
public void mueveIzquierdaAbajo(){
tablero[bolaY][bolaX].setIcon(casilla);
tablero[bolaY-1][bolaX+1].setIcon(bola);
bolaX++;
bolaY–;
}        }
public void mueveDerechaArriba(){
tablero[bolaY][bolaX].setIcon(casilla);
tablero[bolaY-1][bolaX+1].setIcon(bola);
bolaX++;
bolaY–;

}
public void mueveIzquierdaArriba(){
tablero[bolaY][bolaX].setIcon(casilla);
tablero[bolaY-1][bolaX-1].setIcon(bola);
bolaX–;
bolaY–;
}

public void actionPerformed(ActionEvent e){

if(bolaX+1==19){
this.mueveIzquierdaAbajo();
}
this.mueveDerechaAbajo();
//Desde aqui se controlarán los eventos del timer, es decir, hay que resolver
//los diferentes casos de que caiga la bola, rebote y demás.
}
}

//CLASE ARRANCA

class Arranca{

public static void main(String args[]){

Pantalla p = new Pantalla();
}
}

Bueno, pues vamos a publicar el segundo ejercicio…a ver como ha ido este.

En esta ocasión se trata de crear una estructura de datos compleja.

Para ello habra que desarrollar cuatro clases que describiremos a continuación teniendo en cuenta el siguiente esquema:

Clase Cola:

Deberá comportarse como una cola pero con la estructura de una lista enlazada, para ello habra que implementar los siguientes métodos:

1. Encolar elementos (enqueue).

2. Desencolar elementos (dequeue).

3. Indicar si la cola está vacía.

4. Imprimir por pantalla todos los contenidos de la cola.

A su vez esta habrás que programar una clase nodo en la cual se almacenaran objectos de la clase Pila (que también implementatemos).

En esta clase habrá que implementar los métodos necesarios para que se comporte como lista enlazada.

Como ya hemos dicho, la clase cola almacenará en cada uno de sus nodos objetos de la clase Pila, que a su vez guardarán objetos de la clase Vector:

Los métodos a desarrollar dentro de la clase Pila serán los siguientes:

1. Introducir un elemento en la pila (push).

2. Extraer un elemento de la pila (pop).

3. Indicar si la pila está vacía.

4. Indicar si la pila está llena.

5. Imprimir por pantalla todos los contenidos de la pila.

Cada posición de la pila corresponderá con una posición de un array, es decir, la estructura de la pila que desarrollemos deberá ser la de un array.

Por ultimo, tendremos la clase Prueba que contendrá el main y un método llamado crearVector(String vectorInicial[]).

Este vector inicial estará compuestos de los numeros enteros del uno al cuatro.

Para el desarrollo de este problema adjuntamos las siguientes lines del API de java:

java.util
Class Vector<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>
          java.util.Vector<E>

Method Summary

void addElement(E obj): Adds the specified component to the end of this vector, increasing its size by one.

Enumeration<E> elements(): Returns an enumeration of the components of this vector.

boolean hasMoreElements(): Tests if this enumeration contains more elements.

nextElement(): Returns the next element of this enumeration if this enumeration object has at least one more element to provide.

A continución escribiré cada una de las clases que se han descrito arriba:

//CLASE COLA

public class Cola{

Nodo Primero;
Nodo Recorrido;

public Cola(){

Primero=null;
Recorrido=null;
}
public boolean vacia(){

return(Primero==null);
}

public void encolar(Pila p){
Nodo N = new Nodo(p,Primero);
Primero = N;
}
public void First(){
Recorrido = Primero;
}
public Pila Next(){
Pila p = null;
if(Recorrido != null){
p=Recorrido.Elemento();
Recorrido=Recorrido.siguiente();
}
return p;
}

public Nodo desencolar(){
Nodo n = Primero;
Primero = n.siguiente();
return n;
}

public Pila Current(){//No me queda muy claro que hace este método
Pila p = null;
if(Recorrido != null){
p=Recorrido.Elemento();
}
return p;
}

public void imprimir(){
primero.imprimir();
}

}

//CLASE NODO

class Nodo{

Nodo siguiente;
Pila pila;

public Nodo(){
siguiente=null;
pila=null;
}

public Nodo(Pila p, Nodo Siguiente){
pila = p;
this.siguiente = siguiente;
}

public Nodo siguiente(){
return siguiente;
}

public Pila Elemento(){
return pila;
}

public void ActElemento(Pila p2){
pila = p2;
}

public void ActSiguiente(Nodo n){
siguiente = n;
}
public void imprimir(){
System.out,println(“El nodo tiene”);
pila.imprimir();
siguiente.siguiente();
}
}

//CLASE PILA

import java.util.Vector;
import java.util.Enumeration;

class Pila{

private int numElementos;
private int ultimo;
private Vector elementos[];
private Vector v;

Pila(int numElementos, Vector v){
ultimo = -1;
this.numElementos = numElementos;
elementos = new Vector[numElementos];
this.v = v;
Nodo n = new Nodo();//Se crea el nodos con las pilas.
}

public boolean vacia(){
return(ultimo==-1);
}

public boolean llena(){
return(ultimo==numElementos);
}

public void apilar(Vector v){
ultimo++;
elementos[ultimo]=v;
}

public Vector desapilar(){
Vector v;
v = elementos[ultimo];
ultimo–;
return v;
}

public void imprimir(){
for(int i=0 ; i<elementos.length ; i++){
Enumeration e = v.elements();
while(e.hasMoreElements()){
String v = (String)e.nextElement();
System.out.println(v);
}
}
}
}

//CLASE PRUEBA

import java.util.Vector;

public class Prueba{

String vectorInicial[]={“1″,”2″,”3″,”4″};
int numElementos = 3;
Vector v = new Vector();

public Vector crearVector(String vectorInicial[]){

for(int i = 0; i<vectorInicial.length; i++)
v.addElement(vectorInicial[i]);
}
public static void main(String args[]){
crearVector(vectorInicial[]);
Pila p = new Pila(numElementos,v);
}
}

Finalmete escribiré una pequeña lista de los conceptos empleados en este ejercicio:
-Listas enlazadas(aunque yo personalmente no he sido capaz de llegar a entender esto bien)
-Pilas.
-colas.
-Clase Vector con sus metodos.

]]> http://julitros2008.wordpress.com/2008/07/31/ejercicio-2/feed/ 0 Manu&Julio extended by extended by extended by http://julitros2008.wordpress.com/2008/07/29/ejercicio-1-de-verano/ http://julitros2008.wordpress.com/2008/07/29/ejercicio-1-de-verano/#comments Tue, 29 Jul 2008 10:34:59 +0000 julitros2008 http://julitros2008.wordpress.com/?p=23 ]]>

Aqui esta el post de los ejercicios de verano, esperemos que nos sirvan para conseguir seguir en la carrera después de estos años…..puf!!!que miedo…..mucha suerte a todos!!!!

EJERCICIO 1

Este ejercicio consiste en programar cuatro clases y una interfaz que representarán un juego de rol

Para ello deberemos implementar lo siguiente:

1.1.Clase personaje.

Consistirá en una clase que englobará todas las caraterísticas del resto de personajes, además, deberemos tener en cuenta que no se podrán crear instancias de ésta.

La información que ha de guardar será la siguiente:

-Vida del personaje.

-Fuerza.

-Inteligencia.

-Astucia.

-Vigor inicial: Esta característica tendrá en todo momento el mismo valor para todos los personajes, esto es, si alguno cambia su vigor, el nuevo valor cambiará para todos.

Además, los métodos a implementar dentro de ésta clase serán;

-Constructores: inicializarán la información del personaje y tomarán nota del objeto que los llamó, para que puedan llamarlo más tarde.

-Métodos de acceso: A parte de cumplir su función, deberán notificar al método “personajeCambiado(Personaje)” del objeto que creo el personaje cada cambio que se produzca en la información de éste.

Desde aquí habra que llamar al método personajeCambiado(Personaje) de la clase Prueba usando como objeto el que se ha usado para crear el personaje en cuestión.

-Método “imprimir()”: sin implementar.

1.2.Clase Guerrero:

Aparte de la información y de los métodos de Personaje añadirá los siguientes:

Información:

-Habilidad.

-Puntería.

-Una variable que cuente el número de guerreros que han sido creados.

Métodos:

-Método imprimir, que pintará en pantalla la información del personaje.

1.3.Clase Maga

Actuará igual que guerrero, añadiendo:

Información:

-Magia.

-Poder de luz.

-Una variable que cuenta el número de magas que han sido creadas.

Métodos:

-Método imprimir: mostrará en pantalla la información del personaje.

-Deberá implementar la interfaz “Hechicero”.

1.4.Interfaz Hechicero:

Métodos:

-Doblar magia.

-Doblar poder de luz.

1.5.Clase de Prueba.

Métodos:

-main: Inicializará la variable vigor inicial con un entero de 300 y,

a continuación creará una maga.

-personajeCambiado(Personaje): recibirá un atributo de personaje e imprimirá

por pantalla los cambias que haya habido en éste, es decir, se deberá

llamar desde los métodos de acceso de las variables.

(Considero que no es necesario añadir nada del API porque los métodos que se van a usar no son de gran dificultad).

Bueno, a continuación, escribo las diferentes clase que he desarrollado siguiendo las directrices del enunciado.

//CLASE PERSONAJE

abstract class Personaje{
int vida;
int fuerza;
int inteligencia;
int astucia;
public static int vigorInicial;

//CONSTRUCTOR QUE RECIBE VIGOR_INICIAL E INICIALIZA LOS ATRIBUTOS

Personaje(int vigorInicial){
vida=4;
fuerza=300;
inteligencia=150;
astucia=200;
this.vigorInicial=vigorInicial;

}
//METODOS PON Y DAME

public void ponVida(int vida){
this.vida=vida;
}
public void ponFuerza(int fuerza){
this.fuerza=fuerza;
}
public void ponInteligencia(int inteligencia){
this.inteligencia=inteligencia;
}
public void ponAstucia(int astucia){
this.astucia=astucia;
}

public void dameVida(){
return vida;
}

public void dameFuerza(){
return fuerza;
}

public void dameIntreligencia(){
return inteligencia;
}

public void dameAstucia(){
return astucia;
}
//METODO ASBSTRACTO IMPRIMIR

abstract void imprimir();

}//CIERRE DE PERSONAJE

//CLASE GUERRERO

class Guerrero extends Personaje{

int habilidad;
int punteria;
int numGuerreros=0;
Personaje Guerrero;
Object o;

Guerrero(int vigorInicial, Object o){
super(vigorIncial);
this.o=o;
habilidad=50;
punteria=50;
numGuerreros++;
}
public void ponHabilidad(int habilidad){
this.habilidad=habilidad;
o.personajeCambiado(Guerrero);
}
public void ponPunteria(int punteria){
this.punteria=punteria;
o.personajeCambiado(Guerrero);
}
public int dameHabilidad(){
return habilidad;
}
public int damePunteria(){
return punteria;
}
public void imprimir(){
System.out.println(“El guerrero tiene las siguientes habilidades”);
System.out.println(“VIDA: “+vida);
System.out.println(“FUERZA: “+fuerza);
System.out.println(“INTELIGENCIA: “+inteligencia);
System.out.println(“ASTUCIA: “+astucia);
System.out.println(“HABILIDAD: “+habilidad);
System.out.println(“PUNTERIA: “+punteria);
System.out.println(“El numero de guerreros creado es: “+numGuerreros);

}//CIERRE IMPRIMIR

}//CIERRE GUERRERO

//INTERFACE HECHICERO

interface Hehicero{

public int doblarMagia();
public int doblarPoderDeLuz();
}

//CLASE MAGA

class Maga extends Personaje implements Hechicero{
int magia:
int poderDeLuz;
int numMagas;
Personaje maga;
Object o;

Maga(int vigorIncial, Object o){//Este objeto sera la referencia ak objeto que lo creo
super(int vigorInicial);
this.o=o;
magia=450;
poderDeLuz=300;
numMagas++;
}
//METODOS PON Y DAME

public void ponMagia(int magia){
this.magia=magia;
o.personajeCambiado(maga);//Como ha habido un cambio llamamos a personajeCambiado()
}
public void ponPoderDeLuz(int poderDeLuz){
this.poderDeLuz=poderDeLuz;
o.personajeCambiado(maga);//Como ha habido un cambio llamamos a personajeCambiado()
}
public int dameMagia(){
return magia;
}
public int damePoderDeLuz(){
return poderDeLuz();
}
//Metodos que doblan el valor de magio y poderDeLuz

public int doblarMagia(){
magia=magia*2;
return magia;
}
public int doblarPoderDeLuz(){
poderDeLuz=poderDeLuz*2;
return poderDeLuz;
}
public void imprimir(){
System.out.println(“Las cualidades de la maga son:”);
System.out.println(“VIDA =”+vida);
System.out.println(“FUERZA”+fuerza);
System.out.println(“INTELIGENCIA”+inteligencia);
System.out.println(“ASTUCIA”+astucia);
System.out.println(“MAGIA”+magia);
System.out.println(“PODER DE LUZ”+poderDeLuz);
}
}

//CLASE PRUEBA

class Prueba{
public static int vigorInicial=300;
public static String maga;
public static String guerrero;
public static String hechicero;
Prueba p = new Prueba();
public void personajeCambiado(Personaje p){
p.imprimir();
}
public static void crearPersonaje(String s){
if(s.equals(maga)){
Maga m = new Maga(vigorInicial, p);
}else if(s.equals(guerrero)){
Guerrero g = new Guerrero(vigorInicial, p);
}
}
public static void main(String args[]){

crearPersonaje(maga);

}
}

Conocimientos empleados:

En el ejercicio hemos podido practicar los siguientes conceptos:

-Herencia.
-Paso de variables como argumentos de métodos.
-Impementación de interfaces.
-Clases y métodos abstractos.
-Variables static.
-Uso e implementación del constructor.
-Métodos pon y dame.

]]> http://julitros2008.wordpress.com/2008/07/29/ejercicio-1-de-verano/feed/ 0 Manu&Julio http://julitros2008.wordpress.com/2008/06/13/practica-12/ http://julitros2008.wordpress.com/2008/06/13/practica-12/#comments Fri, 13 Jun 2008 14:50:02 +0000 julitros2008 http://julitros2008.wordpress.com/?p=15 ]]>

Comenzamos con JMF…

Introduccion

Este ejercicio sirve de introducción en el mundo de JMF mediante la lectura de su API

1)El paquete javax.media será el que englobe todas las funciones propias de esta API

El javax.media.control será el que implemente las funciones meramente de control.

El javax.media.format nos permitirá realizar acciones con el formato de video, haciando modificaciones y demás

Y el ultimo paquete, el javax.meda.util parece ser que nos permite hacer una captura de fotogramas para quedarnos con imágenes y viceversa

Después de esta introducción se nos informa de como debemos de instalar una serie de paquetes que no son propios de java y que necesitamos para el correcto funcionamiento de las clases de JMF

Ejercicio 1

Nos piden que desarrollemos un reproductor de video sin mucha más información. Nos hemos ayudado para ello de algo de información que hemos buscado en internet y de las explicaciones que se nos han dado en clase.

En realidad el reproductor no es más que hacer un JFrame con un ContentPane y dentro de este añadirle, dos componentes, uno de control, que será donde tengamos las funciones de play, stop, etc, y otro de visualización, que será el reproductor propiamente dicho.

En principio esto no parece que tenga mayr complicación pero debemos tener en cuenta que, en realidad, nos va a tocar tratar una serie de eventos y es aquí donde radica la mayor complicación.

Hemos realizado un objeto de la interfaz player, aydandonos de la clase manager(ya que no se puede hacer un new directamente de una interfaz) y usando el método createPlayer() y este objeto el que debemos de tratar ya que según se implementa se encuentrá en un estado Unrealized, en éste estado el player no está capacitado para reproducir.

La mayoría de los métodos que pueden ser llamados en un player requieren que éste esté en el estado Realized
Para saber en que momento se encuentra en disposición de reproducir el flujo multimedia utilizamos los ya mencionados eventos.

Además, hay que tener en cuenta que los eventos que se generan en el proceso de la reproducción de un flujo multimedia son de tipo asíncrono, es decir, podrán producirse en cualquier momento, por lo que habrá que reflejarlo en la implementación de método que los trate.

Para atender estos eventos deberemos seguir los siguiente pasos;

1) Implementar la interfaz ControllerListener en la clase que genera los eventos, y dentro de está clase deberemos desarrollar el método ControllerUpdate().

2)Registrar cada una de las instancias de la clase para notificar los eventos de la reproducción. Para ello, llamaremos al método del Player addControllerListener() .

De esta forma, cada vez que se genera un evento se llamará al método controllerUpdate() que será el encargado de tratarlos.

La implementación de este método consiste en una serie de if-else que proporcionan la solución a cada evento.

El esqueleto de esta clase será el siguiente:

public synchronized void controllerUpdate(ControllerEvent event){

if(event instanceof TipoEvento){…..}

else if (event instanceof OtroTIpoEvento){…..}

}

…

Nos dijeron en clase que habia que colgar una reseña del videojuego en el Blog. Ahí va!

El juego está implementado por mí (Julio Martín) y un compañero del grupo 66 (Claudio Barroso).

 Las bolas caen desde la parte superior de la pantalla como en el clásico juego del tetris;  la principal diferencia es que, en lugar de tener bloques, tenemos bolas de colores que hay que combinar entre sí  para conseguir sumar puntos y que se eliminen del tablero. Las combinaciones tienen que ser del mismo color y al  menos de tres bolas. Al igual que en el tetris, si las bolas llegan al inicio del tablero, el juego se termina  y te muestra la puntuación final.

Diagrama genérico:

Para implementar el juego, hemos desarrollado las siguientes 8 clases:

Una clase Bitrix, que hereda de JFrame, y se corresponderá con la ventana del Juego.

Cuatro clases que heredan de JPanel, que se combinarán entre sí y se añadiran al JFrame.

Una clase casilla que hereda de JLabel.

Una clase Bola.

Una clase Aplicación.

 Diagrama según su relación.

Clase Bola:

-Atributos: posición ‘x’ e ‘y’ en el tablero y un entero referente al color que toma.

-Al crearse una bola se le asigna un color aleatorio. Tiene los métodos avanzar, derecha e izquierda que modificarán su posición.

Clase Casilla:

-Contendrá una imagen de la bola, o una imagen vacia.

Clase Tablero.

-Atributos: Un objeto de la clase bola, un array de casillas (JLabel), un entero con la puntuación, un boolean finJuego  que se pondrá a true cuando se termine el juego.

-Gestiona la posición y movimientos de la bola, la eliminación y caída de las bolas, la suma de puntuación..          

Clase PanelJuego.

-Atributos: Contiene el panel tablero, un panel que recoge la puntuación, un panel de fin de juego, y un botón volver al menú.

-Implementa las interfaces keyListener, para mover la bola desde el teclado, y el actionListener, para los eventos del timer.

Clase PanelMenu.

-Atributos:Contiene dos botones, el de Jugar y el de salir.

-Estos botones estan controlados por la clase Bitrix.

Clase Multimedia.

Atributos:Contiene dos player, correspondientes a la canción del menú y la del Juego.

-Los componentes de control y los visuales no están implementados por estética.

Clase Bitrix

Atributos: Tres objetos, de PanelJuego, PanelMenu, y Multimedia.

-Implementa los botones que tiene el juego y gestiona el paso de un panel a otro, la reproducción de las canciones,..

Clase Aplicación

Es la clase que contiene el método main y ejecuta la aplicación propiamente dicha.

Hola de nuevo.

Ejercicio 1: Eventos en SWING

Vamos a comentar los apartados donde hemos visto un grado mayor de dificultad.

Comenzamos por el apartado 3, donde te preguntan por hilos (no los entiendo demasiado bien, asique si hay algún error, me gustaría que lo comentaseis)

El método implementado para cambiar color es éste:

bf= new BufferedReader (new InputStreamReader(System.in));
try{
String lineaTeclado = bf.readLine();
System.out.println(t.getName());
if(lineaTeclado.equals(“”)){
label.setBackground(new Color(0,100,0));
} }

donde t es un objeto de la clase Thread().

El hilo que esta haciendo esta ejecución es el 0. (la salida por pantalla nos indica: Thread-0).

Pasamos al ejercicio 5.

Esta clase la he implementado con una HashTable; como asociamos una clave(NIA) al objeto (nombre), podemos obtener el objeto a partir de esta clave.

Hemos utilizado un casting para convertir en String el objeto Object que te devuelve el método get de la clase Hashtable; aunque hubiera sido más correcto implementar el método toString().

Para simular la espera de 10 segundos , simplemente hay que invocar al método sleep(int) sobre el objeto de la clase Thread pasándole como argumento el tiempo en milisegundos.

Ejercicio 6

Lo que nos ha parecido mas complicado de este apartado, es hacer que el usuario no pueda lanzar nuevas búsquedas cuando hay una en curso. Lo que hacemos es quitarle el actionListener que agrego al botón (removeActionListener()) mientras que se está ejecutando la búsqueda. Seguro que hay formas mejores de implementarlo..

Bueno. seguimos con el swing…

Ejercicio 1

El primer ejercicio simplemente nos sirve para introducirnos en los procesos. Sólamente hemos tenido que ir copiando, pegando y ejecutanto tres clases.

La primera de ellas, llamada Ding, se encarga de lanzar un proceso que imprime Ding! por pantalla cada vez que pulsamos la tecla enter. Vemos que la complejidad de la clase es bastante baja y no tiene más.

La segunda clase se encarga de lanzar un proceso cada segundo que consiste en imprimir por pantalla el texto Dong!.

En este proceso se usa algo nuevo (Thread.sleep(1000);)que es quien se encarga de contar el tiempo.

Finalmente ejecutamos un texto que lo pretende es lanzar dos procesos a la vez pero éste ya no funciona correctamente ya que no puedes mandar al ordenador que ejecute más de un proceso al tiempo, para poder conseguir esto será necesarío llevarlos por diferentes vías.

Ejercicio 2

En este ejercicio comenzamos a ver como podemos lanzar dos procesos juntos mediante la creación de diferente hilos.

La mecánica de este ejercicio es la misma que la primera, iremos copiando y compilando.

En primer lugar, creamos una clase llamada TwoThreads que nos imprimirá por pantalla el nombre de los hilos creados en ésta. Al compilalarla vemos que funciona correctamente y nos imprime por pantalla;

main

Thread-0

La clase thread esta relacionada con la clase runable y cuando imvocamos a start(thread) se ejecuta automaticamente lo que haya en el método run() que pretenece a runnable. En dicho método, escribimos el código que se encargará de hacer lo que nosotros queramos, en este caso imprimir el nombre del hilo.

Podemos ver algo que en principio nos podrá chocar, y es la creación de un objeto de runnable, que es un interfaz, ya que en principio esto no se puede hacer, pero en realidad, lo que estamos haciendo es una clase interna, invocando dentro de esta el método run() característico de runnable.

En el segundo texto vemos una manera diferente de hacer la misma cosa.

La diferencia principal es que la clase principal implementa a runnable, por lo que ya no tenemos ninguna cosa “rara” . Run está dentro del cuerpo de la clase principal y en el main es donde se crea un objeto de la clase TwoThreadsSimple pero con las caracteristicas de runnable.

En último lugar tenemos el tercer texto en el que volvemos a conseguir el mismo resultado, pero la caraterística principal de este programa es que la clase hereda de Thread por lo que al hacer el objeto en el main de la clase TwoThreadsSimple, éste tendra todas las características de runnable ya que pertenece a Thread y hemos heredado de Thread.

Ejercicio 3

En este código se crean dos hilos, write0 y write1 y se llama al método start que está definido en runnable.

En principio lo que se podría esperar de este código viendolo a primera vista es que te imprima 10.000 ceros seguidos de 10.000 unos pero no ocurre así debido al funcionamiento en si de los hilos.

Lo que queremos con los hilos es ejecutar varios procesos a la vez, para ello se les adjudica un tiempo del total para cada hilo pero este tiempo no lo va a emplear seguido, es decir, si tiene 20ms no los agotará al instante, lo que hace es ir alternando los hilos a la hora de su ejecución.

En definitiva, el tiempo de ejecución de los procesos nos es desconocido pero es precisamente eso lo que nos interesa ya que nos debe dar la sensación de que éstos se ejecutan paralelamente aunque no sea así.

LLegó el Swing..

De momento parece que empieza fácil; muchos ejercicios, pero cortos para ir entendiendo poco a poco el funcionamiento..

Ejercicio 1
El funcionamiento de este programa se puede resumir en una serie de pasos:

-Se crea un objeto frame de la clase JFrame,
un contenedor de alto nivel (una ventana),
que va a contener a otros contenedores,

-Se invoca al método setDefaultCloseOperation, exclusivo de la clase JFrame,
pasándole como parámetro un objeto de la clase Operation definido en Jframe.
En este caso hablamos de JFrame.EXIT_ON_CLOSE, para permitir cerrar la aplicación usando el
método system exit (está indicado en el API)
-Se crean dos objetos, un contentPane de la clase JPanel, el panel por defecto que contiene el JFrame, y un label de la clase JLabel, una etiqueta de texto que se le añade al contentPane mediante el método add().

-Cuando el JFrame contiene todos los elementos añadidos, se suele invocar al método setSize() ,para definir el tamaño del frame y setVisible(), para que se haga visible el frame. Estos dos últimos métodos estan definidos en la clase Component, de la que heredan JFrame, JPanel y JLabel.

Para hacer mas grande la ventana (HelloWorldGUIBig ) basta con modificar los parámetros que se le pasan al setSize().

Para cambiar el color de fondo de contentPane se puede invocar al método setBackground() de la clase component, pasándole como parámetro un objeto de la clase color. Si quieres que sea azul: contentPane.setBackground(new Color(0,0,255));

Al añadir el codigo adicional, el programa tarda en ejecutarse mas tiempo. Lo que hicimos fué modificar el parámetro del thread.sleep, y observamos que “esperaba” mas a ejecutarse si aumentabamos la cifra, y al revés si la disminuimos.

El programa efectivamente sigue ejecutandose a pesar de que se acabe el método main(); esto es debido a que interactua con el usuario, y está esperando a que éste le de una orden (en este caso, solo puede cerrar la ventana) para seguir ejecutandose. Si comentamos setVisible y setSize, no hay ningún modo de interactuar con el usuario; entonces si que termina de ejecutarse.

Al añadir System.exit(0), el método main ya se encarga de cerrar la ventana, entonces se observa como se abre y se cierra la aplicación inmediatamente, sin dejar tiempo para que el usuario interactue con ésta.

Ejercicio 2

Tras repasar el manejo de ventanas y los diferentes metodos en el API comentamos los ejercicios.

Para ignorar el cierre tan solo hay que pasarle como argumento DO_NOTHING_ON_CLOSE al método setDefaultCloseOperation.

Si quieres que utilize el look and feel por defecto hay que invocar al método setDefaultLookAndFeelDecorated(true).

Para que no utilize decoración por defecto de ventana, hay que implementar setUndecorated(true).

Postearemos los demás ejercicios en breve!

Ejercicio 3

1) En primer lugar nos mandan hacer una variacion del programa HellowGuiColor cambiandole el color de las letras y del fondo.

Para cambiar el fondo de la etiqueta ultilzamos la siguiente linea de código:

label.setBackground(Color.BLACK);

Y para cambiar la letras:

label.setForeground(Color.WHITE);

En cuanto al tamaño de la venana vemos que para poder ponerla maximizada efectivamente hay que comprobar que el entorno gráfico soporta esta posibilidad. Parsa ellos usamos simplemente un if-else con el método isFrameStateSupported() pasándole como argumento Frame.MAXIMIZED_BOTH.

2) En este segundo apartado nos manadan que modifiquemos el programa colocandole cuatro etiquetas de diferente color y diferente texto posicionadas en los diferentess puntos cardinales.

Este apartado tiene la característica principal de como se colocan las etiquetas. Para distribuirlas lo único que usamos es la siguiente linea de código que se la pasamos como argumento al método add()

3) Podemos observar que los textos de las etiquetas vienen centrados, por defecto, a la izquierda y en la parte superior de la etiqueta. A continuación vemos como cambiar esto.

4) En este apartado nos piden modificar el programa anterior para centrar los textos de la etiqueta. Lo único que tenemos que hacer para esto será aplicar el método setHorizontalAlignment(JLabel.CENTER); sobre el objeto label pasandole como argumento la posición en la que queremos que la ponga, en este caso el centro y para la alineación vertical usaremos el método setVerticalAlignment(JLabel.CENTER);

5) En este apartado ya metemos una imagen dentro del contenedor. Para ello, en primer lugar, creamos un objeto de la clase ImageIcon y le pasamos el path de la imagen en cuestión. Después, este obejto se lo pasamos a otro objeto de la clase JLabel y definimos su color posición como hicimos anteriormente.

6) Para la realización de este apartado simplemente habrá que llamar al método pack(); sobre el objeto frame vemos que efectivamente nos reduce la ventana al mínimo necesario para que se vea correctamente.

7) En primer lugar, creamos unas variable de tipo int para almacenar las dimensiones de la pantalla y del frame, que las conseguimos mediante los métodos getWidth(); y getHeight(); aplicados sobre un objeto de la clase Dimension.

Finalmente usamos la clase setLocation sobre frame y le pasamos el punto donde queremos ponerlo que estará formado por las variable que hemos conseguido antes divididas entre dos.( Este paso no lo entiendo muy bien asique preguntare por algún blog a ver si alguien se lo ha planteado).

Ejercicio 4

Bueno, en principio no teníamos problemas con este ejercicio, creimos saber hacerlo pero en el momento de darle a compilar no funcionaba del todo correctamente. El único problema que nos da es que las letras que tienen que poner en negro las pinta del mismo color que las otras, es decir, blancas, y no sabemos porque pasa esto asique si a alguien le apetece leerse el trocillo de código y encuentra el típico fallo chorra que no alcanzas a ver que lo comente…

frame.setLayout(new GridLayout(20,1));
for(int i=0; i<20; i++){
label = new JLabel(“label “+i);
label.setOpaque(true);
if(i%2==0){
label.setForeground(Color.BLACK);
label.setBackground(Color.WHITER);

}else label.setBackground(Color.BLACK); label.setForeground(Color.WHITE);
contentPane.add(label, BorderLayout.CENTER);

Antes de nada, decir que se ha incorporado Manu del blog “Manuelen5″ y a partir de ahora haremos todas las prácticas juntos en este Blog.

Para no perder el hilo de las clases , hemos decidido empezar a comentar la práctica 8 y en los próximos días continuaremos con las que han quedado atrás.

Esta es la última práctica referente a algoritmia de la asignatura, antes de empezar con la chicha!!!

Ejercicio 1

En primer lugar, nos piden implementar una tabla Hash con trucos de un supuesto juego.

Tan solo hay que instanciar un objeto de la clase HashTable (previamente importada), y utilizar el método put para insertar elementos en la tabla con su respectiva clave, y el método get que nos devueve dicho elemento a partir de la clave.

Esta tabla es de gran utilidad ya que accedes fácilmente a los elementos de ésta, además aporta privacidad a los datos ya que solo puedes acceder a ellos a través de la clave asociada. Podríamos usar cualquier otra estructura de datos para almacenar elementos(pila, cola, array..) pero tendríamos que implementar el código para acceder a un elemento mediante una clave.

Ejercicio 2

1. Factorial. Analiza el código y estudia su funcionamiento recursivo.

Este método utiliza la recursividad para obtener el factorial de un número.  Simplemente se ”llama a si mismo” basandose en que el factorial de un número es la multiplicación de ese número por el factorial de ese número una unidad menor.

La condición de parada, se da cuando el número vale 1, y te devuelve un 1.

¿qué hace el método p1(…)?

Imprime el número que le pases como parámetro y vuelve a llamar a ese mismo método con este número una unidada menor, hasta que llega a 0, que imprime “Fin” y deja de ejecutarse el método.

¿qué muestra el método p2(..)?

Le pasas como parámetro un entero “a” y un entero “b”. Lo que hace es sumarle el valor de “a” a “b” y le resta una unidad a “a”. Con estos nuevos valores vuelve a ejecutar el método. La condición de parada se da cuando “a” vale 0, e imprime por pantalla el valor de b.

Suma de elementos de un array. Analiza el código del método suma(…) y estudia su funcionamiento recursivo.

Este método te devuelve el valor de el array en la posición elegida, y te lo suma a los sucesivos valores que tiene el array en posiciones superiores, hasta llegar al último valor. 

Fibonacci. Analiza el código del método fibonacci(…) y estudia su funcionamiento recursivo.

Como los anteriores, utiliza la recursividad para implementar la serie de fibonacci. El método deja de ejecutarse cuando el número que le pasas como parámetro es 1 o 2, en ese caso te devuelve un 1. 

Inverso de un número. Analiza el código del método inverso(…) y estudia su funcionamiento recursivo.

Este método te saca por pantalla las unidades, decenas, centenas.. del número que le pases. Se basa en la operación del resto “%” y utiliza el método recursivo para ir dividiendo el número entre 10 y sacar por pantalla el resto, y así sucesivamente, hasta que el número es menor que 10, que te imprime el número tal cual, y se termina la aplicación.

Si este método se me hubiera ocurrido en el examen de septiembre, ahora no estaría escribiendo esto…