Beceoca

César Juárez Megías

ENUNCIADO EJERCICIO 4

 

En este último ejercicio, vamos a trabajar con el JMF.

No es nuestro objetivo andar investigando métodos muy rebuscados de su API, por lo tanto de cara a la realización de este ejercicio vamos a suponer dos cosas:

            -Si al reproducir un fichero de audio le pido al player que me de la componente de vídeo, el player me devolverá null.

- Para averiguar cuanto tiempo dura la reproducción de un fragmento de audio o de vídeo, lo haremos por el camino cutre, para no tenerle que preguntar a la API del JMF: reproduciremos dicho fragmento, sin visualizarlo, y por medios ajenos al JMF mediremos cuánto tiempo ha tardado en reproducirse.

 

Se trata pues, hechas estas aclaraciones, de construir un programa que reciba como argumentos de entrada (por la línea de comandos, es decir el array por defecto args del método main) una lista de archivos de vídeo y de audio indistintamente.

El programa, como resultado de su ejecución, imprimirá por consola el título de cada archivo, si es de audio o de vídeo y su duración.

Después seleccionará el fragmento más corto, ya sea de audio o de vídeo, y lo reproducirá de nuevo, pero esta vez mostrándole la reproducción al usuario.

Esta última reproducción habrá de ser cíclica: cuando el fragmento termine, volverá a empezar desde el principio.

 

CLASES EJERCICIO 4

(para hacer la lectura más fácil he puesto los comentarios en color verde)

 

//Importamos todos los paquetes necesarios

import javax.swing.*;

import javax.media.*;

import java.awt.*;

import java.awt.event.*;

import java.net.URL;

import java.net.MalformedURLException;

import java.io.IOException;

 

