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

 

 

 

 

BEATRIZ GARCÍA

 

ENUNCIADO EJERCICIO 4

 

Hola,perdón por el retraso he tenido problemas con Internet.

 

En este ejercicio vamos a trabajar con JMF. A la hora de realizar el ejercicio para que sea un poco más fácil, vamos a suponer dos cosas:

 

• Si al reproducir un fichero de audio le pedimos al player que me dé la componente de video, el player devolverá null.
• Para ver cuanto tiempo dura la reproducción  de un fragmento de audio o de vídeo, lo vamos a realizar  reproduciendo dicho fragmento, sin visualizarlo, y por medios ajenos al JMF mediremos cuánto tiempo ha tardado en reproducirse.

 

Hechas estas suposiciones, se trata ahora de construir un programa que reciba como argumentos de entrada(por la línea de comandos) una lista de archivos de video y de audio indistintamente.

 

Al ejecutarse el programa, imprimirá por consola el título de cada archivo, el tipo de archivo(audio o video) y su duración.

 

Después de realizar eso, seleccionará el fragmento más corto de todos ellos(da igual que sea de audio o de video) y lo volverá a reproducirlo pero esta vez mostrándolo al usuario. Esta última reproducción tendrá que ser cíclica, es decir, cuando el fragmento termine, volverá a empezar desde el principio.

 

 

 

SOLUCIÓN EJERCICIO 4

 

   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.IOExceptión ;
   import   javax.media.* ;

 public class Reproductor extends JFrame implements ControllerListener, ActionListener{
  
      Player    player=null ;
      Component visualComponent=null;
      Component controlComponent=null;
      Component progressBar=null;
  
      int cont=0;
      Timer timer;
      static String archivo;
      int numVeces=1;
     public Reproductor(){
     
      this.getContentPane().setLayout(new BorderLayout());

      URL url=null;
      timer=new Timer(1000,this);
     
         try{
        
            if((url=new URL(archivo))==null){
            
               System.out.println(“ERROR”);
           
            }
            else{
           
               player=Manager.createPlayer(url);
               player.addControllerListener(this);
           
            }
        
        

 

         }catch(MalformedURLException e){
           
               System.out.println(“URL NO VÁLIDA”);
           
         }catch(IOException e){
           
        System.out.println(“EXCEPCIÓN DE                LECTURA/ESCRITURA”);
           
         }catch(NoPlayerException e){
           
           System.out.println(“NO EXISTE REPRODUCTOR”);
           
         }
     
         this.addWindowListener(new ManejadorVentana());
         player.start();
         timer.start();
     
      }
  
  
  public synchronized void ControllerUpdate(ControllerEvent event){
     
        
     
         if(player==null){
            System.out.println(“ERROR”);
            return ;
         }
     
 if(event instanceof RealizeCompleteEvent){
                   
            if((visualComponent=player.getVisualComponent())!=null){
              

}else{

 

return null;

 

 }
           
               

if((ControlComponent=player.getPanelComponent())!=null){
              
    this.getContentPane().add(“South”, controlComponent);

}
    validate();
 }else if(event instanceof EndOfMediaEvent){

       

 

    if(numVeces==2){

     player.setMediaTime(new Time(0)); 

 

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

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

}

validate();

  player.start();

  }else{

         numVeces++;
         player.setMediaTime(new Time(0));

         timer.stop();

         cont=0;
          }
           
  }else if(event instanceof ControllerErrorEvent){
               
         player=null;
              System.err.println(((ControllerErrerEvent)event).getMessage());
    }
      }
        
       }
  
  
  public void actionPerformed(ActionEvent event){
     
            cont++;
      }
        
    public static void main(String[]args){
     
      Reproductor reproductor=new Reproductor();
      reproductor.setSize(200,200);
      reproductor.setVisible(true);
        
       int minimaCont=args[0].cont;
     
      for(int i=0;i<args.length;i++){
         

         System.out.println(args[i]);
         System.out.println(args[i].cont);  

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

        

    System.out.println(“ARCHIVO DE VIDEO”);

 

}else{

 

System.out.println(“ARCHIVO DE AUDIO”);

 

}

        if(minimaCont==args[i].cont){
               archivo=args[i];

               player.start();
              
            }
            else if(minimaCont<args[i].cont){
               archivo=args[0];

               player.start();

            }
            else if(minimaCont>args[i].cont){
               archivo=args[i];

               player.start();

            }
         }
     
                 
        
      }
     
 
   public class ManejadorVentana extends WindowAdapter{
     
          public void windowClosing(WindowEvent e){
        
            if(player!=null){
           
               player.stop();
               player.deallocate();
            }
        
            System.exit(0);
        
         }
      }
   }

