Ejercicio 4

•agosto 19, 2008 • Dejar un comentario

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
  

extended by 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
  

extended by 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!!!!

Ejercicio 3

•agosto 11, 2008 • Dejar un comentario

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();
}
}

Ejercicio 2

•julio 31, 2008 • Dejar un comentario

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
  extended by java.util.AbstractCollection<E>
      extended by java.util.AbstractList<E>
          extended by 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.

Ejercicio 1 de verano

•julio 29, 2008 • Dejar un comentario

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.

Práctica 12

•junio 13, 2008 • Dejar un comentario

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){…..}

}

Videojuego

•junio 5, 2008 • Dejar un comentario

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.

 

 

Práctica 11

•junio 5, 2008 • Dejar un comentario

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..

 

 
Seguir

Get every new post delivered to your Inbox.