public class ProyectoReproductor extends JFrame implements ActionListener, ControllerListener{

 

//Atributos necesarios

Player player=null;

Component visualComponent = null;

Component controlComponent = null;

Component progressBar = null;

String [] args;

Timer t;

URL url;

int [] duracion; //Array para almacenar todas las duraciones de las canciones

int duracionNueva; //Variable que mide la duración del archivo

boolean reproduccionFinal = false; //Nos indicará si tenemos que reproducir el archivo más corto o si solo estamos midiendo la duración de los archivos

int masPequeño = 0; //Variable que nos indicará la posición de la canción más corta

 

 

//Constructor

public ProyectoReproductor(String [] args){

//Ponemos titulo a la ventana

super(“Reproductor”);

this.args = args;

this.getContentPane().setLayout(new BorderLayout());

t = new Timer(1000,this);

//Miramos la duración de todos los archivos

dameDuracionTodos();

//Imprimimos los datos de los archivos

imprimeDatos();

System.out.println(“Ahora se reproducirá el archivo más corto);

reproduccionFinal = true;

//Reproducimos el fichero más corto

reproduceMasCorto();

this.setSize(100, 100);

this.setVisible(true);

} //Fin del método constructor

 

 

// Método imprimeDatos

public void imprimeDatos(){

for (int i = 0; i<args.length(); i++){

System.out.println(“El archivo ”+args[i]+” es de ”+dameTipo(args[i])+” y tiene duración: ”+Integer.toString(duracion[i])+”  segundos.”);

}

} // Fin del método imprimeDatos

 

//Método dameTipo

public String dameTipo (String a, int i){

String tipo;

try{

//Intentamos crear la dirección y el player
 if((url=new URL(a)) == null){
System.out.println(”ERROR, no hay archivo a reproducir”);
}else{

//Si no de error creamos el placer con la dirección del archivo a reproducir
player=Manager.createPlayer(url);

//Miramos a ver si es de tipo audio o video mediante la respuesta al método getVisualComponent

if(player.getVisualComponent == null){

tipo = “audio”

}else{

tipo = “video”

}
}

//Capturamos todas los errores posibles

}

catch(MalformedURLException e){
System.err.println(”La dirección o el nombre del archivo con posición “+Integer.toString(i)+“ en la lista de reproducción no es correcta“);
}catch(IOException e){           
System.err.println(”Error de lectura o escritura”);
 }catch(NoPlayerException e){
System. err.println(”No existe un reproductor para hacer esta operación”);
}

//Devolvemos el tipo de archivo que era en este caso

return tipo;

} //Fin del método dameTipo

 

 

//Método dameDuracionTodos, medimos y almacenamos todos las duraciones de los archivos

public String dameDuracionTodos(){

for int(i=0; i <args.length();i++){

try{

//Intentamos crear la dirección y el player
 if((url=new URL(args[i])) == null){
System.out.println(”ERROR, no hay archivo a reproducir”);
}else{

//Si no de error creamos el placer con la dirección del archivo a reproducir
player=Manager.createPlayer(url);

player.addControllerListener(this);

}

//Capturamos todas los errores posibles

}catch(MalformedURLException e){
System.err.println(”La dirección o el nombre del archivo con posición “+Integer.toString(i)+“ en la lista de reproducción no es correcta“);
}catch(IOException e){           
System.err.println(”Error de lectura o escritura”);
 }catch(NoPlayerException e){
System. err.println(”No existe un reproductor para hacer esta operación”);
}

//Añadimos un manejador a la ventana por si esta se cierra el programa se acabe

this.addWindowListener(new ManejadorVentana());
player.start();
timer.start();

} //Fin del método dameDuracionTodos

 

//Método controllerUpdate

public synchronized void controllerUpdate(ControllerEvent event){

//Comprobamos que el reproductor está “vivo”

if (player == null){

return;

}

//Qué evento se ha producido?

if (event instanceof RealizeCompleteEvent){

//Se añade el componente de visualización del reproductor y el de control si es ya la reproducción final

if (reproduccionFinal == true){

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

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

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

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

                        validate();

         }

 }

//Si se ha terminado la reproducción del archivo paramos el timer, y almacenamos la duración, y si estamos ya en la reproducción final volvemos a poner en marcha el reproductor

else if (event instanceof EndOfMediaEvent){

player.setMediaTime(new Time(0));

if (reproduccionFinal == false){

t.stop();

duracion [i] = duracionNueva;

duracionNueva = 0;

{else{

//Si es ya la reproducción final volvemos a poner en marcha el reproductor

player.start();

}

}

else if (event instanceof ControllerErrorEvent){

player = null;

System.err.println(((ControllerErrorEvent)event).getMessage());

}

} //Fín del método controllerUpdate

                       

//Método actionPerformed (controlador del timer)

public void actionPerformed(ActionEvent e){
duracionNueva ++;
} //Fin del actionPerformed

 

//Método reproduceMasCorto

public void reproduceMasCorto(){

dimeMasPequeño();

//Ahora reproducimos el archivo más pequeño que haya en la lista de reproducción

try{

         //Se crea URL para el archivo

            if ((url = new URL(args[masPequeño])) == null)

               System.err.println(“No se puede construir URL para el archivo”);

         //Se crea el reproductor

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

//Como el escuchador de la ventana ya está añadido anteriormente no lo ponemos de nuevo

//Posteriormente se volverá a visualizar ya que hemos puesto una condición en el método controllerUpdate para saber si debemos o no reproducirlo de nuevo o quedarnos parados

      }//Fin delétodo reproduceMasCorto

 

 

//Método dimeMasPequeño

public void dimeMasPequeño (){

//Recorremos todos los componentes y miramos cuál es el más pequeño comparando el archivo segundo de la lista con el archivo más pequeño por el momento (en un principio el más pequeño por defecto será el cero) y así sucesivamente

for (int i = 1; i<duracion.length(); i++){

if(duracion[masPequeño]>duracion[i]){

masPequeño = i;

}

}

}//Fin del método dimeMasPequeño

 

 

//Método main

public static void main (String [] args){

ProyectoReproductor pr = new ProyectoReproductor(args);

}//Fin del método main

 

 

//Clase interna ManejadorVentana

public class ManejadorVentana extends WindowAdapter {

public void windowClosing (WindowEvent e) {

if (player != null) {

player.stop();

player.deallocate();

}

System.exit(0);

}

} //Fin de la clase interna

 

}  //Fin de la clase

CONCEPTOS USADOS EN EL EJERCICIO 4

 

En este caso los conceptos usados para resolver este ejercicio son los siguientes:

             

            - Conceptos sobre JMF

            - Conceptos de swing (incluidos manejos de eventos)

            - Conceptos de Timer

            - Conceptos de algoritmia básica

 

 

 

César Juárez Megías

ENUNCIADO EJERCICIO 3

 

En este caso en el ejercicio se trata de programar un pequeño juego en el que el jugador debe mantener una pelota rebotando de pared en pared sin dejarla caer al suelo.

Para lograrlo, el jugador moverá una raqueta en horizontal, a lo largo del borde inferior de la pantalla de juego.

 

En resumen, se trata de programar una versión simple del típico machaca-ladrillos (como por ejemplo el clásico Arkanoid) pero sin ladrillos.

Olvidaos de menús y similares: la partida comienza nada más arrancar el juego; esto es, aparece en pantalla una pelota moviéndose por la zona de juego y rebotando contra las paredes, y un rectángulo en la parte inferior que el jugador podrá mover a derecha e izquierda mediante el teclado.

Si la pelota llega a rebotar en la pared inferior (suelo), querrá decir que el jugador no logró interceptar la trayectoria de la pelota con la pala y se acabará la partida.

 

Para darle un poco más de gracia al asunto el algún lugar de la pantalla, preferiblemente fuera de la zona de juego, habrá un “marcador” que lleve la cuenta de cuántas veces ha rebotado hasta el momento la pelota contra la pala.

CLASES EJERCICIO 3

(para hacer la lectura más fácil he puesto los comentarios en color verde)

 

 

import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

 

//La propia clase es un JFrame

public class Juego extends JFrame{

 

//Declaramos las variables necesarias

//Como la pantalla la vamos a dividir en dos zonas, creamos dos paneles, en el de arriba pondremos la zona de juego y el de abajo la información de los rebotes en la pared, etc

JPanel zonaJuego;

JPanel zonaInfo;

JLabel info;

JLabel juego[][];

int numeroRebotes = 0;

int posicPala = 7;

//Direcciones posibles de la pelota, 1 para derecha y arriba y dos para izquierda y abajo

direccionPelotaHorizontal = 1;

direccionPelotaVertical = 1;

//La pelota está al inicio en la fila 13 (ya que la 14 es solo para la pala) y centrada, es decir en la columna 7

int posicPelotaFila = 13;

int posicPelotaColumna = 7;

Timer timer;

 

 

//Constructor

public Juego(){

//Llamamos al constructor de JFrame poniendo ya el nombre de la ventana

super(“Proyecto machaca-ladrillos”);

//Inicializamos las variables

creaInfo();

creaJuego();

this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

 

this.getContentPane().setLayout(new BorderLayout());
this.getContentPane().add(zonaJuego, BorderLayout.CENTER);
this.getContentPane().add(zonaInfo, BorderLayout.SOUTH);

 

Manejador manejador= new Manejador ();
addKeyListener(manejador);

 

this.setSize(950,700);

this.setResizable(false);

timer = new Timer(100, this);

timer.start();

this.setVisible(true);

}

 

//Metodo creaInfo, crea el area donde estará la información de los rebotes

public void creaInfo(){

info = new JLabel();

info.setText(“El numero de rebotes es: “+Integer.toString(numRebotes));

info.setOpaque(true);

info.setBackGround(Color.BLACK);

info.setForeground(Color.WHITE);

zonaInfo.add(info);}

 

//Metodo actualizaInfo, este método actualiza la etiqueta que contiene la informacion de los rebotes y refresca la pantalla para hacerla visible

public void actualizaInfo(){

info.setText(“El numero de rebotes es: “+Integer.toString(numRebotes));

this.setVisible(true);}

 

//Metodo creaJuego, crea el área donde estará la el juego

public void creaJuego(){

zonaJuego = new JPanel();

juego = new JLabel [15][15];

 

//Ponemos todo en negro en un principio

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

for(int j = 0; j<14; j++ ){

juego[i][j].setOpaque(true);

juego[i][j].setBackground(Color.BLACK);

zonaJuego.add(juego[i][j]);

}}

pintaPala();

pintaPelota();

}

 

//Metodo pintaPala, pintamos una pala de tres celdas de tamaño

public void pintaPala(){

juego[14][posicPala-1].setBackground(Color.BLACK);

juego[14][posicPala].setBackground(Color.BLACK);

juego[14][posicPala+1].setBackground(Color.BLACK);

}

 

//Método pintaPelota, pintamos una pelota de una celda de tamaño

public void pintaPelota(){

juego[posicPelotaFila][posicPelotaColumna].setBackground(Color.BLACK);

}

 

//Método actionPerformed, controla el timer

public void actionPerformed(ActionEvent e){

timer.stop();

 

//Si la pelota va hacia la derecha

if (direccionPelotaHorizontal == 1){

            //pero no ha llegado a la pared

if (posicionPelotaColumna != 14){

//Si la pelota va hacia arriba y no ha llegado al techo

if (direccionPelotaVertical == 1 && posicionPelotaFila != 0){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila–;

posicionPelotaColumna++;

pintaPelota();

//Si la pelota va hacia arriba y ha llegado al techo

}else if (direccionPelotaVertical == 1 && posicionPelotaFila == 0){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila++;

posicionPelotaColumna++;

pintaPelota();

//Si la pelota va hacia abajo y no ha llegado al suelo

} else if (direccionPelotaVertical == 2 && posicionPelotaFila != 14){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila++;

posicionPelotaColumna–;

pintaPelota();

//Si la pelota ha va hacia abajo y ha llegado al suelo

}else if (direccionPelotaVertical == 2 && posicionPelotaFila == 14){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

//Si da con la pala

if (posicionPelotaColumna== posicPala || posicionPelotaColumna== posicPala-1 || posicionPelotaColumna== posicPala+1){

posicionPelotaFila–;

posicionPelotaColumna++;

pintaPelota();

}

            //Si no da con la pala has perdido

else if (posicionPelotaColumna!= posicPala || posicionPelotaColumna!= posicPala-1 || posicionPelotaColumna!= posicPala+1){

            System.out.println(“Game over”);

            System.exit(0);

            }

}

}

//y ha llegado a la pared

else if (posicionPelotaColumna == 14){

            //pero no ha llegado al techo

if (direccionPelotaVertical == 1 && posiciónPelotaFila!=0){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila–;

posicionPelotaColumna–;

direccionPelotaHorizontal = 2;

pintaPelota();}

//pero ha llegado al techo

else if(direccionPelotaVertical == 1 && posiciónPelotaFila==0){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila++;

posicionPelotaColumna–;

direccionPelotaHorizontal = 2;

direccionPelotaVertical = 2;

pintaPelota();

}

//pero no ha llegado al suelo

else if (direccionPelotaVertical == 2 && posiciónPelotaFila!=14){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila++;

posicionPelotaColumna–;

direccionPelotaHorizontal = 2;

pintaPelota();

}

//pero ha llegado al suelo

else if(direccionPelotaVertical == 2 && posiciónPelotaFila==14){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

//Si da con la pala

if (posicionPelotaColumna== posicPala || posicionPelotaColumna== posicPala-1 || posicionPelotaColumna== posicPala+1){

posicionPelotaFila–;

posicionPelotaColumna–;

direccionPelotaHorizontal = 2;

numeroRebotes++;

actualizaInfo();

pintaPelota();

}

            //Si no da con la pala has perdido

else if (posicionPelotaColumna!= posicPala || posicionPelotaColumna!= posicPala-1 || posicionPelotaColumna!= posicPala+1){

            System.out.println(“Game over”);

            System.exit(0);

            }

}

 

}

}

 

//Si la pelota va hacia la izquierda

else if (direccionPelotaHorizontal == 2){

//pero no ha llegado a la pared

if (posicionPelotaColumna != 0){

//Si la pelota va hacia arriba y no ha llegado al techo

if (direccionPelotaVertical == 1 && posicionPelotaFila != 0){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila–;

posicionPelotaColumna–;

pintaPelota();

//Si la pelota va hacia arriba y ha llegado al techo

}else if (direccionPelotaVertical == 1 && posicionPelotaFila == 0){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila++;

posicionPelotaColumna–;

pintaPelota();

//Si la pelota va hacia abajo y no ha llegado al suelo

} else if (direccionPelotaVertical == 2 && posicionPelotaFila != 14){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila++;

posicionPelotaColumna–;

pintaPelota();

//Si la pelota ha va hacia abajo y ha llegado al suelo

}else if (direccionPelotaVertical == 2 && posicionPelotaFila == 14){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

//Si da con la pala

if (posicionPelotaColumna== posicPala || posicionPelotaColumna== posicPala-1 || posicionPelotaColumna== posicPala+1){

posicionPelotaFila–;

posicionPelotaColumna–;

pintaPelota();

 

}

            //Si no da con la pala has perdido

else if (posicionPelotaColumna!= posicPala || posicionPelotaColumna!= posicPala-1 || posicionPelotaColumna!= posicPala+1){

            System.out.println(“Game over”);

            System.exit(0);

            }

}

}

//y ha llegado a la pared

else if (posicionPelotaColumna == 0){

            //pero no ha llegado al techo

if (direccionPelotaVertical == 1 && posiciónPelotaFila!=0){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila–;

posicionPelotaColumna++;

direccionPelotaHorizontal = 1;

pintaPelota();

}

//pero ha llegado al techo

else if(direccionPelotaVertical == 1 && posiciónPelotaFila==0){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila++;

posicionPelotaColumna++;

direccionPelotaHorizontal = 1;

direccionPelotaVertical = 2;

pintaPelota();

}

//pero no ha llegado al suelo

else if (direccionPelotaVertical == 2 && posiciónPelotaFila!=14){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

posicionPelotaFila++;

posicionPelotaColumna++;

direccionPelotaHorizontal = 1;

pintaPelota();

}

//pero ha llegado al suelo

else if(direccionPelotaVertical == 2 && posiciónPelotaFila==14){

juego[posicionPelotaFila][ posicionPelotaColumna].setBackground(Color.BLACK);

//Si da con la pala

if (posicionPelotaColumna== posicPala || posicionPelotaColumna== posicPala-1 || posicionPelotaColumna== posicPala+1){

posicionPelotaFila–;

posicionPelotaColumna++;

dirPelotaHorizontal = 1;

numeroRebotes++;

actualizaInfo();

pintaPelota();

}

            //Si no da con la pala has perdido

else if (posicionPelotaColumna!= posicPala || posicionPelotaColumna!= posicPala-1 || posicionPelotaColumna!= posicPala+1){

            System.out.println(“Game over”);

            System.exit(0);

            }

}

 

}

}

timer.start();

}//Fin del actionPerformed

 

//Clase interna Manejador, controla los eventos del teclado

class Manejador extends  KeyAdapter {

public void KeyPressed(KeyEvent evento){

//Miramos los casos posibles (tecla izda o dcha pulsada)

switch(evento.getKeyCode){

//Si la tecla pulsada es la derecha, miramos que no estemos ya pegando a la pared de la derecha y si no lo estamos movemos la pala

case KeyEvent.VK_RIGHT:

if(posicPala<13){

juego[14][posicPala-1].setBackground(Color.BLACK);

juego[14][posicPala+2].setBackground(Color.WHITE);

posicPala++;}

 

//Si la tecla pulsada es la izda, miramos que no estemos ya pegando a la pared de la izda y si no lo estamos movemos la pala

case KeyEvent.VK_LEFT:

if(posicPala>1){

juego[14][posicPala+1].setBackground(Color.BLACK);

juego[14][posicPala-2].setBackground(Color.WHITE);

posicPala–;}}}} //Fin de la clase interna Manejador

 

//Método Main

public static void main(String [] args){
 
Juego j = new Juego();
} //Fin del método Main

 

}//Fin de la clase Juego

CONCEPTOS USADOS EN EL EJERCICIO 3

 

En este caso los conceptos usados para resolver este ejercicio son los siguientes:

            - Conceptos de swing a nivel general

            - Conceptos de eventos

            - Timer

            - Uso de switch

César Juárez Megías

ENUNCIADO EJERCICIO 2

 

Se pretende construir una estructura de datos compleja, en este caso una cola mediante el uso de una lista enlazada.

Esta cola deberá contener los siguientes métodos:

            · Encolar elementos (enqueue).

            · Desencolar elementos (dequeue).

            · Indicar si la cola está vacía.

            · Imprimir por pantalla todos los contenidos de la cola.

 

En nuestro caso, la cola que vamos a crear almacenará objetos de tipo pila, cuya clase también deberemos programar, la cual llevará estos métodos:

            · Introducir un elemento en la pila (push).

            · Extraer un elemento de la pila (pop).

            · Indicar si la pila está vacía.

            · Indicar si la pila está llena.

            · Imprimir por pantalla todos los contenidos de la pila.

 

Como en el caso de las colas también deberemos programarla mediante una lista enlazada, la pila se implementará mediante un array.

 

Cada una de estas pilas contendrá vectores (uno en cada posición de la pila)

 

Suponemos que la cola y la pila tienen tamaño para 15 objetos.

Suponemos también que los vectores que se almacenan en la pila nos los dan ya tal y como se quieren almacenar

 

 

NOTAS

 El método imprimir de la cola imprimirá por pantalla cada una de las pilas almacenadas en ella.

A su vez, imprimir cada una de estas pilas significa imprimir todos y cada uno de los vectores que almacena.

Por último, imprimir uno de estos vectores quiere decir imprimir, uno debajo de otro, todos los objetos que estén guardados en él, considerando que dichos objetos serán números enteros.

Tras la impresión, la estructura de datos al completo deberá quedar tal y como estaba al principio.

CLASES EJERCICIO 2

(para hacer la lectura más fácil he puesto los comentarios en color verde)

 

Clase Cola

public class Cola{

//Declaramos los atributos necesarios, en este caso el constructor será el que viene por defecto

private int tamaño = 15;

public int objetosEnCola = 0;

public int objetosImpresos = 0;

public Nodo primero = null;

public Nodo ultimo = null;

 

//Metodo enqueue

public void enqueue(Pila pila){

//Comprobamos que la cola no está llena

if (estaLlena == false){

if (estaVacia == true){

//Al ser el primer objeto añadido tendrá a la vez la primera y la última posición

primero = new Nodo(pila);

ultimo = new Nodo(pila);

}else{

//Como no es el primer objeto añadido creo un nuevo nodo con la pila que voy a encolar

nuevoUltimo = new Nodo(pila);

//Pongo el ultimo nodo apuntando al nuevo

ultimo.setNodoSiguiente(nuevoUltimo);

//Cambio el ultimo nodo por el que acabo de añadir al final de la cola

ultimo = nuevoUltimo;}

//Sumo un objeto en la cuenta de objetos que tiene la cola

objetosEnCola++;

}else{

//Si la cola está llena saco por pantalla un mensaje de error

System.error.println(“La cola está llena, no puede añadir más objetos”);}}

 

//Metodo dequeue

public Pila dequeue(){

if (estaVacia == false){

//Guardo la pila a devolver en una variable

Pila pilaADevolver = primero.getPila();

//Pongo la posición siguiente como la primera de la cola

Nodo NuevoPrimero = primero.getSiguiente();

primero = nuevoPrimero;

//Resto el objeto que acabo de sacar de la cola

objetosEnCola–;

//Devuelvo el nodo que había en la primera posición

return (PilaADevolver);}

//Si no hay objetos en la cola

else{

System.error.println(“No hay más objetos en esta cola”);}}

 

//Metodo estaVacia

public boolean estaVacia(){

//Si la cola está vacía (no hay ningún objeto) devuelvo true, sino, devuelvo false

if (objetosEnCola==0){

return true;

}else{

return false;}}

 

//Metodo imprimir

public void imprimir(){

//Si la cola está vacia lo comunicamos en un mensaje por pantalla

if (estaVacia()==true){

System.out.println(“La cola está vacia”);

}else{

primero.imprimir();

imprimeRestantes(primero.getSiguiente());}

 

public void imprimeRestantes(Nodo nod)

//Si el nodo no es nulo, lo imprimimos y llamamos a este método para que imprima el siguiente

if (nod != null){

nod.imprimir();

imprimeRestantes(nod.gesSiguiente());

//Si el nodo es nulo, no hay más que hacer y por lo tanto se sale automáticamente del algoritmo recursivo

}}}//Fin de la clase Cola

 

Clase Nodo

public class Nodo{

//Declaramos los atributos necesarios

Pila pila;

Nodo siguiente == null;

 

//Constructor

public Nodo(Pila pila){

this.pila = pila;}

 

//Método setNodoSiguiente

public void setNodoSiguiente(Nodo siguiente){

this.siguiente = siguiente;}

 

//Método getNodoSiguiente

public Nodo getNodoSiguiente(){

return (siguiente);}

 

//Método getPila

public Pila getPila(){

return pila;}

//Método imprimir (llama directamente al método imprimir de la pila)

public void imprimir(){

pila.imprimir();}

}//Fin de la clase Nodo

 

Clase Pila

import import java.util.*;

public class Pila{

//Declaramos las variables necesarias

public Vector array [];

public int tamaño = 15;

public int posicion = 0;

 

//Constructor

public Pila(){

array = new Vector [tamaño];}

 

//Método push

public void push(Vector i){

//Miramos si la cola no está llena, si lo está sacamos un mensaje por pantalla,

y si no lo está añadimos el objeto en su posición

if (estaLlena()){

System.out.println(“La pila está llena”);}

else{

array [posicion] = i;

posicion++;}}

 

//Método pop

public Vector pop(){

//Devolvemos el objeto de la lista que está en la primera posición para salir de ella

return array [posicion];

posicion–;}

 

//Método estaLlena

public boolean estaLlena(){

if (posicion == (tamaño-1)){

return true;

}else{

return false;}}

 

//Método estaVacia

public boolean estaVacia(){

if (posicion == -1){

return true;

}else{

return false;}}

 

//Método imprimir

public void imprimir(){

//Comprobamos que no está vacia y si no lo está imprimimos por pantalla todos los elementos de la lista

if (estaVacia()){

System.out.println(“La pila está llena”);

}else{

//Recorremos la pila

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

//Recorremos el vector

for(int j=0; j<array[i].size(); j++){

System.out.print(array[i].elementAt(j)+”  “);}}}}

 

}//Fin de la clase Pila

CONCEPTOS USADOS EN EL EJERCICIO 2

 

En este caso los conceptos usados para resolver este ejercicio son los siguientes:

            - Concepto de pilas y colas

            - Uso de una cola dinámica

            - Uso de la clase Vector

            - Conceptos de algoritmia nivel básico/medio (recorrer arrays, llamadas a otros métodos dentro de un método)

            - Recursividad

César Juárez Megías

 

ENUNCIADO EJERCICIO 1

 El problema consiste en crear clases que representan cada una a un personaje de un juego de rol y una interfaz

 

Clase personaje:

Es una clase que recoge todas las características comunes de todos los tipos de personaje existentes.

Debe programarse de forma que no se puedan crear instancias de ella.

- Información que deberá guardar como mínimo:

 · Vida del personaje.

 · Fuerza.

 · Inteligencia.

 · Astucia.

 · Vigor inicial: Esta característica tendrá en todo momento el mismo valor para todos los personajes

Si alguno de los personajes cambia su vigor, el nuevo valor cambiará para todos.

 

- Métodos:

· Constructores varios: deben inicializar la información del personaje, y tomar nota del objeto que los llamó, a fin poder llamarlo más tarde.

· Métodos de acceso a la información: deberán notificar al método “personajeCambiado(Personaje)” del objeto que creo el personaje cada cambio que se produzca en la información del personaje.

· Un método “imprimir()” sin implementar.

 

 

Clase Guerrero: Guardará la misma información y tendrá los mismos métodos que Personaje, añadiendo además:

- Información:

· Habilidad.

· Puntería.

· Una variable que lleve la cuenta de cuantos guerreros hay creados en cada momento.

- Métodos:

·  Un método para imprimir por pantalla toda la información del personaje.

 

 

Clase Maga: Guardará la misma información y tendrá los mismos métodos que Personaje, y además añadirá:

- Información:

· Magia.

· Poder de la luz.

· Una variable que lleve la cuenta de cuantas magas hay en cada momento.

- Métodos:

· Un método para imprimir por pantalla toda la información del personaje.

· Esta clase deberá además implementar la interfaz “Hechicero”.

 

Interfaz Hechicero:

- Métodos:

· Doblar magia.

· Doblar poder de la luz.

Clase de prueba: El método “main” de esta clase de prueba dará un valor inicial al vigor de los personajes, después procederá a crear una maga. Debe incluir también un método personajeCambiado(Personaje), que simplemente imprima por pantalla las características del personaje cambiado.

 

NOTA: en el ejercicio resuelto he puesto que tiene que haber algún método parecido o igual que el getSource() para saber quien ha llamado a un método, por lo tanto se debería poner en el enunciado dicho método ya que no es común y no tiene porqué conocerse (por lo menos desde mi punto de vista)

 

CLASES EJERCICIO 1

(para hacer la lectura más fácil he puesto los comentarios en color verde)

 

Clase Personaje

//Ponemos la clase como abstract para no poder instanciarla

public abstract class Personaje{

 

//Definimos los atributos

private int vida;

private int fuerza;

private int inteligencia;

private int astucia;

private static int vigorInicial;

 

//constuctor

public Personaje(int vida, int fuerza, int inteligencia, int astucia, int vigorInicial){

this.vida = vida;

this.fuerza = fuerza;

this.inteligencia = inteligencia;

this.astucia = astucia;

this.vigorInicial = vigorInicial;

}

 

//metodos get…

public int getVida(){

return vida;}

 

public int getFuerza(){

return fuerza;}

 

public int getInteligencia(){

return inteligencia;}

 

public int getAstucia(){

return astucia;}

 

public int getVigorInicial(){

return vigorInicial;}

 

//Métodos set… para saber quién ha llamado a este método usaríamos algún método ya creado parecido a getSource(), que nos devolviera el objeto que ha llamado al método

public void setVida(int a){

a = vida;

personajeCambiado(metodo tipo getsource);}

 

public void setFuerza(int a){

a = fuerza;

personajeCambiado(metodo tipo getsource);}

 

public void setInteligencia(int a){

a = inteligencia;

personajeCambiado(metodo tipo getsource);}

 

public void setAstucia(int a){

a = astucia;

personajeCambiado(metodo tipo getsource);}

 

public void setVigorInicial(int a){

a = vigorInicial;

personajeCambiado(metodo tipo getsource);}

 

 

public abstract void imprimir(){}

 

}

 

Clase Guerrero

//Esta clase hereda de personaje

public class Guerrero extends Personaje{

 

//Definimos los atributos necesarios

private int habilidad;

private int punteria;

private static int guerrerosCreados = 0;

 

//Constructor

public Guerrero(int vida, int fuerza, int inteligencia, int astucia, int vigorInicial, int habilidad, int punteria){

super(vida, fuerza, inteligencia, astucia, vigorInicial);

this.habilidad = habilidad;

this.punteria= punteria;

guerrerosCreados++;

}

 

//Nos ahorraríamos bastante código si el método imprimir de la clase Personaje estuviera ya implementado, ya que los valores comunes no nos haría falta ponerlo y se pondría solo super.imprimir();

public void imprimir(){

System.out.println(“Vida: “+getVida()+” Fuerza: “+getFuerza()+” Inteligencia: “+getInteligencia()+” Astucia: “+getAstucia()+” Vigor inicial: “+getVigorInicial()+” Habilidad: “+getHabilidad()+” Punteria: “+getPunteria()+” Numero de guerreros creados: “+getGuerrerosCreados);}

 

//Metodos get… al heredarlos de la clase personaje ponemos super.get…()

public int getVida(){

super.getVida();}

 

public int getFuerza(){

getFuerza();}

 

public int getInteligencia(){

getInteligencia();}

 

public int getAStucia(){

super.getVida();}

 

public int getVigorInicial(){

super.getVigorInicial();}

 

//Los tres métodos get… nuevos son:

public int getHabilidad(){

return(habilidad);}

 

public int getPunteria(){

return(punteria);}

 

public int getGuerrerosCreados(){

return(guerrerosCreados);}

 

//Metodos set… al heredarlos de la clase personaje ponemos super.set…()

public int setVida(int a){

super.setVida(a);}

 

public int setFuerza(int a){

super.setFuerza(a);}

 

public int setInteligencia(int a){

super.setInteligencia(a);}

 

public int setAstucia(int a){

super.setVida(a);}

 

public int setVigorInicial(int a){

super.setVigorInicial(a);}

 

//Los dos métodos set… nuevos son:

public int setHabilidad(int a){

a = habilidad;}

 

public int setPunteria(int a){

a = punteria;}}//Fin de la clase Guerrero

 

Interfaz Hechicero

public interface Hechicero{

public void doblaMagia();

public void doblaPoderLuz();

}

Clase Maga

//Esta clase hereda de la clase Personaje

public class Maga extends Personaje implements Hechicero{

 

//Definimos los atributos necesarios

private int magia;

private int poderLuz;

private static magasCreadas = 0;

 

//Constructor

public Maga (int vida, int fuerza, int inteligencia, int astucia, int vigorInicial, int magia,int poderLuz){

super(vida, fuerza, inteligencia, astucia, vigorInicial);

this.magia = magia;

this.poderLuz = poderLuz;

magasCreadas++;

}

 

 

//Nos ahorraríamos bastante código si el método imprimir de la clase Personaje estuviera ya implementado, ya que los valores comunes no nos haría falta ponerlo y se pondría solo super.imprimir();

public void imprimir(){

System.out.println(“Vida: “+getVida()+” Fuerza: “+getFuerza()+” Inteligencia: “+getInteligencia()+” Astucia: “+getAstucia()+” Vigor inicial: “+getVigorInicial()+” Magia: “+getMagia()+” Poder de la luz”+getPoderLuz()+” Numero de magas creadas: “+getMagasCreadas);}

 

//Métodos de la interfaz hechicero, no hace falta pasarles ningun parametro, ya que lo tienen en esta misma clase

public void doblaMagia(){

magia = magia*2;}

 

public void doblaPoderLuz(){

poderLuz = poderLuz*2;}

 

//Metodos get… al heredarlos de la clase personaje ponemos super.get…()

public int getVida(){

super.getVida();}

 

public int getFuerza(){

getFuerza();}

 

public int getInteligencia(){

getInteligencia();}

 

public int getAstucia(){

super.getVida();}

 

public int getVigorInicial(){

super.getVigorInicial();}

 

//Los tres métodos get…nuevos son:

public int getMagia(){

return(magia);}

 

public int getPoderLuz(){

return(poderLuz);}

 

public int getMagasCreadas(){

return(magasCreadas);}

 

 

//Metodos set… al heredarlos de la clase personaje ponemos super.set…()

public int setVida(int a){

super.setVida(a);}

 

public int setFuerza(int a){

super.setFuerza(a);}

 

public int setInteligencia(int a){

super.setInteligencia(a);}

 

public int setAstucia(int a){

super.setVida(a);}

 

public int setVigorInicial(int a){

super.setVigorInicial(a);}

 

//Los dos métodos set nuevos son:

public int setMagia(int a){

a = magia;}

 

public int setPoderLuz(int a){

a = poderLuz;}}//fin de la clase Maga

 

Clase Prueba

public class Prueba{

//Método personajeCambiado, se le pasa como parámetro el objeto al que se ha hecho el cambio, y por lo tanto imprimimos los nuevos datos de ese objeto

public void personajeCambiado(Personaje p){

System.out.println(“Un personaje ha sido cambiado, los nuevos valores son: “);

p.imprimir();

}

 

//Main, damos valor inicial al vigor (de la clase personaje) y creamos un objeto tipo Maga

public static void main (String [] args){

Personaje.setVigorInicial=0;

 

Maga maga1= new Maga(100, 100, 100, 100, 100, 100, 100);

}}

 

 

 

 

CONCEPTOS USADOS EN EL EJERCICIO 1

 

 

Los conceptos que se tocan en este ejercicio son los siguientes:

-         Herencia, con todo lo que ello supone, incluido sobreescritura de métodos en las clases que heredan

-         Modificadores de acceso

-         Interfaces