Aqui os lo dejo:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.lang.String;
import java.net.URL;
import java.net.MalformedURLException;
import java.io.IOException;
import javax.media.*;
//Clase reproductor
public class Reproductor extends JFrame implements ActionListener, ControllerListener{
String archivo;
Player player=null;
URL url=null;
Component componenteVisual=null;
Component componenteControl=null;
Component barraProgreso=null;
int contador;
Timer timer;
int num=0;
static boolean parado;
static int duracion;
static int []array;
int a=0;

public Reproductor(String archivo){
parado=false;
contador=0;
this.archivo=archivo;
array=new int[2];//No se hacerlo con un array de longitud indeterminada, le tengo que dar un valor
timer=new Timer(1000, this);
getContentPane().setLayout(new BorderLayout());

try{

if((url=new URL(archivo))==null){
System.err.println(“No se puede crear Url para el archivo”);
}
else{
player=Manager.createPlayer(url);
player.addControllerListener(this);
}
}
catch(MalformedURLException e){
System.out.println(“Url no valida”);
}
catch(IOException e){
System.out.println(“Excepción de lectura/escritura”);
}
catch(NoPlayerException e){
System.out.println(“No existe reproductor”);
}

player.start();
timer.start();
addWindowListener(new EscuchadorVentana());
}

public void actionPerformed(ActionEvent e){
//Va contando los segundos de cada video
contador++;
}

public Player damePlayer(){
return player;
}

public synchronized void controllerUpdate(ControllerEvent e){

if(player==null){
return ;
}
if(e instanceof RealizeCompleteEvent){
if((componenteVisual=player.getVisualComponent())!=null){
this.getContentPane().add(“Center”, componenteVisual);
}

if((componenteControl=player.getControlPanelComponent())!=null){

this.getContentPane().add(“South”, componenteControl);
}
validate();
}

else if(e instanceof EndOfMediaEvent){
player.setMediaTime(new Time(0));

//Supuestamenete este evento captura cuando la reproducción termina, por eso paro el timer.
timer.stop();
/*Mi idea es almacenar los tiempos en un array, el que primero termine se almacenará en la posición 0 y así sucesivamente. Entonces luego solo tendré que reproducir es que se encuentre en la primera posición(el de menor duración).*/
array[a]=dameTiempo();

//El siguiente que termine se almacenará en la posición 1
a++;

//La variable parado nos indica cuando ha terminado una reproducción
parado=true;
}

else if(e instanceof ControllerErrorEvent){
player=null;
System.err.println(((ControllerErrorEvent)e).getMessage());
}
}

public int dameTiempo(){
return contador;
}

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

public void temp(){
if((componenteVisual=player.getVisualComponent())!=null){
System.out.println(“Este archivo contiene video”);
}
else {
System.out.println(“Este archivo solo contiene audio”);
}
}

//Main
public static void main (String[]args){
Reproductor r;

//Lo que intento hacer es crear varios objetos a la vez para que se vayan reproduciendo simultaneamente
for (int i=0;i<args.length;i++){
r=new Reproductor(args[i]);

/* No podremos entrar en este if, hasta que la variable parado no esté a true, es decir, hasta que el
video haya terminado de reproducirse.*/
if(parado==true){
int durMin=r.dameTiempo();
System.out.println(“Título: “+args[i]+” Duracion: “+durMin);
r.temp();
}
parado=false;//Para que el siguiente video no entre en el if antes de tiempo

/*Comprobamos que el tiempo de este reproductor coincide con el de la primera posición y lo reproducimos
aunque los de mayor duración sigan reproduciendose sin visualización, cuando hayan terminado se mostrara su titulo, tipo de archivo etc…*/
if(r.dameTiempo()==array[0]){
r.setSize(500,500);
r.setVisible(true);
r.damePlayer().start();
}

}
}
}//fin clase

Por si no ha quedado muy claro, mi idea era que al introducir los titulos de las pistas, todas se empezaran a reproducir a la vez sin visualizar y sin sonido (el sonido he sido incapaz de quitarlo, asi que sonaban todas a la vez…), y en cuanto la más corta terminara volver a reproducirla visualizándola. Cuando fueran terminando las demás se daría su título, duración y resto de requisitos que nos pedían en el enunciado.

El caso es que si que se reproducen todas a la vez pero no llega a dar las características del video, cuando van terminando las reproducciones el programa se queda parado y no hace nada.

Espero que alguno de vosotros pueda ayudarme, que llevo muuuuchos días quebrándome la cabeza!!

Un saludo!

Lo que nos proponen en este ejercicio es crear una especie de arkanoid pero bastante más sencillo, esto es:

Hay una zona de juego formada por cuatro paredes y una barra encima de la pared inferior.  Entre estas cuatro paredes hay una pelota que va rebotando entre pared y pared. El juego consiste en evitar que la pelota que va moviendose por la zona de juego no toque la pared inferior, para conseguir esto tendremos que mover la barra de derecha a izquierda con el teclado.

Al iniciar el juego la pelota empieza a moverse, cada vez que rebote contra nuestra barra acumulamos un punto. Debe haber un marcador fuera de la zona de juego que nos vaya indicando cuantos puntos llevamos acumulados.

El enunciado del ejercicio está claro, lo único que no especifica, y por lo tanto podemos elegir, es la dirección que tiene que llevar la pelota (si tiene que ir siempre en la misma, si tiene que cambiar…) que por mi parte ha sido lo que más me ha dificultado terminar el juego.

La implementación es la siguiente:

CLASE ARKANOID

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

//Clase Arkanoid
public class Arkanoid extends JFrame implements KeyListener, ActionListener{

JPanel panel1, panel2, panel3, panel4, panel5;
JLabel zonajuego[][];
JLabel marcador;
Container contenedor;
int contador=0;
int X=30;
int Y=20;
Timer timer;
int pos1,pos2,pos3;
int a,b;
int movanterior=1;

public Arkanoid(){
super(“Arkanoid cutre”);

//Creamos el panel del marcador
panel1=new JPanel();
panel5=new JPanel();
panel3=new JPanel();
panel4=new JPanel();
marcador=new JLabel(“Tienes “+Integer.toString(contador)+” puntos”);
panel1.add(marcador);

//Creamos el panel de juego
panel2=new JPanel();
panel2.setLayout(new GridLayout(X,Y));
zonajuego= new JLabel[X][Y];

for (int i=0;i<zonajuego.length;i++){
for (int j=0;j<zonajuego[i].length;j++){
zonajuego[i][j]=new JLabel();
zonajuego[i][j].setOpaque(true);
zonajuego[i][j].setBackground(Color.BLUE);
panel2.add(    zonajuego[i][j]);
}
}

//Añadimos al panel de contenido
contenedor=getContentPane();
contenedor.setLayout(new BorderLayout());
contenedor.add(panel1, BorderLayout.NORTH);
contenedor.add(panel2, BorderLayout.CENTER);
contenedor.add(panel3, BorderLayout.EAST);
contenedor.add(panel4, BorderLayout.WEST);
contenedor.add(panel5, BorderLayout.SOUTH);

//Barra que se mueve
pos1=Y/2;
pos2=(Y/2)+1;
pos3=(Y/2)-1;
zonajuego[X-2][pos1].setBackground(Color.BLACK);
zonajuego[X-2][pos2].setBackground(Color.BLACK);
zonajuego[X-2][pos3].setBackground(Color.BLACK);

//Pelota
a=2;
b=Y/3;
zonajuego[a][b].setBackground(Color.YELLOW);

//Añadimos evento
this.addKeyListener(this);

//Timer
timer = new Timer(100, this);
timer.start();
}

//Metodo que nos devuelve true si la pelota choca con la barra
public boolean barra(){
if(zonajuego[a][b]==zonajuego[X-3][pos1]||zonajuego[a][b]==zonajuego[X-3][pos2]||zonajuego[a][b]==zonajuego[X-3][pos3]){
return true;
}
else{
return false;
}
}

//Implementamos actionPerformed de la interfaz ActionListener
public void actionPerformed(ActionEvent e){
if(a==0){
zonajuego[a][b].setBackground(Color.BLUE);
if(b==(Y-1)){
movanterior=5;
}
else{
a+=1;
int aleatorio=(int)((Math.random()*10)%2)+1;
switch(aleatorio){
case 1:b++; movanterior=1;
break;
case 2:b=b-1;movanterior=5;
break;}
zonajuego[a][b].setBackground(Color.YELLOW);
}
}

if(b==0){
zonajuego[a][b].setBackground(Color.BLUE);
if(a==0){
movanterior=1;
}
else{
b=b+1;
if((movanterior==3)||(movanterior==8)){
a=a-1;movanterior=4;
}
else if((movanterior==5)||(movanterior==2)){
a+=1;
movanterior=6;
}
zonajuego[a][b].setBackground(Color.YELLOW);
}
}

if(b==(Y-1)){
zonajuego[a][b].setBackground(Color.BLUE);
b=b-1;
if((movanterior==1)||(movanterior==6)){
a+=1;
movanterior=2;
}
else if((movanterior==7)||(movanterior==4)){
a=a-1;
movanterior=8;
}
zonajuego[a][b].setBackground(Color.YELLOW);
}

if(barra()){
contador++;
zonajuego[a][b].setBackground(Color.BLUE);
a=a-1;
int aleatorio=(int)((Math.random()*10)%2)+1;
switch(aleatorio){
case 1:b++;movanterior=7;
break;
case 2:b=b-1;movanterior=3;
break;}
zonajuego[a][b].setBackground(Color.YELLOW);
marcador.setText(“PUNTOS: “+Integer.toString(contador));
}

if((movanterior==6)&&(!barra())){
zonajuego[a][b].setBackground(Color.BLUE);
a+=1;
b+=1;
zonajuego[a][b].setBackground(Color.YELLOW);
}

if((movanterior==5)&&(b>0)){
zonajuego[a][b].setBackground(Color.BLUE);
a+=1;
b=b-1;
zonajuego[a][b].setBackground(Color.YELLOW);
}

if((movanterior==1)&&(b<Y)){
zonajuego[a][b].setBackground(Color.BLUE);
a+=1;
b+=1;
zonajuego[a][b].setBackground(Color.YELLOW);
}

if((movanterior==7)&&(b<Y)){
zonajuego[a][b].setBackground(Color.BLUE);
a=a-1;
b+=1;
zonajuego[a][b].setBackground(Color.YELLOW);
}

if((movanterior==2)&&(!barra())){
zonajuego[a][b].setBackground(Color.BLUE);
a+=1;
b=b-1;
zonajuego[a][b].setBackground(Color.YELLOW);
}

if((movanterior==8)&&(a>0)){
zonajuego[a][b].setBackground(Color.BLUE);
a=a-1;
b=b-1;
zonajuego[a][b].setBackground(Color.YELLOW);
}

if((movanterior==3)&&(b>0)){
zonajuego[a][b].setBackground(Color.BLUE);
a=a-1;
b=b-1;
zonajuego[a][b].setBackground(Color.YELLOW);
}

if((movanterior==4)&&(a>0)){
zonajuego[a][b].setBackground(Color.BLUE);
a=a-1;
b+=1;
zonajuego[a][b].setBackground(Color.YELLOW);
}

if(a==X-1){
marcador.setText(“FIN DEL JUEGO”); //System.exit(0);

}
}
//Implementamos los siguientes métodos de la interfaz KeyListener

public void keyPressed(KeyEvent e){
switch(e.getKeyCode()){
case KeyEvent.VK_LEFT:
if(pos3!=0){
zonajuego[X-2][pos2].setBackground(Color.BLUE);
zonajuego[X-2][pos3-1].setBackground(Color.BLACK);
pos1=pos1-1;
pos2=pos2-1;
pos3=pos3-1;
break;
}
else{
break;
}

case KeyEvent.VK_RIGHT:
if(pos2!=Y-1){
zonajuego[X-2][pos2+1].setBackground(Color.BLACK);
zonajuego[X-2][pos3].setBackground(Color.BLUE);
pos1=pos1+1;
pos2=pos2+1;
pos3=pos3+1;
break;
}
else{
break;
}
}
}

public void keyTyped(KeyEvent e){
e.consume();
}

public void keyReleased(KeyEvent e){
e.consume();
}

//Main
public static void main(String[]args){
Arkanoid a=new Arkanoid();
a.setSize(350,450);
a.setVisible(true);
a.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

}//Fin Clase

CONCEPTOS FUNDAMENTALES

Con este ejercicio hemos repasado conceptos de Swing y eventos. A diferencia de los anteriores, este ejercicio no especifica tanto cómo tenemos que hacerlo dándonos algo mas de libertad a la hora de plantearlo y buscar la forma de resolverlo.

Aún así, creo que el juego estaba enfocado a aclararnos conceptos de Swing( manejar ventanas, paneles, etiquetas…), y entender bien los eventos; con la creación del Timer vemos el uso de la interfaz ActionListener y la implementación del método actionPerformed, que es el que nos ha permitido que la pelota se mueva y rebote como nosotros le indiquemos. Para el movimiento de la barra utilizamos la interfaz KeyListener. Mediante los métodos keyPressed, keyTyped y keyReleased (los que hay que implementar obligatoriamente) hemos conseguido que la barra se mueva de izquierda a derecha, dandole la orden mediante el teclado.

En cuanto a los algoritmos que hay que plantear para resolver este ejercicio, creo que la dificultad ha sido mayor. Quizás los movimientos de la pelota era lo que más podía dificultar el juego.

Un saludoooo!!

Tenemos que crear una cola (con su política de inserción/obtención FIFO), implementada mediante una lista enlazada (lista con memoria dinámica). Esta cola debe almacenar pilas (LIFO), en este caso implementadas mediante un array. En cada posición de este array debe haber un vector(memoria dinámica) que almacene enteros.

Nos piden implementar los siguientes métodos en la clase pila: introducir un vector, extraer un vector, indicar si está vacía, indicar si está llena e imprimir; y los siguientes métodos en la clase cola: encolar una pila, desencolar una pila, indicar si está vacía e imprimir.

Lo que hay que conseguir es que llamando al método imprimir de la clase cola, éste imprima todas las pilas que contiene, los vectores que contiene cada pila y los enteros que contiene cada vector.

La implementación es la siguiente:

CLASE VECTOR DE ENTEROS

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

public class VectorEnteros {
//vector que va a guardar los enteros
private Vector vectorenteros;
/*Por simplicidad creamos un array que contenga inicialmente los enteros que queremos guardar.
Si queremos modificar el vector, solo hay que modificar el array correspondiente en la clase Prueba*/
private int numeros[];

public VectorEnteros(){
//Creo el vector
vectorenteros=new Vector();
}

public void añadir(int n[]){
numeros=n;
for (int i=0;i< numeros.length; i++){
Integer num=new Integer(numeros[i]);
vectorenteros.addElement(num);
}
}

public void imprimir(){
Enumeration e=vectorenteros.elements();
while(e.hasMoreElements()){
//Hay que hacer cambio de tipo
Integer entero=(Integer)e.nextElement();
System.out.print(entero+” “);
}
System.out.println(“”);

}
}//Fin clase

CLASE PILA

//Clase Pila implementada como array en la que se almacenan vectores de enteros. Observar que se cumple LIFO

public class Pila{
private int numElementos;
private VectorEnteros elementos[];
private int indice;

public Pila(int numElementos){
this.numElementos=numElementos;
indice=-1;
elementos= new VectorEnteros[numElementos];
for(int i=0; i<numElementos;i++){
elementos[i]=new VectorEnteros();
}
}

public int vacia(){
return(indice =-1);
}
public int llena(){
return (indice=numElementos-1);
}

public void push(VectorEnteros v){
indice++;
elementos[indice]=v;
}

public VectorEnteros pop(){
VectorEnteros v= elementos[indice];
indice–;
return v;
}

public void imprimir(){
int j=0;
for (int i=elementos.length-1;i>=0;i–){
System.out.print(“Vector “+(j+1)+”\t”);
elementos[i].imprimir();
j++;
}
System.out.println(“”);

}
}//Fin clase

CLASE NODO

//Clase nodo para implementar posteriormente la cola dinámica

public class Nodo{
public Nodo siguiente;
public Pila pila;

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

public Nodo(Pila p, Nodo sig){
pila=p;
siguiente=sig;
}

public Nodo siguiente(){
return siguiente;
}
public Pila elemento(){
return pila;
}
public void actualizarPila(Pila p){
pila=p;
}
public void actualizarSiguiente(Nodo sig){
siguiente=sig;
}
}//Fin clase

CLASE COLA

//Clase Cola implementada como lista dinámica en la que se almacenan pilas. Observar que se cumple FIFO

public class Cola{
private Nodo primero;
private Nodo ultimo;

public Cola(){
primero = null;
ultimo = null;
}

public boolean vacia(){
return (primero == null);
}

public void encolar(Pila p){
Nodo nuevo = new Nodo(p,null);

if(vacia())
primero = nuevo;
else
ultimo.siguiente = nuevo;
ultimo = nuevo;
}

public Pila desencolar(){
if(vacia()){
System.err.println(“No hay elementos en la cola\n”);
return null;
}
else{
Pila p = primero.pila;
primero = primero.siguiente;
if(vacia()){
ultimo = null;
}
return p;
}
}

public void imprimir(){
int j=1;

if(!vacia()){
System.out.println(“CONTENIDO DE LA COLA\n”);

while(!vacia()){
System.out.println(“Pila “+j+”: \n”);

Pila p = primero.pila;
primero = primero.siguiente;

ultimo = null;
p.imprimir();
j++;
}
System.out.println(“\n”);
}
else{
System.out.println(“ESTA COLA ESTÁ VACÍA”);
System.out.println(“\n\n”);
}
}
}//Fin clase

CLASE DE PRUEBA

public class Prueba{
public static void main(String[]args){

//creamos nuestros arrays de enteros
int array1[]= {1,2,3,4,5,6,7};
int array2[]= {1,2,3,4};
int array3[]= {1,2};
int array4[]= {1,2,3,4,5,6,7,8,9,10};
int array5[]= {1};
int array6[]= {1,2,3,4,5};
int array7[]= {1,2,3,4,5,6};

//rellenamos los vectores
VectorEnteros v1=new VectorEnteros();v1.añadir(array1);
VectorEnteros v2=new VectorEnteros();v2.añadir(array2);
VectorEnteros v3=new VectorEnteros();v3.añadir(array3);
VectorEnteros v4=new VectorEnteros();v4.añadir(array4);
VectorEnteros v5=new VectorEnteros();v5.añadir(array5);
VectorEnteros v6=new VectorEnteros();v6.añadir(array6);
VectorEnteros v7=new VectorEnteros();v7.añadir(array7);

//creamos una pila con los 7 vectores de enteros
Pila p1=new Pila(7);
p1.push(v1);
p1.push(v2);
p1.push(v3);
p1.push(v4);
p1.push(v5);
p1.push(v6);
p1.push(v7);

//creamos varias pilas para almacenar en la cola y hacer pruebas con ellas
Pila p2=new Pila(7); p2=p1;
Pila p3=new Pila(7); p3=p1;
Pila p4=new Pila(7); p4=p1;
Pila p5=new Pila(7); p5=p1;
Pila p6=new Pila(7); p6=p1;
Pila p7=new Pila(4); //cambiamos el orden y el tamaño
p7.push(v4);
p7.push(v2);
p7.push(v3);
p7.push(v1);

Cola c1=new Cola();
c1.encolar(p1);c1.encolar(p7);c1.encolar(p3);c1.encolar(p7);

Cola c2=new Cola();
c2.encolar(p7);c2.encolar(p6);c2.encolar(p5);

Cola c3=new Cola();
Cola c4=new Cola();

c4.encolar(p7);
c1.desencolar();

c1.imprimir();
c2.imprimir();
c3.imprimir();
c4.imprimir();
}
}//Fin clase

CONCEPTOS FUNDAMENTALES

En este ejercicio repasamos estructuras de datos tocando un poco todo lo que hemos dado durante el curso.

En el orden en que yo he ido haciendo el ejercicio, lo primero que he repasado es como crear una clase vector de enteros(con memoria dinámica); no es muy difícil si importamos la clase Vector que ya tenemos implementada (import java.util.Vector). El mayor problema que veo es a la hora de hacer los cambios de tipo, creo que es donde más metemos la pata… Hay que tener en cuenta que la clase Vector almacena una lista de elementos de tipo Object, o derivadas de ésta; en cualquier caso, estos elementos tienen que ser objetos. En nuestro caso, no podemos almacenar enteros como int(ya que es un tipo primitivo), tenemos que hacer un cambio de tipo a su clase envoltorio Integer para que funcione correctamente.

En la clase Pila repasamos el comportamiento de inserción y obtención de objetos LIFO. Básicamente trabajamos con arrays, con las NullPointerException y esas cosas que nos hacen la vida un poco más difícil…Esta parte desde mi punto de vista es la más sencilla ya que trabajamos con memoria estática, que es a lo que más acostumbrados estamos.

La clase Cola es la que más problemas me ha creado; no por no entender el comportamiento de una cola, sino por tener que implementarla como lista enlazada. He tenido que buscar más información sobre las listas enlazadas a parte de los apuntes para por fin lograr entenderlas. La clase Nodo es siempre igual, yo creo que he incluido métodos que no eran necesarios para nada, pero bueno…por si acaso! y en la clase cola, el método desencolar todavía no me queda claro del todo…

Para terminar he creado una clase Prueba donde como su nombre indica compruebo los métodos en los que más dudas tengo, y que todo funcione correctamente. Imagino que en algo habré metido la pata pero este ejercicio creo que lo he entendido bastante bien

El ejercicio consiste en crear un juego de personajes de rol donde tenemos que crear 4 clases y una interfaz:

·    Personaje: Recoge las características generales comunes a cualquier tipo de personaje. Habrá de programarse de forma que no se puedan crear instancias de esta clase. (Esta frase no deja claro lo que nos están pidiendo. Quizás poniendo que no se pueden crear objetos o directamente diciendo que se trata de una clase padre(asi ya indicamos que el ejercicio trata de herencia) abstracta, se entendería mejor.)
o    Información que deberá guardar como mínimo: vida del personaje, fuerza, inteligencia, astucia y vigor inicial: Esta característica tendrá en todo momento el mismo valor para todos los personajes, esto es, si alguno cambia su vigor, el nuevo valor cambiará para todos.(Lo que quiere decir, el atributo vigor tiene que ser estático, aunque la forma de explicarlo del enunciado también se entiende bien).
o    Métodos:
- Constructores varios: Además de inicializar la información del personaje, deberán tomar nota del objeto que los llamó, a fin poder llamarlo más tarde.(No termino de entender ni este apartado ni el siguiente)
- Métodos de acceso a la información: Estos métodos, además, 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.(Queda claro que tiene que ser abstracto)
·    Guerrero: Guardará la misma información y tendrá los mismos métodos que Personaje(es decir, guerrero hereda de la clase personaje), y además añadirá:
o    Información: habilidad, puntería y una variable que lleve la cuenta de cuantos guerreros hay en cada momento(un contador).
o    Métodos:
- Un método para imprimir por pantalla toda la información del personaje.
·    Maga:    Guardará la misma información y tendrá los mismos métodos que Personaje(también hereda de la clase Personaje), y además añadirá:
o    Información: Magia, poder de la luz y una variable que lleve la cuenta de cuantas magas hay en cada momento(otro contador).
o    Métodos:
-   Un método para imprimir por pantalla toda la información del personaje.
-    Esta clase deberá además implementar la interfaz “Hechicero”(tiene que implementar los métodos que contenga la interfaz hechicero ).
·    Interfaz Hechicero:
o    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.

CLASE PERSONAJE

//clase base Personaje, abstracta para que no se pueda instanciar.

public abstract class Personaje{
public int vida;
public int fuerza;
public int inteligencia;
public int astucia;
public static int vigor;//común a todos los personajes, por eso es estático

//Constructor
public Personaje(int vida, int fuerza, int inteligencia, int astucia, int v){
this.vida=vida;
this.fuerza=fuerza;
this.inteligencia=inteligencia;
this.astucia=astucia;
vigor=v;
}

//Método abstracto imprimir para implementar en clases derivadas
public abstract void imprimir();

//Métodos de acceso
public int dameVida(){
return vida;
}
public int dameFuerza(){
return fuerza;
}
public int dameInteligencia(){
return inteligencia;
}
public int dameAstucia(){
return astucia;
}
public int dameVigor(){

return vigor;
}

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

//Método estático para cambiar el vigor de todos los personajes
public static void ponVigor(int v){
vigor=v;
}

public void personajeCambiado(Personaje personaje){
ponVida(personaje.vida);
ponFuerza(personaje.fuerza);
ponInteligencia(personaje.inteligencia);
ponAstucia(personaje.astucia);
ponVigor(personaje.vigor);

}

}//Fin clase

CLASE GUERRERO

//Clase guerro que hereda de Personaje
public class Guerrero extends Personaje{
private int habilidad;
private int punteria;
private static int contadorguerreros=0;

//Constructor solo con los atributos de la clase base
public Guerrero(int vida, int fuerza, int inteligencia, int astucia,int vigor){
super (vida, fuerza, inteligencia, astucia,vigor);

}
//Constructor con todos los atributos
public Guerrero(int vida, int fuerza, int inteligencia, int astucia,int vigor,int habilidad, int punteria){
this(vida, fuerza, inteligencia, astucia,vigor);
this.habilidad=habilidad;
this.punteria=punteria;
contadorguerreros++;
}

//Metodo imprimir
public void imprimir(){
System.out.println(“Características del guerrero: \nVida:”+vida+”\nFuerza: “+fuerza+”\nInteligencia: “+inteligencia+”\nAstucia :” +astucia+”\nVigor :”+vigor+”\nHabilidad :”+habilidad+”\nPuntería :”+punteria+”\nNumero de Guerreros :”+contadorguerreros+”\n\n”);
}
}//Fin clase

CLASE MAGA

//Clase maga hereda de personaje e implementa la interfaz hechicero

public class Maga extends Personaje implements Hechicero{

private int magia;
private int poder;
private static int contadormagas=0;

//Constructor solo con los atributos de la clase base
public Maga(int vida, int fuerza, int inteligencia, int astucia, int vigor){
super (vida, fuerza, inteligencia, astucia, vigor);
}

//Constructor con todos los atributos
public Maga(int vida, int fuerza, int inteligencia, int astucia, int vigor, int magia, int poder){
this(vida, fuerza, inteligencia, astucia, vigor);
this.magia=magia;
this.poder=poder;
contadormagas++;
}

//Método imprimir
public void imprimir(){
System.out.println(“Características de la maga: \nVida:”+vida+”\nFuerza: “+fuerza+”\nInteligencia: “+inteligencia+”\nAstucia :”+astucia+”\nVigor :”+vigor+”\nMagia :”+magia+”\nPoder :”+poder+”\nNumero de Magas :”+contadormagas+”\n\n”);
}

//Implemento los métodos de la interfaz hechicero
public int doblarMagia(){
magia+=magia;
return magia;
}

public int doblarPoder(){
poder+=poder;
return poder;
}
}//Fin clase

INTERFAZ HECHICERO

public interface Hechicero {
public int doblarMagia();
public int doblarPoder();

}

CLASE PRUEBA

//Clase de prueba

public class Prueba{

public void personajeCambiado(Personaje personaje){
/*No hace falta
if(personaje instanceof Guerrero){
personaje.imprimir();
}
if(personaje instanceof Maga){
personaje.imprimir();
}*/
personaje.imprimir();
}

//main
public static void main(String[]args){
Prueba p1=new Prueba();

//damos valor inicial al vigor de todos los personajes
Personaje.vigor=10;

//creamos una maga y un guerrero
Guerrero g1=new Guerrero(1,2,3,4,500,5,6);
Maga m1=new Maga(4,5,6,7,900,8,9);

//imprimimos y vemos que el último vigor que se actualiza es el que se guarda para todos los personajes
p1.personajeCambiado(m1);
p1.personajeCambiado(g1);

//cambiamos el vigor
m1.ponVigor(2);

//vemos que el vigor cambia para ambos personajes
p1.personajeCambiado(m1);
p1.personajeCambiado(g1);
}
}

CONCEPTOS FUNDAMENTALES:

Los conceptos que sobre todo se repasan en este ejercicio son orientación a objetos y herencia.

Recordamos como implementar interfaces(que creo que estaba un poco olvidado), el uso de clases y métodos abstractos, o que indica la palabra static y que efecto tiene tanto en atributos como en métodos.

Aunque ayuda mucho recordar conceptos como los dichos anteriormente, sigo pensando que nuestro principal problema es “descifrar” el enunciado, pero bueno imagino que con algo de práctica lo conseguiremos, no?

La primera parte trata sobre el polimorfismo y la herencia, que no vamos a explicarla aquí ya que en la práctica está bastante bien explicado.

El primer ejercicio trataba sobre llamar al método de la superclase toSting() con la referencia super… ni idea!! Pero con la ayuda de otros compañeros y leyendo sus blogs,hemos conseguido entenderlo. Esto es bastante útil ya que no hace falta escribir el mismo método en cada una de las clases. Que menudo rollo…

El segundo ejercicio es sencillo de entender, ya que explica la funcionalidad de una interfaz (Almacenable) en la clase Clase.

A partir del tercer ejercicio, nos hemos liado bastante más, ya que de golpe, en la práctica nos pide usar unos métodos que no habíamos visto nunca y que no especifican en la misma.

En la clase ComponenteGrafico nos piden implementar el constructor (en el cual hay que incializar las variables que le pasamos como parámetros), y los métodos pintaFondo(), pintaBorde() y paint(). En los métodos pintaFondo() y pintaBorde(), hemos tenido que usar lo métodos setColor(), fillRect() y drawRect(), cosa que no teniamos ni idea y hemos tenido que acudir a las solución de la práctica.

En las clases Boton y Menu, más de lo mismo… buscando y buscando en API y con la cantidad de métodos que hay…no encontrábamos nada.

En la clase GUIContenedor hemos tenido que usar if e ir recorriendo el array, por eso nos ha resultado un poco más sencillo.

Con el resto de clases…otra vez los mismos problemas

Aun así, esta práctica tenía muy poca información sobre GUI, asi que habrá que estudiar más para entenderla!! Es una de las prácticas que nos queda pendiente por volver a hacer varias veces para que nos quede todo más claro.

La introdución explicativa del principio ayudó bastante sobre todo a los que no tenemos mucha idea de este tema. La parte teórica sobre jerarquía de clases (clases bases, subclases…) resultó bastante sencilla de entender.

En los ejercicios del 1 y 2, las clases Miembro y Atributo plantean practicamente los mismos problemas:  implementar el constructor y el método toString, teniendo en cuenta que una de las clases es clase base y otra es subclase. La parte “menos fácil” del primer ejercicio es la llamada al método toString de la clase Modificador, pero no nos supuso mucho problema. En este ejercicio se nos plantea la diferencia entre los modificadores de acceso private y protected. Según lo que vimos en el cuatrimestre anterior(si no me equivoco), cuando encotramos modificadores de tipo private el acceso a esos métodos, atributos…solo se puede hacer desde la propia clase, sin embargo con protected también se permite el acceso desde las subclases. En el ejercicio 2 se nos pregunta por la palabra super, que hemos utilizado durante toda la práctica para hacer referencia a los atributos de la clase base desde el constructor de las subclases.

En las clases Metodo y Constructor (donde constructor deriva de método), la única novedad son los parámetros, un array de objetos de la clase Parámetro, pero con algo de manejo en arrays tampoco resulta complicado. Una parte que si nos llevó más tiempo fue entender bien qué hacía la clase Parámetro, la diferencia entre String y StringBuffer y lo que hacía el método append(), pero nada que no se pueda solucionar con un poco de API

El apartado más difícil fue el 5; la clase Clase, donde juntamos todas las clases anteriores. Trabajamos con arrays, recordamos lo que es una interfaz y nos introdujo el operador instanceof (para comprobar que teneníamos dentro de cada posición del array miembros). Este ejercicio también se dificulta si intentas entender el contenido del paquete java.lang.reflect… además quita mucho tiempo.

Uno de los problemas que he visto en la práctica es no poder ir ejecutando cada uno de los ejercicios para comprobar que obteníamos lo que buscábamos, algo que a programadores novatos como nosotros ayuda mucho.

En general la práctica ha estado un poco desequilibrada, unos apartados bastante sencillos y algunos muy  liosos(a parte, como siempre, de lo largas que son…), pero por lo menos creo que ha conseguido aclararnos el tema de herencia, que era uno de los objetivos.

Hasta la próxima! xaooo

El ejercicio 0 es bastante simple y tampoco necesita mucho comentario, ya que es un ejercicio hecho en la primera práctica de RDA.