CONCEPTOS EJERCICIO 4

 

 

 

            En este último ejercicio los conceptos que se han tratado han sido:

 

-El concepto de JMF

-El concepto de interfaz gráfica(swing)

-El concepto de programación orientada a eventos

-El concepto del Timer

 

 

 

 

BEATRIZ GARCIA

 

ENUNCIADO EJERCICIO 3

En este ejercicio lo que hay que hacer es programar un pequeño juego que consiste en que el jugador debe mantener una pelota rebotando de pared en pared sin dejarla caer al suelo.

 

Para lograrlo, el jugador moverá una raqueta o pala o paleta(como se quiera llamar) en horizontal, a lo largo del borde inferior de la pantalla de juego.

 

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

 

A la hora de hacerlo hay que olvidarse 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 de la zona de juego que el jugador podrá mover de derecha a izquierda mediante las flechas correspondientes al teclado. Si la pelota llega a rebotar en la parte inferior(suelo), querrá decir que el jugador no logró interceptar la trayectoria de la pelota con la pala y se acabará la partida. Para completar un poco más el juego, en 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 raqueta.

 

Aquí se muestra un dibujo de la interfaz gráfica:

 

 

 

 

 

 

SOLUCIÓN EJERCICIO 3

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

public class Juego extends JFrame{
  
  private JPanel abajo,arriba;
  private JLabel rebotesPala;
  private int TAMAÑO=20;
  private int numRebotesPala=0;
  private JLabel tablero[][]= new JLabel[TAMAÑO][TAMAÑO];
  private Timer reloj;
  private  int x=19;
  private  int y=TAMAÑO/2;
  private  int xx=14;
  private  int yy=14;
  
  
 public Juego(){
        
  super();
  abajo= new JPanel();rebotesPala= new

  JLabel(“CONTADOR:”+Integer.toString(numRebotesPala));
  abajo.add(rebotesPala);
     
     
     
  arriba=new JPanel(new GridLayout(TAMAÑO,TAMAÑO));
  arriba.setSize(TAMAÑO*TAMAÑO,TAMAÑO*TAMAÑO);
     
  for(int i=0;i<TAMAÑO;i++){
     for(int j=0;j<TAMAÑO;j++){
           
         tablero[i][j]=new JLabel();
         tablero[i][j].setOpaque(true);
         tablero[i][j].setBackground(Color.BLACK);
         arriba.add(tablero[i][j]);
                          
           
        }
        }
     
      getContentPane().setLayout(new BorderLayout());
      getContentPane().add(arriba,BorderLayout.CENTER);
      getContentPane().add(abajo,BorderLayout.SOUTH);
      pintarJugador();
      pintarPelota();
        
    
    Manejadores manejador= new Manejadores();
    addKeyListener(manejador);
     
                
     reloj=new Timer(250,manejador);
     reloj.start();

      }
     
     public void pintarJugador(){
     
       for(int y=8;y<12;y++){
        
         tablero[x][y].setBackground(Color.WHITE);
        
       }
    }

  public void pintarPelota(){
     
     tablero[xx][yy].setBackground(Color.YELLOW);
        
        
   }
     
  public void visualizar(){
     
     setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     pack();
     setSize(635,400);
     setResizable(false);
     setVisible(true);
     
     
     
  }

 

 

  
     
class Manejadores extends KeyAdapter implements ActionListener {
     
 

public void KeyPressed(KeyEvent e){

     

int x=19;
    

 

 switch(e.getKeyCode()){
            
    case KeyEvent.VK_RIGHT:

         int numVeces=0;
         int j=0;
              
    if (tablero[x][j].getBackground() == Color.WHITE) {
                 
     if(numVeces<4){
           j++;  

           tablero[x][j].setBackground(Color.WHITE);                                                          
           numVeces++;
                     }
                  }
                  else{
           tablero[x][j].setBackground(Color.BLACK);
                  }
    case KeyEvent.VK_LEFT:

          

         int numVeces=0;
         int j=19;
              
    if (tablero[x][j].getBackground() == Color.WHITE) {
                  
     if(numVeces<4){
           j–;  

           tablero[x][j].setBackground(Color.WHITE);                                                          
           numVeces++;
      }
     }else{

           tablero[x][j].setBackground(Color.BLACK);
      }

    }
  }
          
         

public void actionPerformed(ActionEvent e){
        
   int w=19;
   int h=0;
         
        
     if(yy!=0){
           
        if(xx!=19){
              
             tablero[xx][yy].setBackground(Color.BLACK);
             xx–;
             yy–;
             tablero[xx][yy].setBackground(Color.YELLOW);
              
      }else if(xx==19&&tablero[xx][yy].getBackground()!=Color.WHITE ){
              
              
                  System.exit(0);
               
     }else

if(xx==18&&tablero[w][yy].getBackground()==Color.WHITE){
              
numRebotesPala++;               tablero[xx][yy].setBackground(Color.BLACK);
                  xx–;
                  yy++;
                  tablero[xx][yy].setBackground(Color.YELLOW);
                  reloj.start();
              
               }
           
            }
            else{
           
           
       reloj.stop();
                       
           
       tablero[xx][yy].setBackground(Color.BLACK);
       xx++;
       tablero[xx][yy].setBackground(Color.YELLOW);
       reloj.start();
               
            }
                      
       }
      }
  public static void main(String [] args){
        
      Juego juego= new Juego();
      juego.visualizar();
      }
   }
  

