Jun
05
Bueno pues esta ya por fin, es la ultima y definitiva. Primero decir que esta práctica no nos ha parecido demasiado difícil de realizar, ya que con la amplia base que teníamos después de hacer el juego y otros cursos ya sabíamos de qué iba el tema. Ya sin más preámbulos os vamos a pasar a comentar como hemos realizado el reproductor.
Lo primero que hemos hecho ha sido crear una clase que implementase a ActionListener y a ControllerListener. No hemos extendido de JFrame para cambiar un poco el modo de utilizar las interfaces gráficas, aunque lo que hemos hecho simplemente ha sido crear un JFrame y “jugar” con él como veréis a continuación.
Ahí va el constructor comentado:
public Reproductor(){
ppal=new JFrame(“Reproductor”);
boton1=new JButton(new ImageIcon( “imagen1.jpg” ));
boton2=new JButton(new ImageIcon( “imagen2.jpg” ));
boton3=new JRadioButton( “Reinicio” ); //casilla de verificación, en caso de que se seleccione el video se reiniciara automáticamente al acabar su reproducción.
panel=new JPanel();
try{
url=new URL( “file:video.mpg” ); //lo hemos guardado en la misma carpeta
player=Manager.createPlayer(url);
player.addControllerListener(this);
} //sencillo no??
catch(Exception e){ //habíamos puesto más excepciones pero por no cansar…
System.exit(0);
}
ensamblar(); //método donde se añade los botones al panel y este al ppal //(JFrame), también se añade el escuchador a los botones y diversas chorradillas para //dejarlo bonito. Por último también le metimos player.realize() porque sino no no //se ve el Reproductor
}//constructor
Ya que hemos implementado ActionListener y ControllerListener, tenemos que usar a la fuerza los métodos actionPerformed y controllerUpdate.
public synchronized void controllerUpdate(ControllerEvent e){
if(e instanceof RealizeCompleteEvent){
visual=player.getVisualComponent();
control=player.getControlPanelComponent();
ppal.add( “Center” ,visual); //lo añade al centro del Frame
ppal.add( “South” ,control); //lo añade al sur del Frame
}
if(e instanceof EndOfMediaEvent){
if(boton3.isSelected()){
player.setMediaTime(new Time(0)); //lo pone al inicio del video, Time es float
player.start();
}
else{
player.stop();
player.deallocate(); //libera recursos
}
}
ppal.validate(); //muy importante para que se vea algo
} //controllerUpdate
public void actionPerformed(ActionEvent e){ //este es fácil
if(e.getSource()==boton1){
player.setMediaTime(new Time(6.0));
}
else if(e.getSource()==boton2){
player.setMediaTime(new Time(12.0));
}
} //actionPerformed
Os hemos puesto casi todo el código de nuestro Reproductor, para los que no supieseis como funciona JMF os pudieseis enterar de forma rápida y sencilla, y para los que ya supieseis por si queréis coger ideas, aunque no hay nada del otro mundo…
P.D: esperamos no escribir por aquí más después de este último y definitivo post, si seguimos escribiendo empezaros a preocupar seriamente por nosotros, porque sería un síntoma de que algo en nuestras vidas no iría nada bien…
Ultima cosa que decimos de nuestro gran amigo:
Chuck Norris ha contado hasta el infinito, 2 VECES.
Agur.
Jun
05
Bueno ya tenemos la penúltima práctica con la que ya casi estamos nuestro super post.
Lo que hemos hecho en esta práctica no ha sido demasiado porque nos hemos quedado sin tiempo de terminarla por completo, pero bueno eso no quería decir que por eso no subiésemos nada, así que por lo menos vamos a comentar lo que hemos hecho si os parece…
La clase Simple02GUI es relativamente fácil de realizar, os vamos a dejar nuestro código comentado para no perder la costumbre para que le echeis un vistazo, empezamos por el constructor, antes de nada decir que nuestra clase no extiende de ninguna clase ni implementa ninguna interfaz:
public Simple01GUI(){
frame= new JFrame( “Eventos” );
panel= new JPanel();
boton=new JButton( “Mi boton” );
etiqueta= new JLabel ( “cambiame el color” );
frame.add(panel);
panel.add(boton);
panel.add(etiqueta);
etiqueta.setOpaque(true); //para que se vea el nombre de la etiqueta al cambiarle el fondo
etiqueta.setBackground(Color.YELLOW);
OyenteBoton pulsaBoton=new OyenteBoton();
boton.addActionListener(pulsaBoton); //le añadimos la acción de ser pulsado
Enter teclado=new Enter();
boton.addKeyListener(teclado); //le añadimos la acción de pulsar el teclado
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);
frame.setVisible(true);
frame.setSize(200,100);
} //constructor
class OyenteBoton implements ActionListener {
public void actionPerformed(ActionEvent evento) {
if(etiqueta.getBackground()==Color.YELLOW){
System.out.println(Thread.currentThread().getName()); //devuelve el nombre del //evento que se produce en ese instante por consola
etiqueta.setBackground(Color.RED); //si la etiqueta es amarilla al ser pulsado el boton //cambia de color y en else al revés.
System.out.println(“Me has pulsado 
“); //imprime un mensaje en consola
}
else {
System.out.println(Thread.currentThread().getName());
etiqueta.setBackground(Color.YELLOW);
System.out.println(“Me has pulsado “);
}
}
} //ActionListener
Importante!!: Extendemos de KeyAdapter para poder implementar únicamente el método keyPressed, si implementásemos de KeyListener también tendríamos que implementar los metodos keyTyped() y keyReleased().
public class Enter extends KeyAdapter{
public void keyPressed(KeyEvent evento){
char e=evento.getKeyChar();
if(e==’\n’){ //si la tecla pulsada es enter hace lo mismo que en el método //actionPerformed, también se podría haber hecho con el metodo getKeyCode y utilizando //VK_ENTER en vez de ‘\n’
if(etiqueta.getBackground()==Color.YELLOW){
System.out.println(Thread.currentThread().getName());
etiqueta.setBackground(Color.RED);
System.out.println(“Me has pulsado “);
}
else {
System.out.println(Thread.currentThread().getName());
etiqueta.setBackground(Color.YELLOW);
System.out.println(“Me has pulsado “);
}
} //keyPressed()
} //KeyAdapter
La clase no logramos terminarla porque nos daba un error que no supimos resolver en el método public String query(int i), esto fue lo que le pasamos a este método:
String alumno=(String)alumnos.get(i);
throw new InterruptedException(“mete un NIA correcto”);
return alumno;
Seguro que es un fallo tonto pero no supimos arreglarlo, alumnos es un objeto Hashtable que se declara en el constructor de la clase.
Todo esto ha sido lo que hemos hecho de esta práctica, bueno también hicimos algo del siguiente ejercicio pero nada reseñable.
Para terminar y poco antes de colgar la última práctica, queríamos pedir perdón por la tardanza en subir muchos de los post, pero esto es debido a que también tenemos más asignaturas en las que también nos ‘exigen’ entregar semanalmente prácticas, ejercicios y demás… y también porque pensamos que ya que nos poníamos a subir post lo suyo sería que contuviesen información que fuese útil para todos y por supuesto también para nosotros, por lo que también nos llevaba un tiempo extra realizar cada uno de los post que hemos colgado en nuestro blog.
P.D: un saludo para esas personas que ven nuestro blog aunque no estén cursando la asignatura, y como no os dejamos con un par de cosillas de Chuck Norris:
Cuando Chuck Norris va a donar sangre no usa jeringuillas: Pide un cubo y un cuchillo.
Chuck Norris puede quemar una hormiga con una lupa… de noche.
Agur.
Jun
04
Practica10.
Buenas!! En esta y en la siguiente práctica os vamos a hablar un poco sobre threads, básicamente lo que nosotros sabemos y lo que como en las demás prácticas creemos que es más importante.
Vamos a empezar por comentar las diferencias entre las clases TwoThreads, TwoThreadsSimple y TwoThreadsSimple2.
En la clase TwoThreads, primeramente se crea un método (PrintThreadName()) que devuelve el nombre del proceso actual por pantalla, luego dentro del ‘main’ se crea un objeto de la interfaz Runnable en el que incluimos el método run() (indispensable al implementar esta interfaz), que lo que hace simplemente es invocar PrintThreadName().
Por último se crea un objeto de la clase Thread al que le pasamos como parámetro el objeto de la interfaz Runnable para que nos saque por pantalla el Thread que se esta ejecutando en ese momento. La ultima línea de código sirve para que imprima por pantalla donde se esta ejecutando el proceso actual, en nuestro caso en el ‘main’.
La clase TwoThreadsSimple implementa Runnable, por lo que esta obligada a crear el método run(), que como en el caso anterior invoca a PrintThreadName(). En el main de la clase crea un objeto de la misma clase y se lo pasa posteriormente a un objeto de Thread, como el objeto TwoThreadsSimple contiene los métodos run() y PrintThreadName() e implementa Runnable no hace falta llamar a los métodos de la clase.
**Como ejemplo también se hace lo mismo al crear un ActionListener y añadirle el escuchador, que para que funcione no hace falta llamar expresamente al método actionPerformed().
La última clase es la más sencilla de todas ya que extiende de Thread y esto hace todo más fácil. Simplemente crea los dos métodos de las anteriores clases y luego en el main crea un objeto de TwoThreadsSimple2, que como hereda de Thread solo con arrancarlo ya llama a los métodos de su clase tts2.start().
De las clases RaceCondition y RaceConditionSolved no vamos a comentar nada porque creemos que esta bien explicado n el guión y realmente tampoco lo entendíamos demasiado bien como para poder contaros algo sin liaros…
Para acabar os vamos a pasar a comentar como hemos hecho la clase StroboscopicGUI para que funcione como el ejecutable, realmente lo hemos hecho a ‘nuestra’ manera porque todavía no sabemos muy bien como utilizar procesos. Os dejamos comentado nuestro código para que le echéis un vistazo aunque como ya os decimos según dice la práctica no se debería hacer así pero es como nosotros sabemos y funciona!!!
public StroboscopicGUI(){
frame=new JFrame( “StroboscopicGUI” );
etiqueta1=new JLabel( “StroboscopicGUI” ,JLabel.CENTER);
panel=new JPanel();
frame.add(panel);
panel.setLayout(new BorderLayout());
panel.add(etiqueta1,BorderLayout.CENTER);
frame.setSize(200,200);
//setPack();
frame.setResizable(false);
frame.setVisible(true);
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);
try{
while(true){
etiqueta1.setOpaque(true);
etiqueta1.setForeground(Color.BLACK);
etiqueta1.setBackground(Color.WHITE);
Thread.sleep(100);
etiqueta1.setOpaque(true);
etiqueta1.setForeground(Color.WHITE);
etiqueta1.setBackground(Color.BLACK);
Thread.sleep(100);
}}
catch (InterruptedException e) {
System.out.println( “Interrupted while sleeping” );}
}
Lo del contador binario y demás os dejamos para que lo intentéis en casa, porque no os vamos a dar todo hecho…jeje. No en verdad no hemos tenido tiempo para “meterle mano” así que como referencia os recomendamos que os paséis por el blog de Jose y Marco’s que tienen algo explicado y os puede quedar un poco más claro.
Bueno y para acabar definitivamente en estas tres últimas prácticas os vamos a dejar con nuestro gran amigo Chuck Norris y sus actos celebres, ahí van las dos primeras:
Chuck Norris toma la sopa con tenedor.
Chuck Norris jugó a la ruleta rusa con un revolver completamente cargado y ganó.
May
30
Aquí os dejamos la memoria de nuestro juego (encima que la colgamos no es plan de que os copieis)
Memoria de la práctica de software del Juego de TSIOCA
- Fecha: 30-05-2008.
- Nombre del juego: “PAREJAS”.
- Autor 1: Juan Luís Campins Frau.
- Autor 2: Francisco José González León.
1.DIAGRAMA DE USO:
El juego que hemos realizado, es el de las ‘PAREJAS’, cuya interacción con el usuario es total, y es la que sigue:
-El usuario puede comenzar una partida del juego.
-Introducir/cambiar su nombre.
-Establecer un numero de intentos para resolver la pantalla, o de lo contrario un numero ilimitado de intentos.
-Puede cerrar la aplicación, es decir, acabar el juego.
-Iniciar una partida nueva, parando la que estaba en juego.
-Resolver el panel del juego que, a continuación, se iniciara una partida nueva.
-Ver los créditos del juego, para ver quienes son los autores.
2.DIAGRAMA DE CLASES:
La aplicación consta solamente de una clase, que es la principal, la cual inicializa el sistema, todos los componentes gráficos, todos los escuchadores de los distintos componentes gráficos como los JButton, JMenuItem…, es decir, que esta única clase realiza todas las funciones que el juego requiere y su ejecución.
3.DIAGRAMA DE FUNCIONAMIENTO:
La estructura del juego en marcha es la siguiente:
-Muestra de una pantalla inicial en la que se puede elegir 2 opciones: una la de salir, que saldrá de la aplicación, y otra la de jugar, que nos llevara a la pantalla principal del juego.
-Si hemos elegido la opción de jugar en la pantalla anterior, nos encontraremos con el tablero principal del juego, con los distintos botones y un menú en la parte superior de esta pantalla, todos ellos para su interacción. En esta pantalla se podrán elegir muchas opciones del juego, explicadas en el punto 1, solo añadir como dato, que una vez en el tablero principal, si se pulsa la tecla ENTER, en lugar de jugar con las imágenes de una determinada serie de TV, se jugarán con otras de una distinta serie.
4.DIAGRAMA DE DESPLIEGUE:
-Es necesario tener el classpath de JMF debido a que se reproducen distintos sonidos a lo largo del juego.
-El código fuente, y los distintos class no se encuentran en ninguna carpeta, solo las imágenes y sonidos que, mediante código java, se acceden a ellas, por lo que solo el zip hay que descomprimirlo y dejarlo como se encuentre.
-Para su ejecución, hay que ejecutar java Parejas.
-En nuestro blog se encuentra la memoria: http://losquintos.wordpress.com/.
May
22
Ya por fin, después del pequeño fallo técnico de colgar el post vacío sin darnos cuenta y de tener que volver hacerla entera, pues nada os vamos a comentar lo que nos ha parecido más significativo de esta práctica y lo que creemos os puede servir de ayuda.
Vamos a empezar directamente con el ejercicio de las etiquetas en blanco y negro que nos pareció interesante. El primer problema que tuvimos que solucionar mediante el API de java fue el de cambiar el nombre al panel mediante:
TitledBorder nombre;
nombre= BorderFactory.createTitledBorder(“nombre del panel”);
panel.setBorder(nombre);
Posteriormente creamos un array de 20 etiquetas que le añadimos al panel principal y las hicimos opacas ( setOpaque(true) ), después creamos un algoritmo sencillo para que las etiquetas pares tuvieran el fondo blanco y el nombre en negro, y las impares al revés.
Esto lo hicimos de la siguiente forma:
if (i%2==0){
etiquetas[i].setBackground(Color.WHITE);
etiquetas[i].setForeground(Color.BLACK);
}
else {
etiquetas[i].setBackground(Color.BLACK);
etiquetas[i].setForeground(Color.WHITE);
Ahora vamos a pasar a comentaros directamente el último ejercicio que es el más completo y el que más nos va ayudar para aprender a utilizar los Layouts paneles y demás utilidades. Nosotros lo hemos dividido todo en varios paneles y hemos creado un array de etiquetas para posteriormente añadírselo a los paneles de la izquierda. Para que os hagáis una idea os lo ponemos:
contenedor= getContentPane();
panel= new JPanel();
derecha= new JPanel();
izquierda= new JPanel();
uno=new JPanel();
dos=new JPanel();
tres=new JPanel();
etiquetas= new JLabel [5];
contenedor.add(panel);
panel.setLayout (new GridLayout (1,2));
izquierda.setLayout(new GridLayout(3,1));
panel.add(izquierda);
panel.add(derecha);
Para las etiquetas lo que hacíamos era dependiendo del número de etiquetas que hiciesen falta recorríamos el array hasta una posición u otra, de esta forma:
for(int i=0; i<3; i++){
etiquetas[i]=new JLabel(“etiqueta”+(i+1));
dos.add(etiquetas[i]);
}
Para el panel de la derecha creamos cinco etiquetas dependiendo de su posición en el panel y se las añadimos a este:
derecha.setLayout(new BorderLayout());
JLabel centro = new JLabel(“Center”,JLabel.CENTER);
centro.setForeground (Color.BLACK);
centro.setBackground(Color.WHITE);
centro.setOpaque(true);
derecha.add(norte, BorderLayout.NORTH);
Esto fue todo lo que dio de sí esta práctica, nos sirvió para confirmar lo que ya sabíamos de swing y para recordar algunas cosillas que ya teníamos en el olvido.
Bueno pues nada ya sabéis, ir guardando la ropa de invierno los que todavía no la hayáis hecho que ya estamos a punto de acabar el curso y esto tiene que empezar a parecer que se aproximan las vacaciones (o por lo menos el verano).
Agur.
May
16
Ya estamos otra vez por aquí, que tenemos que ir espabilando…
En esta práctica vamos a comentar como hicimos la tabla hash con sus truquillos, y explicar los métodos de recursividad que nos adjuntan.
En la tabla hash hemos realizado una normalita en la que tú le metes por teclado el truco que quieres y te saca por pantalla lo que hace ese truco. Os vamos a dejar el código que no es muy largo y no se hace nada pesado.
import java.util.Hashtable;
import java.io.*;
public class TablaHash{
public static void main(String []args){
Hashtable truco= new Hashtable();
truco.put( “vidas” , “tienes vidas infinitas” );
truco.put( “invisible” , “no te pueden ver los enemigos” );
truco.put( “dinero” , “dinero ilimitado” );
truco.put( “velocidad” , “maxima velocidad” );
truco.put( “armas” , “activadas todas las armas” );
truco.put( “volar” , “puedes volar??” );
truco.put( “robar” , “atraca a quien quieras” );
truco.put( “comer” , “toda la comida gratis” );
truco.put( “salud” , “te han curado” );
truco.put( “ganar” , “has ganado la partida” );
try{
System.out.print( “Pon un truco->” );
BufferedReader teclado=new BufferedReader(new InputStreamReader(System.in));
String s=teclado.readLine();
System.out.println( “El truquillo es:” +truco.get(s));
} //try
catch(Exception e){
System.out.println( “Pon un truco que exista” );
}
} //main
} //class
IDEA!! Viendo esto y con ayuda de Jose, se nos ha ocurrido una aplicación para poder utilizar trucos en el juego. Bueno realmente no tiene nada que ver con la tabla Hash, pero como se nos ha ocurrido al ver esto (y a estas alturas ya hemos utilizado swing y demás ) pues os lo vamos a contar. La historia seria que mediante el metodo keyPressed() que implementa KeyListener, se podría hacer algún que otro truquillo al presionar una serie de teclas…hay queda eso;).
Ahora os vamos a comentar el ejercicio de recursividad por métodos:
public long factorial(long num)
{
if (num==1)
return 1; //cuando llega a 1 devuelve un 1
else
return num * factorial(num-1); //multiplica el número que le pasas por el factorial de los números menores a este hasta llegar a 1
} //si num=3 ->return 3*2*1;
public void p1(int a)
{
if (a>0)
{
System.out.println(a); //imprime el número que le pasamos
p1(a-1); //resta 1 y si sigue siendo distinto de 0 se vuelve a llamar
}
else //cuando llega a 0 imprime FIN
System.out.println(“FIN”);
} //si a=3, imprime en diferentes filas-> 3 2 1 FIN
public void p2(int a, int b)
{
if (a>0)
{
p2(a-1,b+a); //hace b+a y le resta 1 a “a”, si “a” sigue siendo mayor que 0 le vuelve a sumar al valor que teníamos antes “a”, es decir, primero b+a y después (b+a)+a
}
else //cuando “a” llega a 0 imprime b
System.out.println(b);
} //a=2,b=5, hace 5+2 y decrementa a(a=1), luego 7+1 y la vuelve a decrementar(a=0), por ultimo imprime b=8
public long suma(long [] tabla, int posActual, int tamaño)
{
// Condición de salida en el último elemento
if (posActual == tamaño -1 )
return tabla[posActual]; //si coinciden te devuelve el valor que hay en esa posicion
else
return tabla[posActual] + suma(tabla, posActual+1, tamaño);
} //devuelve la suma de los números hasta donde se indica la posición actual partiendo del tamaño que se le meta en un principio
public long fibonacci(long num)
{
if ((num == 1) || (num == 2))
return 1; //si es 1 o 2 devuelve 1
else
return fibonacci(num-2) + fibonacci(num-1); //hace la suma de Fibonacci de los dos numeros menores del que le pasamos y nos devuelve los dos ya sumados.
}
El método inverso no le entendimos muy bien por eso no os lo ponemos haber si la íbamos a liar a estas alturas del curso…
Bueno esto es todo por hoy.
Esperamos no encontrarnos con ninguno de vosotros por ahí de juerga, porque sería un síntoma de que vosotros seguro que ya sabéis todos los conceptos necesarios para aprobar la asignatura (que es lo suyo) y que a nosotros nos han liao en una época en que no debían y hemos desaprovechao una noche de intenso estudio…jeje;)
Agur
May
15
Buenasss!!
Nos a costado un poquillo lo de volver a arrancarnos poniendo los post de las prácticas , pero ahora intentaremos poneros unas cuantas seguidas, para volver a coger el ritmo. Bueno realmente no hemos llegado a entender esta práctica hasta que hemos visto unas cuantas veces el post de Jose y Marco(porque nos parecio el más entendible), y también le hicimos a Marco que nos lo explicara en papel para que nos quedase claro.
Con todo esto lo que vamos a hacer es coger parte de su código e intentar explicarlo.
public void Insertar(Pieza p){
Nodo N;
N = new Nodo(p,Ultimo); //se crea un nodo y se le mete la pieza en la ultima posicion de la lista enlazada
if(n==0)} //si no hay nigun nodo todavia se lo asigna al primero
Primero=N;
}
else{
ultimo = N;
}
n++; //incrementa el contador
} //Insertar()
public Pieza Sacar(){
Recorrido=Ultimo.Siguiente(); //asigna Recorrido al nodo que apunta Ultimo
for(int k=0; k<n; k++){ //bucle que recorre la lista de nodos si se hubiese puesto el bucle hasta k<=n devolveria un null, ya que intentaria
//devolver un nodo al que apunta el primero que hemos metido y no apunta a nada
Recorrido=Recorrido.Siguiente(); //va recorriendo los nodos y asignando Recorrido al nodo apuntado e incrementado k hasta llegar a n-1
k++;
}//for
Primero=Recorrido; //asigna Primero a Recorrido que esta en la ultima posicion del bucle for anterior
n–-; //se decrementa un nodo
return Recorrido.Siguiente(); //devuelve el nodo al que apunta Primero
} //Sacar()
Como veis hemos destacado, a nuestra forma de ver las cosas,lo más difícil e importante de esta práctica y lo que a nosotros nos a dado más problemas.También nos hemos ayudado del archivo de listas enlazadas que suibieron los profesores a la web de oca.
Esperamos que os haya servido de algo, aunque el código lo hayamos cogido prestado de Jose y Marco.
P.D: Vamos a tener que empezar a rezar para que en época de exámenes llueva todo lo que no ha llovido hasta ahora para tener que quedarnos en casa y hacer algo de provecho, porque con el tiempo que hace, hay ganas de todo menos de estar en casa;)
Agur.
Abr
23
Buenasss! Bueno para no perder las ‘buenas’ costumbres colgamos el post de esta práctica con un poquillo de retraso…
En esta práctica hemos realizado una cola mediante un array de Piezas como nos decían. La hemos hecho de una forma entendible, sencilla y como no, que funcione. Para empezar hemos creado tres clases: Pieza(donde solo le pasamos como atributo el tipo de pieza que vamos a meter en el array), Cola(donde se encuentra el array de Piezas, un puntero que se va moviendo según encolamos y desencolamos, y los distintos métodos para utilizar la cola(“no seais mal pensaos eee…jeje”)) y Tetris que es la que contiene el método main y donde creamos los objetos.
Os voi a dejar la implementación solo de la clase Cola porque lo demás creemos que es muy facil.
public class Cola{
Pieza[] array;
public int ultimo=-1;//puntero que indica la posicion en el array
public int numElementos;//tamaño del array
public Cola(int numElementos){
this.numElementos=numElementos;
array=new Pieza[numElementos];
}
public boolean estaVacia(){
return ultimo==-1;
}
public boolean estaLlena(){
return ultimo==numElementos-1;
}
public void encolar(Pieza p){
//desplazo primero el puntero para que se incremente una posición en el array
ultimo++;
//en esta posición es donde almaceno la pieza, como yo soy quién le paso el objeto //se debe declarar así.
array[ultimo]=p;
//Esto lo hago para que cada vez que inserto una pieza sepa lo que insertamos.
System.out.println ( “Has insertado una pieza tipo: “ +p.tipo);
}//encolar
public Pieza desencolar(){
Pieza p;
//A la pieza que acabo de crear le asigno la ultima posición a la que apunta el puntero.
p=array[ultimo];
//Recorro el array y lo que estaba en la posición i+1 me lo pasa a la posición i.
for(int i=0;i<numElementos-1;i++)
array[i]=array[i+1];
//Una vez recorrido el array decremento en una posición el puntero para poder seguir //sacando piezas.
ultimo–;
return p;
}//desencolar()
}//class
Para lo demás solo teneis que hacer una clase con el ejecutable en la cual creais un objeto Cola( y le pasais el tamaño de la Cola), despues los objetos que vayais a meter en la cola(x ej:Pieza L=new Pieza(‘L’)), y por último llamais a los métodos encolar, etc, y veís si la cola esta llena, vacía y esas cosillas, mas que nada para que veaís que funciona.
Bueno pues eso es todo, si teneís alguna duda, no os sale o no lo veís claro nos lo decís y resolvemos vuestras dudas que para eso estamos.
Os voi a dejar un chiste para mayores de 18 años asi que si le estais enseñando lo bonito que es este blog a vuestro sobrino/a, primo/a pequeña… mandarle a ver la tele mientras os leeis el chistecillo:
Uno que entra al telepizza con dos mujeres de uso público y dice:
-Quiero dos pizzas.
-Familiares?
-No son putas pero tambien tienen hambre.
Agur.
Abr
16
Buenasss!Ya por fin hemos podido colgar el post de esta práctica, que con eso de la entrega del juego y que no era demasiado corta…
Vamos a empezar a comentar la práctica por apartados.
Ejercicio 1: en este apartado lo reseñable es la forma de como heredar metodos de la clase base, que se hace mediante la referencia super y a continuación el método del que se quiere heredar, en este caso super.toString(); Esto nosotros ya lo hicimos en la práctica anterior porque ya tenemos tablas en este asuntillo. El otro apartado reseñable es el aprovechamiento del mecanismo de polimorfismo, lo explicamos con este ejemplo:
for(int i=0;i<miembros.length;i++)
//asi lo hacíamos antes->s+=miembros[i].toString();
s+=miembros[i];
También se puede ver en la clase ejecutable que al hacer la llamada a los objetos para que nos imprima la cadena de caracteres por pantalla no hace falta volver a invocar el método toString(), ahí va el ejemplo:
/*antes lo haciamos asi->System.out.println(” La meta-información ‘en tiempo de ejecución’ del OBJETO “
+o1.toString()+” es: “+analizadorObjeto1.toString());*/
System.out.println(” La meta-información ‘en tiempo de ejecución’ del OBJETO “
+o1+” es: “+analizadorObjeto1);
Ejercicio 2: para este ejercicio nos hizo falta ayuda de las soluciones para poder implemetar el método guarda, porque más o menos nos hacíamos una idea de como hacer que guardara la cadena con
->out.write(toString);, pero lo siguiente no sabíamos asi que nada un poco de ayuda del api de java y las soluciones y listo. Lo que nos pareció importante de comprender era que en las INTERFACES solo se definen los metodos->public void guarda( java.io.FileWriter out ) throws Exception ; , y en las clases que implementan estos interfaces los declaramos->public void guarda( java.io.FileWriter out ) throws Exception {//cuerpo del método}.
La otra parte de la aplicación gráfica también la hicimos pero realmente nos parecio que esta bien hacerla para entender la parte del contenedor, la ventana y eso, pero nosotros que ya hemos utilizado swing en java creemos que luego lo que se ve en estos apartados solo nos da una pequeña idea de como lo vamos a utilizar posteriormente a la hora de crear una interfaz gráfica(con esto no queremos decir que no lo hagaís eeee, que si lo han puesto sera por algo).
Por último y en compensación de que no hemos comentado como hicímos la interfaz gráfica, vamos a poner un ejemplo de como se crea una clase abstracta y como se hereda de esta, que es lo unico que no viene un ejemplo en esta práctica, ahí va:
public abstract class Abstracta{
protected int x=2;
protected String frase=”También se pueden implementar metodos”;
//solo definimos este método
public abstract int getX();
//este lo declaramos
public String getFrase(){
return frase;
}
}//clase
public class HeredaAbstracta extends Abstracta{
//tenemos que declarar el método que hemos definido en
//la clase abstracta sino daría error.
public int getX(){
return x;
}
public static void main(String[] args){
HeredaAbstracta h=new HeredaAbstracta();
System.out.println(h.getX());
System.out.println(h.getFrase());
}//main
}//clase
Es facilito, simplemente es para que veais como se utilizan las clases abstractas, si teneís dudas decirnoslo y las intentarmos solucionar(no prometemos nada;)).
P.D: siguiendo con la tónica de la práctica anterior despues de que nos hemos creado unas clases y todo a modo de ejemplo, si nos llamais frikis lo entendermos aunque nos duela…
Os voi a contar un chistecillo para terminar:
Se abre le telón, y se ve en una reunión a Office, a PowerPoint y a Excel. Se cierra el telón.¿Cómo se llama la película?
->Star Word?
Agur.