 El objetivo de la práctica consiste en tener un poco de conocimiento sobre la abstracción y encapsulación y saber obtener información sobre los “metadatos” en tiempo de ejecución.

No describiremos cada ejercicio ya que prácticamente todos se hacen de la misma forma. En las clases Metodo, Atributo y Constructor, debemos inicializar los valores de los atributos en su respectivo constructor, y en el método toString(), implementarlo de tal forma que nos devuelvan una cadena de caracteres con los datos de cada uno de ellos.

 En la clase Clase, se han creado tres arrays para almacenar en ellos los objetos de las clases Atributos, Métodos y Constructores . En sus métodos get, hemos recorrido estos arrays e invocado al método toString() para que nos devuelva la información(parecido al ejercicio anterior).

En AnalizadorObjeto es más de lo mismo…así que tampoco vamos a alargarnos mucho. Lo hemos comprendido bastante bien.

 Agur

En general me ha parecido bastante interesante porque te refresca la memoria en el tema de excepciones que ya lo teníamos un poco olvidado…pero quizás era demasiado larga para el tiempo que tenemos, a nosotras por lo menos no nos dio tiempo a terminarla

En el ejercicio 1 nos pide que trabajemos con el classpath. Este apartado no nos ha dado ningún problema, aunque en la práctica no explica muy bien su utilidad…si no nos equivocamos, debe especificar la ruta donde se tienen que buscar los archivos que tenemos que compilar y ejecutar.

En cuanto a las trazas de depuración y aserciones, creo que es algo que todos habíamos utilizado antes para saber donde están los errores pero que ninguno sabíamos como se llamaban. Es bastante útil para no perder mucho tiempo localizando fallos. Creo que la única duda de este ejercicio fue el tema de System.exit(1); no sabíamos muy bien porqué era un 1 pero consultando en otros blogs hemos encontrado la respuesta, así que asunto arreglado!

Sin duda el ejercicio 3 nos pareció el más complicado. Había que utilizar mucho el API. Las excepciones no era lo más difícil de entender, sino lo que hacían el InputStream, OutputStream, etc. Nos llevó bastante tiempo entender lo que nos pedían y tampoco no aclaró mucho de excepciones….por lo menos recordamos el try/catch un poco!

En el 4 hemos visto muchos tipos de excepciones que suelen salir muy a menudo ( y conviene evitar…). Es el la parte de la práctica que más nos ha ayudado.Es más fácil que el apartado anterior y aclara mucho las ideas,además, también nos recuerda otras cosas como los métodos parseInt, valueOf…que no deberíamos olvidar nunca

Un saludo!!!

Esta práctica consiste en un repaso de RDA, y bueno… repaso repaso no es, ya que no recordamos que esto se diese en RDA. En fín… nos dispusimos a empezar la práctica después de estar buscando un ordenador que funcionase, y con la ayuda del profesor, no nos pareció difícil.

También es verdad lo que dicen los profesores…hay que mirarse la práctica e intentar hacerla antes de ir a clase porque apenas da tiempo para hacer siquiera la mitad de ella. Asique lección aprendida :p