CONCEPTOS EJERCICIO 3

            En este tercer ejercicio los conceptos que se han tratado han sido:

 

-El concepto de interfaces gráficas(swing)

-El concepto de programación orientada a Eventos

-El concepto de arrays bidimensionales

 

 

 

BEATRIZ GARCÍA

EJERCICIO 2 ENUNCIADO

 

 

En este ejercicio vamos a crear una estructura de datos compleja como se muestra en la figura:

 

 

 

Cola:

 

 PRIMERO—-                                                         ——NULL                                  

NODO

 

 

 

 

 

En cada nodo se almacena  una pila:

 

 

 

 

Posición 1

Posición 2

. . .

Posición N

 

 

 

 

En cada posición de la pila se almacena un vector:

 

 

 

Posición 1

Posición 2

. . . . . . . . . . . . . . .

Posición N

 

 

 

 

Y en cada posición del vector se almacenará un número entero.

 

 

 

Primero hay que programar una cola utilizando para ello una lista enlazada, de esta manera conseguimos que la cola sea dinámica (da igual el número de elementos que insertemos, el límite está en la RAM del ordenador).

 

Esta cola debe incluir estos métodos:

 

·Encolar elementos (enqueue).

·Desencolar elementos (dequeue).

·Indicar si la cola está vacía.

·Imprimir por pantalla todos los contenidos de la cola.

 

Además, en la cola se almacenará solamente pilas, es decir, los elementos a encolar serán pilas, o lo que es lo mismo, cada nodo de la lista enlazada almacenará una pila.

Cada una de estas pilas, cuya clase también hay que programar, debe incluir 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.

 

 

La pila se implementará mediante un array (memoria estática).Cada una de estas pilas almacenará vectores, es decir, que almacenará un vector en cada posición de la pila.

 

 

 

NOTA: cuando se invoque al método imprimir de la cola implica imprimir cada una de las pilas almacenadas en ella y a su vez imprimir todos los vectores que almacena y también imprimir todos los objetos que estén guardados en cada vector uno debajo de otro considerando que dichos objetos serán números enteros.

 

 

EJERCICIO2 SOLUCIÓN  

 

 

CLASE COLALISTA

 

 

public class ColaLista {

 

private Nodo primero;

private int ultimo;

 

public ColaLista(){

 

primero=null;

ultimo= 0;

 

}

 

public void enqueue(Pila pila){

 

Nodo nodo=new Nodo(primero,pila);

Primero=nodo;

ultimo++;

 

}

 

public Pila dequeue(){

 

Nodo actual=primero;

 

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

actual=actual.dameSiguiente();

}

ultimo–;

return actual;

 

}

 

 

public boolean vacia(){

 

return primero=null;

 

}

 

 

 

 

 

 

 

public void imprimir(){

 

Nodo actual=primero;

 

while(actual!=null){

 

System.out.println(actual.damePila());

actual=actual.damePila();

 

}

 

 

}

 

 

}FIN CLASE COLALISTA

 

 

 

CLASE NODO

 

 

public class Nodo{

 

private Nodo siguiente;

private Pila pila;

 

public Nodo(Nodo siguiente, Pila pila){

 

this.siguiente=siguiente;

this.pila=pila;

 

}

 

 

public Nodo dameSiguiente{

 

return this.siguiente;

 

}

 

 

public Pila damePila(){

 

return this.pila;

 

}

 

 

public void ponNodo(Nodo siguiente){

 

this.siguiente=siguiente;

 

}

 

 

 

public void ponPila(Pila pila){

 

this.pila=pila;

 

}

 

}FIN CLASE NODO

 CLASE PILA

 

public class Pila{ 

 

private int numElementos;

private Vector elementosPila[];

private int indice;

 

public Pila(int numElementos){

 

this.numElementos=numElementos;

indice = -1;

elementosPila=new Vector [numElementos];

 

}

 

 

public void push(Vector v){

 

indice++;

elementosPila[indice]=v;

 

}

 

 

public Vector pop(){

 

Vector vector=elementosPila[indice];

indice–;

return vector;

 

}

 

 

public boolean vacia(){

 

return (indice = = -1);

 

}

 

 

 

public boolean llena(){

 

return (indice = = numElementos-1);

 

}

 

 

 

public void imprimir(){

 

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

 

 System.out.println(elementosPila[i]);

 

}

}

}FIN CLASE PILA

 

 

EJERCICIO 2 CONCEPTOS

 

            En este segundo ejercicio los conceptos que se han tratado han sido:

 

-El concepto de pila

-El concepto de cola

-El concepto de lista

-El concepto de vector

 

 

 

 

 

 

 

 

 

 

 

 

 

BEATRIZ GARCÍA VIZUETE

ENUNCIADO EJERCICIO 1

Consiste en crear un conjunto de clases que representen personajes de juegos de rol. Todos los atributos los vamos a considerar de tipo int. Hay que crear cuatro clases y una interfaz.

 

Clase Personaje: es la clase base, que contiene las características generales. De esta clase no se podrán crear instancias.

-Atributos: vida del personaje, fuerza, inteligencia, astucia, vigor inicial(tiene el mismo valor para todos los personajes, es decir, si alguno cambia su vigor, el nuevo valor cambia para todos).

-Métodos: tiene un método imprimir sin implementar(las clases derivadas están obligadas a redefinirlo), tiene sus correspondientes métodos de acceso a los atributos en el que deberán notificar al método personajeCambiado(Personaje)del objeto que creó el personaje cada cambio que se produzca en la información del personaje y por último tiene varios constructores donde se inicializa la información del personaje y deberá tomar nota del objeto que los llamó.

 

Clase Guerrero: es una clase derivada de la clase base Personaje, es decir, que tiene los mismos atributos y métodos que la clase Personaje y además añade la siguiente información:

-Atributos: habilidad, puntería y una variable que lleva la cuenta de cuantos guerreros hay en cada momento.

-Métodos: tiene un método para imprimir toda la información del personaje.

 

Clase Maga: es una clase derivada de la clase base Personaje, es decir, que tiene los mismos atributos y métodos que la clase Personaje y además añade la siguiente información:

-Atributos: magia, poder de la luz y una variable que lleva la cuenta de cuantas magas hay en cada momento.

-Métodos: tiene un método para imprimir toda la información del personaje.

Pero además, esta clase debe implementar la interfaz Hechicero, es decir, implementar los dos métodos que tiene en este caso.

 

Clase Prueba: esta clase contiene el método main que dará un valor inicial al vigor de los personajes y creará una maga. Esta clase también debe incluir un método personajeCambiado(Personaje) que imprime por pantalla las características del personaje cambiado.

 

Interfaz Hechicero: como se ha dicho antes esta interfaz contiene dos métodos: doblar magia y doblar poder de la luz.

 

SOLUCIÓN  EJERCICIO 1

CLASE PERSONAJE

 

public abstract class Personaje{

 

private int vidas;

private int fuerza;

private int inteligencia;

private int astucia;

public static int vigorInicial;

private Prueba p;

 

public Personaje(){

 

}

public Personaje(int vidas, int fuerza, int inteligencia, int astucia, int vigorInicial, Prueba p){

 

this.vidas=vidas;

this.fuerza=fuerza;

this.inteligencia=inteligencia;

this.astucia=astucia;

this.vigorInicial=vigorInicial;

this.p=p;

}

 

public int dameVidas(){

return this.vidas;

}

 

public void ponVidas(int vidas){

this.vidas=vidas;

p.personajeCambiado(Personaje);

 

}

 

public int dameFuerza(){

return this.fuerza;

}

 

public void ponFuerza(int fuerza){

this.fuerza=fuerza;

p.personajeCambiado(Personaje);

 

}

public int dameInteligencia(){

return this.inteligencia;

}

public void ponInteligencia(int inteligencia){

this.inteligencia=inteligencia;

p.personajeCambiado(Personaje);

 

}

public int dameAstucia(){

return this.astucia;

}

 

public void ponAstucia(int astucia){

this.astucia=astucia;

p.personajeCambiado(Personaje);

 

}

 

public int dameVigorInicial(){

return this.vigorInicial;

}

 

public void ponVigorInicial (int vigorInicial){

this.vigorInicial=vigorInicial;

p.personajeCambiado(Personaje);

 

}

 

public abstract void imprimir();

 

} FIN CLASE PERSONAJE

 

 

 

 

 

CLASE GUERRERO

 

public class Guerrero extends Personaje{

 

private int habilidad;

private int punteria;

private int numGuerreros;

 

public Guerrero(){

super();

habilidad=0;

punteria=0;

numGuerreros++;

 

}

 

 

public Guerrero(int vidas, int fuerza, int inteligencia, int astucia, int vigorInicial, Prueba p , int habilidad, int punteria, int numGuerreros){

 

super(vidas,fuerza,inteligencia,astucia,vigorInicial,p);

this.habilidad=habilidad;

this.punteria=punteria;

this.numGuerreros=numGuerreros;

}

public int dameHabilidad (){

return this.habilidad;

}

 

public void ponHabilidad (int habilidad){

this.habilidad = habilidad;

}

 

 

public int damePunteria (){

return this.punteria;

}

 

public void ponPunteria(int punteria){

this.punteria=punteria;

}

 

 

public int dameNumGuerreros(){

return this.numGuerreros;

}

 

public void ponNumGuerreros(int numGuerreros){

this.numGuerreros=numGuerreros;

}

 

public void imprimir(){

 

System.out.println(“Vidas:” + vidas);

System.out.println(“Fuerza:” + fuerza);

System.out.println(“Inteligencia:” + inteligencia);

System.out.println(“Astucia:” + astucia);

System.out.println(“Vigor Inicial:” + vigorInicial);

System.out.println(“Habilidad:” + habilidad);

System.out.println(“Punteria:” + punteria);

System.out.println(“Numero de Guerreros:” + numGuerreros);

 

}

}FIN CLASE GUERRERO

 

 

 

 

CLASE MAGA

 

public class Maga  extends Personaje implements Hechicero{

 

private int magia;

private int poderLuz;

private int numMagas;

 

public Maga(){

super();

magia=0;

poderLuz=0;

numMagas++;

 

}

 

public Maga(int vidas, int fuerza, int inteligencia, int astucia, int vigorInicial, Prueba p, int magia, int poderLuz, int numMagas){

 

super(vidas,fuerza,inteligencia,astucia,vigorInicial,p);

this.magia=magia;

this.poderLuz=poderLuz;

this.numMagas=numMagas;

}

 

public int dameMagia (){

return this.magia;

}

 

public void ponMagia (int magia){

this.magia= magia;

}

 

 

public int damePoderLuz(){

return this.poderLuz;

}

 

public void  ponPoderLuz(int poderLuz){

this.poderLuz=poderLuz;

}

 

 

public int dameNumMagas(){

return this.numMagas;

}

public void ponNumMagas(int numMagas){

this.numMagas=numMagas;

}

public void doblarMagia(int magia){

 

this.magia=magia*2;

 

}

 

 

public void doblarPoderLuz(int poderLuz){

 

this.poderLuz = poderLuz*2;

 

}

 

 

public void imprimir(){

 

System.out.println(“Vidas:” + vidas);

System.out.println(“Fuerza:” + fuerza);

System.out.println(“Inteligencia:” + inteligencia);

System.out.println(“Astucia:” + astucia);

System.out.println(“Vigor Inicial:” + vigorInicial);

System.out.println(“Magia:” + magia);

System.out.println(“Poder de la Luz:” + poderLuz);

System.out.println(“Numero de Magas:” + numMagas);

 

}

 

}FIN CLASE MAGA

 

 

 

 

 

 

 

 

INTERFAZ HECHICERO

 

public interface Hechicero{

 

public void doblarMagia(int magia);

public void doblarPoderLuz(int poderLuz);

 

 

}FIN INTERFAZ HECHICERO

 

 

 

 

 

CLASE PRUEBA

 

 

public class Prueba{

 

public static void main (String [] args){

int vigorInicial = 5;

Personaje.vigorInicial=vigorInicial;

Prueba p=new Prueba();

Maga mago = new Maga(5,2,4,4,vigorInicial,p,7,6,1);

 

}

public void personajeCambiado(Personaje){

Personaje.imprimir();

 

}

 

}FIN CLASE PRUEBA

 

 

 

 

 

 

 

CONCEPTOS EJERCICIO 1

 

En este primer ejercicio los conceptos que se han tratado han sido:

 

-El concepto de herencia forzada(abstract)

-El concepto de interfaz.

-Elementos de clase(static)

.Uso de atributos e  invocación de métodos