Que podemos decir, se han cumplido todas nuestras espectativas, el juego funciona tal y como queremos:
- ya nos guarda la partida cuando nosotros le digamos
- antes de empezar nos deja la opción de cargar partida guardada o no
- podemos salirnos sin guardar
- podemos salirnos en cualquier momento dando a la cruceta de la esquina superior derecha
en definitiva, todas los objetivos cumplidos, el juego del comecocos, está listo para ser mandado!! jejeje
Escrito en Prácticas
Bueno gentecilla parece que este es nuestro último post de prácticas, y la verdad es que, qué rápido se pasa el tiempo,no?? parece que era ayer, cuando no sabíamos ni que era el Blogroll, y fijaos que ahora somos unos “expertos” en esto de <Blogear> jejeje.
Y que decir de la última práctica, que nos deja con el gusanillo de los reproductores de video y audio, pero no nos preocupemos, que en segundo nos vamos a hinchar!!jejeje, y es que tenemos una asignatura prácticamente sólo de JMF!!;)
Hablando un poco de la práctica del pasado viernes, qué podemos decir que JMF es un API que permite manejar multimedia que no viene dentro del JDK. Tenemos que descargarla a parte y configurar el classpath, cosa que nos tocó preguntar a nuestro compañero de delante porque no nos acordábamos!jejeje.
Lo primerode todo, el profesor nos mando bucear en el API un poco, para que viésemos la cantidad de cosas que se pueden hacer con JMF.
En el ejercicio 1, se nos pedía que hiciéramos un reproductor, que reprodujera un video que teníamos que descargar con la práctica.Teníamos que usar JFrame de swing, extraer su content pane y añadir sus componentes visuales ( que se extraen de la clase player).
¿Como creo la clase player? Tenemos una clase con 2 métodos principales, getVisualComponent(), y otro que es getControlPanelComponent(), que tenemos que añadir a un content pane.
Player es una interfaz, no puedo hacer un new, y quedarme tan ancho, con la clase Manager,se define una serie de métdos estáticos, uno es createPlayer(“¿donde encotrar el fichero, el imputStream, que vamos a reproducir?); donde nosotros podemos meterle la url del fichero para que lo reproduzca.
Por lo tanto, tendremos que hacer un objeto tipo URL y se lo pasaremos por parámetro. Al componer una URL se hace así: prot://destino/recurso; ejemplo!!file://video.mpg
Tenemos nuestra ventana con nuestros 2 componentes que hemos creado a traves de un manager, y con nuestro control de excepciones debidamente hecho. Al estar en el estado de Unrealized, para pasar correctamente al estado de Realized deberemos hacer p.realize(); y después getVisualComponent();.
No podemos reservar un tamaño sin saber antes el tamaño que tiene de verdad lo que queramos hacer, por eso hacemos el realize(); Primero salta al estado de “me estoy dando cuenta”, y se ejecuta un nuevo Thread que está ejecutando realize. El problema es que estamos tardando, y no sabemos cuanto puede tardar, y no se ejecuta getVisualComponent(), y se solucionaría si ponemos un thread.Sleep(); pero es una burrada. Por eso hacemos lo que hemos contado en el párrafo anterior.
JMF también trabaja con eventos porque el hecho de que un player cambie de estados también genera un evento.
Si seguimos con la práctica, tendremos que saber que hay que añadir un controllerListener(), para que cuando se lance u ocurra un evento. (ocurra el evento que ocurra) ,descubramos de qué tipo de evento estamos hablando, qué objeto es el que nos aperce, entonces haremos un instanceof nombre_del_evento, y en vez de esperar un tiempo arbitrario, instalamos un modelo de evento, y nos ponemos a escuchar, de tal forma que cuando se haya dado cuenta de lo que está pasando continuamos. El evento que nos hace falta es RealizeCompleteEvent (evento de que se ha terminado el paso del estado Realize).
NO PUEDO INVOCAR VISUAL COMPONENT ANTES DE PASAR AL ESTADO REALIZE ; POR ESO ES POR LO QUE HAGO EL TRATAMIENTO DE EVENTOS.
Con el video es posible que nos salte este mensaje, variable Handle format; (nos soy capaz de manejar este formato), que estamos usando un video no compatible, y ¿dónde hay un video compatible? www.it.uc3m-es/alcortes/tmp/otrovideo.mpg
Y bueno, ahora para más detalles, os ponemos el código a continuación:
import javax.swing.*;
import javax.media.*;
import java.awt.event.*;
import java.net.URL;
import javax.swing.JFileChooser;
import java.net.MalformedURLException;
import java.io.*;
import java.awt.*;
public class MiReproductor extends JFrame implements ControllerListener{
URL direccion;
Player player;
Component c;
JPanel panel;
public MiReproductor(String cadena)
{
try {
direccion = new URL (cadena);
player = Manager.createPlayer(direccion);
player.addControllerListener(this);
}
catch(IOException e){
}
catch(MediaException me){
}
catch(Exception e){
}
player.start();
setTitle(“Reproductor”);
panel = (JPanel)getContentPane();
setVisible(true);
System.out.println(direccion.toString());
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public synchronized void controllerUpdate(ControllerEvent ce){
if(ce instanceof RealizeCompleteEvent){
c = player.getControlPanelComponent();
if(c != null)
panel.add(“South”,c);
c = player.getVisualComponent();
if(c != null)
panel.add(“North”,c);
}
if(ce instanceof EndOfMediaEvent){
player.setMediaTime(new Time(0));
player.start();
}
}
public static void main(String[]args)
{
MiReproductor aver = new MiReproductor(“file:video.mpg”);
}
}
Y hasta aquí, el que podría ser nuestro último post! muchas gracias a todos los que nos habéis leido, y a todos los que han hecho posible que esta propuesta no se haya venido a pique.
1Saludo a todos!!!
Escrito en Prácticas
Ya queda menos chicos!!!jejje, como os fue esta práctica?? Si pudiésemos definirla con una sola palabra, la ideal sería CATÁSTROFE!!! y es que primero los ordenadores de al área de no-telemática no tiraban, se quedaba la pantalla azul y no entraba en windows, luego, nos mudamos a la torre de telemática, y que pasaba??? que el classpath no estaba configurado!!jejej, que bien!! menos mal que nos dejo volver a la otra torre, pero como usuario “invitado”, así que a tirar de block de notas y simbolo del sistema!!jejejej
Hoy nos vamos a comunicar con los programas! Hay varias formas de comunicarse por ejemplo:
- La entrada estándar, system(in), si queremos lo transformamos en un bufferReader para que
nos lea de teclado..pero bien, sabemos comunicarnos con un programa gracias a la entrada estándar pero no es muy ortodoxo que digamos.
- También podemos hacerlo con parámetros de entrada, tampoco es muy adecuado, pero se usa a veces.
- Y como no, el manejador de ventanas, mediante eventos. Hay componentes gráficos que pueden capturar eventos, y que esos eventos se darán cuando pase algo. Y qué pasa entonces???? que cuando alguien pulse por ejemplo, un JButton, éste se encolará en la cola de eventos, de tal forma que si pulsas 10 veces el boton, se meterán 10 eventos dentro de la cola.
Estructura básica de los hilos:
Quien procesa los eventos es event-dispaching thread, y el hilo principal es que los lanza, y todos ellos se meten dentro de una cola.
Por ejemplo, setVisible() lanza un evento, y el event-dispaching thread, cuando en la cola le toque su
turno, se encargará de hacer ese setvisible().
Esta clase de hoy esta básicamente para familiariazarnos y trabajar rárpido con hilos en swing. Recordamos pues que para crear una ventana con un componente: creabamos un JFrame, creabamos un JPanel. y se creaba un contentPane, y dentro de él un JPanel, JButton y JText.
¿Qué diferencia hay entre insertar un JButton y un JPanel?
Que un JBUtton contiene un ActionListener, que se lo tenemos que añadir así, b.addActionListener(e), siendo e un objeto de ActionPerform; y cuando lance este evento se va a encolar en la cola de eventos.
¿Cómo conseguimos un objeto de una clase que implemente actionListener? O con una clase interna
o implementándola como interfaz.
Al final llegamos a la conclusión de la pregunta sobre que diferencia hay entre ellos y es que sobre JButton puedo ejecutar un evento, y sobre JPanel no. JButton es un elemento activo y JLabel pasivo.
En el ejercicio 1 se nos pedía que escribiéramos un programa que presentara una ventana con un botón y que cada vez que le pulsáramos imprimiera un texto por salida estándar, y bueno la verdad es que no fue muy complicado, simplemente había que poner un escuchador al botón y cuando éste se activara, sacase por pantalla ese texto que queramos.
En el ejercicio 2 se nos pedía que hiciéramos una ventana que tuviera un botón y una etiqueta, y cada vez que se pulsara el botón se cambiara de color la etiqueta, y bueno esto tampoco tuvo mucha difultad porque sabiendo que teníamos que usar un escuchador para el botón y luego para cambiar el fondo un setOpaque() (para poder pintarlo) y setBackground() (para darle color).
En el ejercicio 3 se nos pide que calculemos eventos de boton y de salida estandar.
Aunque tenemos una ventana, tenemos también otro hilo que sigue trabajando, sigue
haciendo código, que es lo vulgarmente diríamos “lo que está en la linea comandos”,y está respondiendo a eventos dentro de ese linea de comandos. Lo que principalmente se nos pide es que mezclemos ejercicios 1 y 2, por lo que no tiene mucha complejidad,pero..
¿¿qué hilo es el que se está ejecutando?? Dentro de la tarea que estemos utilizando antes de cambiar el color o imprimir por salida estandar (ejercicio anterior) debemos poner para saberlo la siguiente línea de código: Thread.currentThread().getName();
Cuando alguien pulsa enter en ese hilo, lo escuchamos y ejecutamos un código, y a ese jLabel, lo cambiamos de color, así mismo cuando pulsemos el botón.
¿¿Por qué queremos que lo ejecute el hilo event-dispaching thread?? porque esta para eso, esta para procesar y ejercutar eventos!!jejjee, y ¿cómo se lanza un evento? ponemos:
pongo invokeAndWait( )
invokeLater(Runnable r);
creo una clase que implemente Runnable, y en el método run lo que quiera que haga!!
Bueno chicos, la verdad es que no nos dio tiempo a más, y todo gracias a nuestros problemas informáticos..jejeje.
Intentaremos a ver si acabamos la práctica y la ponemos por aquí, pero no se si lo sabéis, pero las soluciones hoy mismo ya estaban colgadas, echadlas un ojo por si acaso nunca viene mal!!
De todas formas la dinámica de los ejrecicios no es muy complicada si los 3 primeros se entienden bien, es mezclar los conceptos aprendidos unos con otros, y añadiendo el concepto de búsqueda en threads!
Un saludo a todos y hasta la próxima y última clase!!
Escrito en Prácticas
Hola a todos!! Quien decía que programar es fácil?? Es facilísimo!!jajaja, la verdad es que no, pero bueno.. Como lo lleváis???
La práctica de hoy, la verdad es que ha sido bastante teórica pero ha venido bien, pese a que en clase se nos avisara de que hilos nos muy probable que caiga en el examen, pero oye, nunca viene mal saber estas cosas, sobre todo para nuestros juegos!!jejeje
La práctica de hoy se podría decir que se divide en:
Cuantos procesos hay ejecutándose en el ordenador a la vez, si miramos el administrador de tareas de Windows (Ctrl.+Alt.+Supr.) vemos que son 50!!!
¿Que diferencia hay entre un programa y un proceso? Los programas necesitan procesos para ejecutarse. No hay diferencia entre ellos, son lo mismo. El resumen de procesos es llamado programa. Tanto proceso como programa son líneas de código compilado ejecutándose. Un proceso es un código en ejecución.
Tenemos 50 procesos ejecutándose a la vez, pero lo están haciendo realmente a la vez??? Pues no, como Windows es un sistema operativo multitarea:
es posible ejecutar 5 procesos al mismo tiempo (la cpu en cada momento solo puede ejecutar un proceso) la diferencia es que los procesadores trabajan en rangos de milisegundos y si dividimos 1 segundo en 5 partes, en la primera se ejecuta el primero (20milisegundos) y así con todos
.
Un procesos hace sus tareas secuencialmente, si uno necesita hacer 2 cosas ala vez, esperar 2 segundos, y aceptar cosas por líneas de comando, ¿Qué pasa? Que solo puedo ejecutar una tarea en cada momento por cada proceso.
En el ejercicio 1 hay un programa que cada vez q damos al enter hace ding, y otro que hace dong cada un cierto intervalo de tiempo, ¿podemos hacer que un código que espere un temporizador y a la vez lea una entrada por teclado?
El ejercicio 1 es fácil, porque solo es compilar, ejecutar, y entender!jejeje
¿siempre se reparten equitativamente los procesos? En principio es la mas sencilla de hacer, pero a veces hay prioridades (es como en avión que el que va en Business pues tiene prioridad sobre los demás).
2. Threads en java
Un thread (hilo de ejecución), es un camino que sigue nuestro programa mientras se ejecuta, podemos hacerlo de tal forma que nuestro programa tenga 2 hilos de ejecución en el mismo proceso. Es más, por ejemplo, tienes 20 milisegundos y te las apañas como puedas, y esto nos permite hacer dos cosas a la vez. La situación sería lo mismo que tener 2 procesos asociados a un única salida estándar.
El ejercicio 2, es aprender a lanzar un hilo…
Runnable r = new Runnable (){
Public void run(){
}
¿Qué es Runnable? Hemos dicho, que de una interfaz no podemos hacer un objeto de ella. Una clase que los implemente (clase interna), quiere decir que estoy poniendo un atributo de clase (va ser r), que es un interfaz tipo Runnable, siempre y cuando estén implementado todos los métodos de esta interfaz.
Esta es una sintaxis válida para crear un objeto que implemente una interfaz, es un objeto más.
Lo que queremos es lanzar un hilo nuevo. Existe una clase que tiene un método run(), y la clase Thread esta relacionada con algo que implementa run().
La clase Thread lanza un hilo nuevo, se ejecuta el código que esté dentro de run() si quiero hacer que cuando se ejecute el hilo imprima el nombre del hilo por pantatalla, thread hace la bifurcación y dentro de run() ponemos el S.O.P.
Tenemos un objeto r que implementa la interfaz Runnable, y se lo paso al constructor de thread, de tal forma que tengo un hilo que esta relacionado en su construcción con un tipo Runnable, y el método start(); q se encarga de hacer la ejecución.
Thread t = new Thread (r);
t.start;
¿Qué pasa cuando el código principal se acaba?¿Se puede dar la situación de que nuestro hilo no raíz siga y el de la raíz se muera? no!!!
Otra forma de lanzar un Thread es el código 2, hago que la clase principal implemente Runnable, y en el main lanzo el thread (new thread) y le paso un objeto de la clase principal.
Y la tercera forma, una clase principal que herede de thread, y como algo que herede de thread a parte de los métodos que tenga ,arrastra las interfaces que implemente.
Thread implementa Runnable, y dentro del código tengo la posibilidad de hacer start, e implementar el método run();
Class TwoThreads extends thread{
start ();
run(){
}
}
Luego puede pasar que en vez invocar el método start invoco el método run, estoy hablando de un error común!!! No invocar t.run(), lo que estoy haciendo es no lanzar la bifurcación que eso lo hace start!!.
3. Condiciones de Carrera
ERROR CLÁSICO!!
Imaginad un programa con 2 threads, y esos 2 threads acceden a una base de datos en la forma de un vector, pila, cola, (contenedor de objetos) que es una atributo de esta clase. Puedo acceder desde cualquier thread a él, es un elemento compartido desde de los 2 hilos. ¿Qué pasa? Si dos elementos acceden a la vez a un mismo sitio de la memoria, como el tiempo asignado a cada hilo es aleatorio, es una cosa que esta fuera de nuestro control, no sabemos cual de los 2 accesos se van a ejecutar primero, si a la vez, esto se llama CONDICION DE CARRERA!!!!! (Es el accesos simultaneo de dos hilos del mismo programa a un recurso compartido)
En el ejercicio 3 se nos habla de esto:
Antes de ejecutar podríamos esperar que primero saldrían unos y luego ceros, se puede saber ese orden??? Hay alguna forma??? Te dice si primero se lanza un hilo a simple vista en el código, pero el problema es que no sabemos que pasa después.
Imaginamos que tenemos un fichero que es “hola” y tenemos 2 hilos, y el primer hilo accede y asigna un “1” y luego el segundo hilo lo mismo y pone un “2”, y viceversa entonces se pueden tener 2 casos: o que salga hola12, o salga hola 21.
¿Cómo evitar esta confusión?
Comprobando que el otro hilo no lo aya usado!! o mejor compramos otra taza!!jajaja
Si genera problemas acceder a un recurso compartido, sino es necesario pues no lo hacemos, y si no nos queda mas remedio, hay comprobar que el otro no este accediendo.
En el ejercicio siguiente, vamos a evitar que los 2 hilos accedan a la salida estándar. Tenemos un hilo que genera eventos y un hilo que procesa a eventos, uno sale a salida estándar y el otro ordena que vaya a salida estándar. Se comunican con una cola de eventos (es una forma de que uno de lo hilos ataque la salida estándar).
Ahora tenemos un ejemplo de código, pero la idea es que desde un hilo se metan una serie de eventos en una cola, y desde el otro hilo se mire para procesar esos eventos.
Bueno esto nos pareció curioso y es que en este ejemplo
Runnable write1Runnable = new Runnable(){
public void run(){
eventQueue.add(‘1′);
eventQueue.add(‘z’);
}
};
Pasa que después de la llave del final, hay un “;”, por qué?? Por que al ejecutar el constructor “Runnable write1Runnable = new Runnable() } { ;” dentro de esas llaves podemos meter lo que queramos! Que funciona dentro de ese constructor!
El resto del ejercicio consistió en compilar y ejecutar y entender!jejeje
4. Hilos en Swing
Y a partir del ejercicio 4, hemos visto que cuando yo quiero ejecutar algo en swing, como es multihilo, tendremos un hilo “jefe”, y un hilo que procesa eventos (event-dispaching thread), que mira a ver si hay eventos gráficos que procesar.
Cuando hago el setVisible(), el hilo siempre chequea si existe algo en la cola de eventos, si lo hay lo procesa, y sino, cada X tiempo vuelve a chequear.
Un hilo que maneja el estado del programa, y otro que lo procesa (event-dispaching thread) es el resumen fundamental de la función multihilo. El event-dispaching thread lo procesa y el principal lo lanza., cualquier evento que se lance, no se va ejecutar al principio, se va a una cola de eventos, y ya se irán ejecutando.
En el apartado 2 se nos habla de una ventanita que parpadea, y principalmente lo que hay que hacer es createGUI, procesarlo, y actualizarlo.
Se lanza el main, y lanzamos el GUI, lanzamos una ventana, la ventana inicial, dentro del main cambiamos los atributos tipo COLOR y los tocamos de tal forma que se adecuen a lo que nos piden, y llamamos a updateGUI.
Y bueno como dicen, el resto de apartados acabarlos en casa!!jejeje, ya los miraremos y conforme los tengamos actualizaremos si andamos bien de tiempo!!
1Saludo a todos!!!!
Escrito en Prácticas
Saludos gentecilla!! que tal con nuestro primer dia de swing??jejeje, no ha estado mal!!:P
Bueno comenzamos con un poquito de teróría!!ejeje , y es que, qué es una interfaz gráfica? Lo que comunica el ordenador con la persona , algo que permite que un programa que hace lo que sea, se comunica con el usuario.
Nosotros vamos a hacer una representación gráfica, pero puede interesarnos que el programa se comunique con nosotros por sonido, basada en texto..,el programa es el mismo, la diferencia es la forma de comunicarse con el usuario.
¿Cuándo es útil y cuando no, un interfaz gráfico?
Por ejemplo, un antivirus que hace? rastrea continuamente el sistema, entonces, para que tenemos una interfaz gráfica en los antivirus? Para que el usuario no se asuste de la cantidad de frases de código que es lo que internamente hace el antivirus!!jejeje
Ahora vamos a hacer el ejercicio 1, y así de paso vamos explicando un poco de todo.
¿Cuántas clases estamos programando? Una, y ¿cuántos métodos tiene? Uno, el main.
¿De qué tipo se crean los objetos? De tipo JFrame, JPanel y JLabel.
¿qué métodos que se invocan?
- El main à HelloWorldWorldGUI (el nombre de la clase)
- El constructor de JFrame à JFrame (se crea un panel cuando lo ejecutamos)
- El setDefaultCloseOperation à JFrame (que estamos haciendo?? darle una operación de cierre por defecto)
- El getContentPane à J Frame ( crea un contenedor)
- El constructor de JLabel à JLabel (una etiqueta)
- El add(label) à container (añadimos cosas al contenedor, al JPANEL )
- El setSize(100,50) à window (nos crea una ventana de cierto tamaño)
- El setVisible(true) à window (hace que podamos ver la ventana)
Antes de swing, está awt, solo que está un poco anticuado ya! Cuando ponemos una “j” delante de las clases que pertenecen a swing.
Para esta práctica y las que nos queden hay que quedarse con algo seguro, y es que JFrame es algo relacionado con ventana, JPanel es algo relacionado con contenedor y JLabel algo relacionado con etiqueta.
Ahora vamos a ver las líneas de código una a una a ver que nos dicen:
JFrame frame = new JFrame(“HelloWorldGUI window title”);
Le estoy pasando un String como parámetro, que es este es el título de nuestro frame que vamos a crear.
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Aquí lo que hacemos es darle una condición de salida (cerrar). Para cerrar la ventana, cuando das a la “X”. El atributo EXIT_ON_CLOSE, es un atributo de clase, de tipo entero , de tipo estático, de tipo final.
JPanel contentPane = (JPanel) frame.getContentPane();
Lo que estamos haciendo, es obtener algo que se llama contentPane, que me devuelve un objeto que tengo que transformar a JPanel (por eso lo del casting).
JLabel label = new JLabel(“Hello World!”);
Creamos un objeto de tipo JLabel, y le estamos pasando como parámetro un String.
¿solo puedo pasar texto? Pues no, también imágenes, color de fondo, pero sonido no!!
contentPane.add(label);
Aquí se dice que se añada el siguiente elemento, le paso un JLabel como parámetro y a partir de esta línea el contenedor tiene una etiqueta.
frame.setSize(100,50);
Ajusto el tamaño de frame.
frame.setVisible(true);
Muestra por pantalla el frame.
Ahora se nos dice que hagamos la ventana 4 veces mas grande, y bueno eso es simplemente es multiplicar por 4 a cada numero del setSize.
Luego se nos pide cambiar el fondo y solo tenemos que añadir esto:
¨ label.setBackground(Color.RED);
¨ label.setOpaque(true);
la primera sentencia entra en funcionamiento cuando los objetos sean opacos!!, resulta que las etiquetas pueden ser transparentes u opacas, y la nuestra como es??jejeje, pues ya sabéis para que está la segunda línea, porque sino no podríamos pintar nada!!
Ahora se nos pide que toqueteemos un poco más esta clase, y tras comprobar qué pasa cuando pones los system.exit, y demás, vemos que aunque lo que hacen es o cerrarte tu programa o no dejártelo abrir según donde los pongas.
Bueno ahora vamos a meternos con el manejador de ventanas, y qué es eso? “Es lo que lo pinta” , el programa no puede controlar todo lo que ocurre en la pantalla, por eso existe el manejador de ventanas.
A cada programa que quiere utilizar una ventana, le da un rectángulo (le llamamos ventana). La ventana la crea el manejador de ventanas, y el programa lo maneja el usuario.
El programa se puede comunicar con el usuario. ¿Cómo? Con un texto, color e imagen.
El usuario se puede comunicar con el programa, con un JButton, con un J algo..
En algún momento el programa se tiene que comunicar con el manejador de ventanas para que éste le dibuje por pantalla y le dibujará la típica ventana.
Luego los símbolos _ [] X son responsabilidad del manejador de ventanas, por lo que el programa no tiene que preocuparse. Cuando pulsamos la X, el manejador le dice oye que te están cerrando!! Y el programa tiene que ejecutar el evento correspondiente a qué pasa cuando pulsan la X.
Es necesario que nos comuniquemos con el manejador de ventanas???
Cuando queremos operar con ventanas si!, minimizar, cambiar de ventanas, cerrar..
Necesito un medio de comunicación: _ [] X , alt+F4, alt+Tab…
El manejador de ventanas tiene sentido que se comunique con el usuario??
Por ejemplo tenemos una barra de estado en la parte inferior de nuestra pantalla, que tenemos en esa barra?? ¿una lista de programas en ejecución o una lista de ventanas abiertas? Pues una lista de ventanas, que el manejador de ventanas comunicará al usuario diciéndole que tiene tales ventanas abiertas.
El programa no es el único elemento que interviene cuando hay interfaz gráfica, por eso está el manejador de ventanas. ¿Qué operaciones podemos hacer con el manejador de ventanas? Por ejemplo setVisible, setLocation..
¿Qué pasa si no ponemos la algo relacionado con el cierre de la ventana en nuestro programa? pues que no se cierra del todo el programa. Solo la ventana, pero el programa sigue abierto.
¿Qué pasa si no ponemos decoración? Que no se nos decorará la ventana, lo siento no se cómo explicarlo!!jejjeje
¿Y si ponemos setDefaultLookAndFeelDecorated(true); al principio de nuestro código dentro del main? Que le dirá a la clase si los nuevos JFrame los creo con la decoración por defecto o no, y en este caso si lo ponemos antes del constructor nos sale algo como esto:
Cuando quieres añadir varios componentes gráficos a una sola ventana, has de agruparlos en un JPanel. Y si quieres añadir varias etiquetas, solo tienes que crearlas y añadirlas todas. Recuerda que un JPanel es un componente gráfico, por lo que podrás añadir JPanelS al interior de otros JpanelS.
Y hasta aquí hemos llegado!! no dio tiempo a hacer más, ni a él ni a nosotros!!jejeje,
Pero nos pusimos a ello durante estos días y bueno el ejercicio 3 no nos costó demasiado pero es muy importante hacerlo!! Sabemos que para cambiar el color de fondo usamos el setOpaque() y el color se puede cambiar con setFontColor(); Luego nos pedían que ocupara la pantalla entera (maximizara), y con un setSize(1024,760) conseguíamos hacerlo!!
El apartado 2 empezamos haciendo un setLayout(new BorderLayout()); para que el panel se nos dividiera en 5 partes, como ya vimos en clase, que son , norte, sur, este, oeste y centro, y para colocar una etiqueta en la posición que queramos lo hacemos con marco.add(JLabel, BorderLayout.NORTH) por ejemplo, y con el método pack(); colocamos bien todos los elementos.
Para añadir una imagen a la etiqueta, declaramos la imagen con la ruta de acceso Icon imagen= new ImagenIcon(“flecha.jpg”); y luego lo añadimos a la etiqueta con etiqueta.add(imagen);y bueno así más o menos hemos resumido lo más importante del ejercicio 3.
El ejercicio 4, nos pedía crear lo que veíamos en la imagen, así que con un grid layout 1,19, y con un bucle for desde 0 a 18, insertamos el texto de las etiquetas. Luego con un if, miramos si es par hacemos setOpaque(Color.WITHE), y si es impar setOpaque(Color.BLACK)., esto es lo más importante del ejercicio 4 a grosso modo, por lo demás nos salio sin problemas, bueno, mucho pensar y echarle un ratejo!jejeje
Un saludo a todos!! y hasta la proxima!!!
Escrito en Prácticas
Cómo va eso??? ha sido entretenida la práctica 8,e?? jejej, ya cada vez nos quedan menos, según el profesor estamos en el ecuador del curso!jejej, y que mejor que hacer una práctica de Tablas hash y Recursividad.
Una tabla hash, es una especie de tabla en la que podemos insertar y sacar objetos, sin necesidad de definir un primero o un último. Literalmente hash significa “resumen”. Cuál es la motivación de ésta??
En muchas de las colecciones (arrays, pilas, colas, vectores, listas) que vamos a usar, es muy probable que una vez que las tengamos, necesitemos sacar o trabajar con un elemento concreto.
Ahora vamos a ver un ejemplo para cada una de estas colecciones, y así veremos que es mejor usar en cada situación y por qué. Dada la clase persona:
public Perona{
int DNI;
String Nombre;
}
Tenemos un array de peronas donde vamos a buscar personas concretas, ¿tardo mucho en insertar una nueva persona en mi array de personas? ¿importa el numero de personas q ay en el array a la ora de meter una persona mas? ¿tardamos lo mismo si hay alguien que sino lo hay?
Si, si que importa, porque si esta vacio, le meto en el primer hueco que haya, si esta semilleno lo meto pero tengo que recorrer hasta que encuentre el hueco más cercano y así sucesivamente.
Si intentas hacer rapida la extracción, lo que va ser lenta es la inserción, y viceversa.
Nos interesa que insertar sea rápido, por tanto puedo usar una variable libre, que me indique cual es la posición que este libre, asi no tendré que recorrerlo cada vez que quiera insertar, por tanto tardo muchísimo menos.
¿Cuánto tardo en encontrar a una persona si doy el DNI?
Si está vacio, tardaré lo que tarde en mirar la variable libre, y si tengo 100 personas??pues 100 veces lo que tarde en buscar por cada persona. Entonces de promedio, si la ocupación es n, tardaré (n/2)·t
¿Cuánto tardo en insertar una nueva persona en una nueva lista?
Primero una constante que define lo que tardaré en crear el objeto, otra que me indica lo que tardaré en apuntar al nuevo objeto y seleccionarle un nodo vacío.
Si lo ponemos al principio cada vez que quiera meter un nuevo objeto, crearé un nuevo nodo y correré los otros para que mi nuevo nodo sea el primero. No me importa el numero de nodos que tenga en la lista porque no necesito nada mas que un tiempo constante que corresponde a la creación de nuestro nodo y apuntar a él.
¿Cuánto vamos a tardar en buscar una persona? ¿Depende del numero de persanas que tenemos en la lista?
En los arrays sí importaba, y al final no va ser lo mismo recorrer una lista grande que una lista pequeña, nuestro promedio será (n+1)/2.
¿por qué tardamos lo mismo, en que se diferencian listas de arrays?
En los arrays desperdicio memoria y en las listas no.
¿Qué pasa con las cola? ¿Cuánto tardo en insertar un objeto en mi cola?
Lo que tarde en insertar el propio ordenador y, ¿cuánto tardo en buscar una persona en mi cola? compruebo con el método peek, si mi primer elemento es el que estaba buscando, y si no lo es, lo saco a otra cola con el método push, y así hasta que lo encuentre, luego tendré que hacer pop para dejar la cola como estaba.
De promedio tardaré el doble que en listas y arrays, n
(En las pilas es lo mismo que en las colas, no cambia nada)
Ahora llegamos a las tablas hash!
Una tabla hash, es una mezcla de array con listas enlazadas, y siguiendo con el ejemplo de la clase persona puedo decir, que no me importa cuanta gente que haya en mi tabla, siempre tardo lo mismo en encontrar cualquier persona. Asigno a cada persona que vaya metiendo un valor, o las ordeno alfabéticamente. El tiempo en buscar es muy pequeño, pero ¿qué pasa cuando tengo 2 personas con el mismo nombre? ¿irían las 2 en el mismo sitio?
Como yo tengo mi array, puedo hacer que ese array sea un array de listas de personas, así que se crearía un nuevo nodo dentro de la lista en la que haya habido esa coincidencia de nombres.
Las tablas hash como son muy “listas” (jajaja, lo habéis pillado xDD) de vez en cuando se recorren a sí mismas, y miran si hay alguna de sus listas dentro del array , es demasiado grande, mas grande que incluso el tamaño del propio array, entonces la tabla hash, hace una nueva agrupación y divide esas colas a la mitad, y así hasta que volvamos a tener listas de tamaño muy grande, que las volverá a partir.
Por eso a nosotros cuando se nos planteen problema, tendremos que ver qué es lo que nos sale más rentable usar en cada situación.
Hablando un poco de recursividad, podemos llegar a decir que un método es recursivo si se llama así mismo. así es lo que vulgarmente entendemos por recursividad. Un ejemplo! F(n) = F(n-1) + F(n-2)
Y después de esta explicación teórica de nuestro profesor, nos dedicamos a leer la práctica, y es que estuvo una hora explicando en la pizarra!!jejeje, nosotos no nos quejamos ya que lo que dice nos aclara mucho las cosas!!
En nuestra práctica, se nos pedía que usáramos una tabla hash, pero antes nos dijeron que si hacíamos medio bien la práctica nos iba a dar un error a la hora de compilar debido a que estaríamos usando terminología adecuado, por tanto se nos dijo, que a la hora de crear nuestra tabla, la pusieramos sus “apellidos”(técnicamente se llama generics), que en nuestro caso sería String, y el nombre del objeto.
También hace unos años, las pilas dejaron de ser pilas de objetos, y se convirtieron en pilas de lo que sea (de personas, enteros, Strings…), lo bueno es que ya no necesitaríamos hacer casting, porque ya le podemos decir de qué va a estar rellena!! y por eso sino ponemos “apellidos” a nuestras colecciones, java le autoasigna, que lo que lleva sera de tipo <Object>.
Bueno pues nos pusimos rápidamente a mirar el API, y tras un rato de búsqueda..
import java.util.*;
public class Truco{
String informacion;
public Truco(String informacion){
this.informacion = informacion;
}
public static void main(String[]args){
Truco truco = new Truco();
System.out.println(Truco.get());
}
}
import java.util.*;
public class ListaDeTrucos{
public static void main(String[]args){
Hashtable Trucos = new Hashtable();
Trucos.put(“one”, new Truco(“este el truco1″));
Trucos.put(“two”, new Truco(“este es el truco2″));
Trucos.put(“three”, new Truco(“este es el truco3″));
Trucos.put(“four”, new Truco(“este es el truco4″));
Trucos.put(“five”, new Truco(“este es el truco5″));
Trucos.put(“six”, new Truco(“este es el truco6″));
Trucos.put(“seven”, new Truco(“este es el truco7″));
Trucos.put(“eight”, new Truco(“este es el truco8″));
Trucos.put(“nine”, new Truco(“este es el truco9″));
Trucos.put(“ten”, new Truco(“este es el truco10″));
Trucos.get(“uno”); // llama a la tabla hash, trucos y devuelve el objeto de tipo truco
}
Seguimos con el ejercicio 2!! y es que al ser prácticamente teórico, djimos a ver si lo acabos!! y sí!!jejje
Se nos pedía que dados algunos métodos recursivos, dijésemos que hacía cada uno:
- El método p1, mira que a sea > 1, la saca por pantalla, y le resta 1. Cuando a sea <= que 1, entonces sacará por pantalla “FIN”.
- El método p2, se le pasa como parámetro los enteros a y b, y comprueba si a es > 0, y si lo es, hace la resta a-1, y luego suma a+b. Y si a es <= 0, entonces sacará por pantalla “b”.
- El método suma, se le pasa como parámetro un array de longs, un entero posActual, y otro tamaño. Si la posición en la que estamos es = al tamaño -1 de nuestro array, nos devuelve el array en la posActual. Sino, nos devuelve lo que hay en la posActual restándole 1. En cada iteración se suma uno a posActual.
- El método inverso, consiste en cojer un numero y poner sus cifras al revés. Se le pasa como paráemetro el entero n. Lo primero, imprime por pantalla el resto de la división de n entre 10, luego compruebo si n >= 10, y si lo es, llama al método inverso, pasándole como parámetro la división n/10, así obtemeos cifra a cifra el resultado inverso.
- El método fibonacci, se le pasa un long como parámetros. Si es 1 o 2, devuelve 1, sino devuelves la suma de los resultados de llamarse así mismo con el (numero – 2) y otro con el (num-1), como parámetros, obteniendo cada vez un número de la ya conocida serie de fibonacci!!
Aquí está lo que conseguimos!!jejej, la verdad es que nos enteramos bastante bien de lo que es y como se usan las hash table! y cuanto a recursividad parece que entendimos los métodos propuestos!jejje, lástima que para cuando quisimos hacer el ejercicio 3 de recursividad nos quedáramos sin tiempo, pero que queréis que os digamos, prefiero una hora de explicación a una hora perdido leyendo la práctica sin saber que hacer!!jejje
Bueno gentecilla, espero que a lo largo de esta semana, podamos acabar el ejercicio de recursividad y lo pongamos por aquí.
Un saludo y hasta la próxima!!!
Escrito en Prácticas
Hey Hey Hey!!! vamos a comentar un poco sobre el juego que vamos a realizar para esta asignatura, que por si no lo sabéis es el mítico “comecocos”, que por no pagar copyright deberíamos haberle cambiado el nombre, pero.. nos sobra el dinero!!!jajaja
Bueno centrándonos en el juego, como ya sabéis, esta semana hay que hacer la primera entrega, en la que más o menos deberíamos mandarles una pequeña idea de qué es lo que queremos hacer, pero seguro que alguno ya le tiene casi terminado!!jejej
Poco a poco nosotros hemos ido añadiendo cosas que o bien nos han ido enseñando en clase, o bien nos hemos tenido que buscar un poco la vida ( más bien mucho) jejje, porque bueno, la verdad es que no queríamos que se nos juntara con exámenes, y oye que tenemos algo de experiencia en eso de buscar información, no somos pioneros en esto!!jejeje
Nuestro juego consta de varias clases, y bueno, hasta ahora lo que llevamos hecho es la creación de los fantasmitas y la del protagonista, y estas dos clases heredan de una clase padre que hemos llamado individuo, ya que estas dos anteriores tienen un patrón bastante parecido!!
Luego, hemos conseguido dar un poco de libertad a estos personajes, pero de momento no les hemos visto moverse jejej, simplemente les hemos definido cómo tienen que moverse, utilizando una lista de movimiento para enemigos, dándoles un poco de inteligencia a los fantasmitas!!jejeje
Ahora nos queda hacer el tablero, las casillas, y a jugar!!!!jejjee
Ojala nos salga bien, porque llevamos muchas horas delante del ordenador!!:-(
Mucha suerte para los que estén intentando el juego!!! y cualquier duda si la podemos resolver, no dudéis en comunicárnoslo!!
Un saludo!!!
Escrito en Prácticas
Hey Hey Hey!!! creo que para muchos de nosotros la primera palabra cuando empezamos a leer la práctica fue, queeeeeeeeeeeeeeeeeeeeeeeeee???????? jajjaja, como se nota cuando nos hacen pensar a que sí??jejje, pues creo que todos andubimos igual..
Así que bueno empecemos por una pequeña introdución a esta práctica, que así, por si acaso alguien no se enteró bien en clase, esto le vendrá bien:
La semana pasada hicimos una cola con un array, pero todos sabemos que la clase cola de java es distinta:
entre otras cosas, no está hecha con un array y al constructor no se le pasa ningún tamaño (en cambio, la que hicimos nosotros, sí lo que lo hacía).
Reescribiremos la cola del otro día pero con memoria dinámica, pero, ¿qué cambios nuevos meteremos?
no debería cambiar el interfaz de la clase, tampoco tiene sentido que le entre un tamaño, lo mejor es que hagamos un constructor vacío, y ¿qué mas le meteremos? ¿cómo irán sus métodos?
- boolean estaLlena() ( no tiene sentido preguntarlo si está llena, porque no tiene tamaño fijo, es dinamico)
- void encolar( objeto o) ( que pasa si la memoria está llena?? Que lanza una excepción de memoria llena, pero ya lo hace java, así que nosotros no nos tenemos que preocupar xD)
- objeto desencolar() (¿qué objeto devuelve? El primero que hayas metido)
- boolean estaVacia() (comprueba si la cola está vacía)
Con estos métodos de aquí, ya puedes hacer la práctica, es básicamente rehacer lo mismo del otro día, pero en memoria dinámica, y ¿qué ventajas tiene esto?
- Aparte de que puedes meter lo que quieras sin preocuparte de dar un tamaño antes.
- La complejidad es importante, que es cuánto tardas en realizar una determinada operación, por ejemplo: si en mover un elemento de la cola tardo 3 segundos, el tiempo total empleado será el numero de elementos de la cola por el tiempo que tardo en mover cada elemento mas una constante que viene dada por los aspectos que rodean al programa. El numero de elementos siempre será menor que el tamaño de nuestra cola!! ( y esto es lo que pasa si tenemos una cola estática) La solución es no asignar la cabeza de la cola, y así lo único que tardaría sería, en buscar el elemento y extraerle, o sea, esa constante de antes.
- No es necesario un último para comprobar que la cola está vacía, si primero apunta a null, es que está vacía (puedes hacerlo así), aunque por otro lado es necesario un último, pero para cuando metemos un valor, para saber que tendremos que meterle en la posición “último + 1”
- ¿Qué pasa sino tengo un último? Que tengo que recorrerla, y claro, voy a tardar!!(entoces es mas complejo).Las estáticas reservan recursos que creen que van a necesitar, una de las ventajas es que las colas dinámicas no ocupan más memoria de la que van a necesitar. Con una estructura dinámica aprovecho la memoria y con una estática la desaprovecho.
Y ahora es cuando te preguntas por donde empiezo??? pues lo primero, desempolvamos nuestra práctica 6 y todo lo que tenga que ver con arrays lo tenemos que sustituir, por algo que se le parezca, así aquí nos toca pensar, jejejej.
Hacemos 3 clases, una con el main ( clase prueba), otra con la pieza y sus características (clase pieza), y luego, la más importante, la clase cola. En ella, vamos a tener:
public void encolar(Pieza p){
if (cola.estaVacia()==true){ //cola es un objeto de la clase cola
tamaño = ultimo; // si está vacía entonces el elemento que metamos será el primero
tamaño= tamaño + 1;
for (int i=0;i<tamaño;i++){ // falta completarlo para que empieces a meter elementos
}
}else{ //falta completar, porque sino está vacía también meterá elementos
tamaño = tamaño +1;
}
}
public pieza desencolar(){
if (cola.estaVacia()==true){
System.out.println(“La cola está vacía”);
tamaño = null;
}else{
return pieza;
tamaño = tamaño -1;
}
}
}
como habéis podido comprobar, nos falta lo esencial, como guardar esas piezas, bueno, nosotros nos rompimos el coco con el tamaño, a ver si nos podéis echar un cable ahora con esto! de todas formas, a lo largo de la semana, ya completaremos el código, lo que pasa es que hoy andábamos poco inspirados!jejjee
Un saludo, y hasta que actualicemos, por el momento aquí dejamos esto!!
Escrito en Prácticas
Cuanto tiempooooooooo!!jejeje, que tal fue la práctica?? la verdad es que estuvo un poco mal organizado a nuestro juicio, ya que habiendo dado la semana pasada colas y pilas, no entendimos, el porqué una semana despúés de haberlo dado, nos metían esta práctica, pero como quien dice, mejor tarde que nunca!!jjajaj
Nuestra primera impresión sobre la práctica fue buenísima: cómo??? solo 2 ejercicios?? yuhuuuuuu!!!jajjaa, luego descubrimos que ponía una hora en cada uno de ellos, pero daba igua!!jejeje, era el tetris!!!
Lástima, que graficamente no hicieramos nada, pero aún así sabíamos que era para el tetris, así como que trabajamos con más ganas!! se nos pedía desarrollar el algoritmo de caída de piezas durante el juego así como su previo relleno de piezas.
También podríamos hacer un generador aleatorio, que nos manda una pieza cuando la otra está bajando, y cuando llegue al final la saca.( esto es muy costoso), así que mejor las vamos a meter en una cola y luego las vamos a sacar, no nos interesa el orden, simplemente hay que pensar en la cola como un contenedor.
Si nos toca hacer la cola de piezas qué es lo que tenemos que hacer?? , qué clases vamos a utilizar??
y cómo lo hicimos nosotros, pues muy sencillo:
public class Pieza{
private char tipo;
private int x;
private int y;
public void Pieza(char tipo){
this.tipo = tipo; }
public void mover(){
System.out.println(“Empieza a mover!!!”); }
public String toString(){
String mov = “”;
mov = “La pieza es un”+tipo;
return mov; }
Pieza contenido[] = new contenido [100];
public boolean estaVacia(){
boolean s=true;
for (int i=0;i<contenido.length;i++){
if(contenido[i]!=0) s=false;
}
return s; {
public boolean estaLlena(){
boolean n=true;
for(int i=0;i<contenido.length;i++){
if(contenido[i]=0) f=false;
}
return f; {
public void encolar(Pieza p){
for (int i=0;i<contenido.length;i++){
if (contenido.estaLlena()){
System.out.println(“aaaaaaah perdiste!!!”);
}else{
contenido[i]=p;
}
}
public pieza desencolar(){
for (int i=0;i<contenido.length;i++){
if (contenido.estaVacia()){
System.out.println(“aaaaaaah ganaste!!!”);
}else{
return pieza; }
}
}
y aquí quedaría nuestro código, no es muy bueno, porque sabemos que el hecho de recorrer con un for cada vez que saquemos o metamos una pieza, relantiza, pero hoy en día hay buenos ordenadores así que no habría problema!!jejjeje, es nuestra primera cola!!:P luego la probamos y funcionó sin problemas, pero deberíamos haberla hechos sin el for!! y vosotros como la hicistéis??? Bueno pues no hay mucho más que contar, esperemos que salgan igual de bien todas las que nos quedan, así que ,mucha suerte!!
Un saludo!!
Escrito en Prácticas
Hola a todos!!! jo, esta vez nos hemos retrasado en publicar el post, y todo tiene una explicación…jjeje, no queríamos comentar sin antes haber acabado o al menos haber terminado casi toda la práctica, y es que andábamos por el ejercicio 2 cuando miramos el reloj y quedaban 10 minutos para acabar la clase.. y como que no era plan de ponerse a contaros tan poco!!jejej
Por fin las cosas estas que hacemos con el ordenador empiezan a dar su fruto, y quien no puso cara de felicidad cuand dio a ejecutar la clase del ejercicio 3.1 y derrepente apareció esa ventana con un cuadrado de colores!!!jjajaja
Pues esta práctica básicamente trata de polimorfismos, y el trabajo con interfaces. Hay 2 tipos de polimorfismos, de clase, y de método, el polimorfismo de clase es cuando un objeto puede comportarse como un objeto de una clase o de otra, y el polimorfismo de método es lo que responde a, ¿cómo sabe java que hacer cuando llamo a un método que dos clases le tienen igual? en este ejemplo está muy bien explicado:
public class Figura{
getArea();
}
public class Rectángulo extends Figure{
Rectángulo (Point A, Point B);
Rectángulo (Point A, int area);
float getArea();
}
//Si llamo al getArea() de una clase rectángulo, es distinto que llamar al método getArea() de la clase figura.
//Si le paso 2 puntos, me hace una cosa, y si le paso un punto y un área, entonces me usa el otro.
Luego también vimos el operador abstract y su función báscia principal,que se utiliza cuando quiero dejar métodos sin implementar, por ejemplo:
public class Figura{
abstract float getArea()}{
}
public class Rectángulo{ // aquí lo estoy usando, y “sobreescribiendo el método getArea()
float getArea(……)}{
}
Después vimos interfaces, y nos explicaron que en un interfaz solo se puede declarar métodos (no rellenarlos),se parecen mucho a las clases y sus atributos son de tipo final, ¿pero para qué los uso?
Hay 3 tipos de datos en java:
- las clases
- tipos básicos
- interfaz
Un objeto puede ser de tipo básico (int, float..), con referencias a clases (persona, figura..), y referencia a interfaces.
Se puede implementar un interfaz o extender un interfaz, es una manera de configurar las clases, de “colorear las clases”. Un interfaz es un “contrato” que firmas con el exterior, cuando tu haces por ejemplo:
public class Coche implements Guiable{
acelerar()
frenar()
girar a la izquierda()
….
}
Tu clase coche está obligado a cumplir unas ciertas normas, tu coche tiene que ser como diga el interfaz y luego ya le añades tú características.
No me importa lo que haga cada método, porque cada marca de coche acelera de una forma, frena de otra..,pero todos coinciden en que todos frenan, todos aceleran.., da igual la marca.
Una clase no puede extender de varias clases y puede implementar varios interfaces, pero un interfaz sí puede extender de varios interfaces
Y después de esta explicación teórica (que siempe viene bien saberlo) en teoría estábamos preparados para hacer la práctica..jejeje y aunque no se si a vosotros también os pasó pero ya el ejercicio 1 se hacía un poco largo. En él nos pedían que sobreescribiéramos el método toString() de la clase Clase, heredando lo ya escrito en la clase base, y añadiendo nosotros alguna anotación adicional que caracterizaba la clase, y así no tuvierámos que copiar todo el código ya heredado de la clase base, esto ahorra bastante tiempo, pero como lo hicimos? pues:
Public String toString() {
String str = “”;
str += “\nMETODO\t”;
//str += “Nombre = ” + nombre+”, MODIFICADOR = “+ Modificador.toString(modificadores);
//en vez de hacer todo esto, es mucho mejor que lo heredemos de la clase base, poniendo super.toString();
str += super.toString();
str += ” TIPO RETORNO = “+tipoRetorno;
if ( parametros != null ){
for (int i=0; i<parametros.length; i++)
str +=” PARAMETRO(“+i+”) TIPO= “+parametros[i].tipo;
}
return str;
}
de tal forma que así nos evitamos copiar de nuevo todo el código! es importante saber que hay ciertos caracteres en Java que significan varias cosas, por ejempñlo, el “+” ( operador aritmetico u operador concatenador). A la hora de pasarle un numero ya sabe que es un operador aritmético. Si le pasas un string te lo concatena. Por eso, si ponemos un string + (objeto, o cualquier cosa) automáticamente como se encuentra primero con un string sabe que el objeto o cualquier cosa hace referencia al metodo toString por defecto. Por eso podemos eliminar el metodo toString cuando hacemos referencia al objeto:
“hola!”+a1.tostring(); à lo podemos cambiar por “hola!”+a1, DA LO MISMO!!! J
Llegamos al ejercicio 2, y entre el API, y nosotros lo hicimos sin problemas, pero ahora llega lo dificil, lo que nos dio tiempo a hacer en clase, el ejercicio 3..mola, pero cuando te sale!! jejeje. Este ejercicio pedia API a gritos!! jajja, así le hicimos caso para mirar los métodos que teníamos que usar, para conseguir rellenar tanto el borde como el fondo de nuestro cuadrado, así que después de divagar un poco los encontramos a los 2 y nos pusimos a completar el código, eran fillRect() y drawRect(), y el método para establecer el color era setColor(), el resto era compilar, ejecutar, ojo con las mayúsculas, y.. pantalla con colores!!! jajjaja
Pero tuvimos un problema, cuando pusimos para hacer una prueba g.pintaFondo() y g.pintaBorde(), simprre salía en negro el fondo,pero caímos en que primero pusimos el fillRect() y luego el setColor, y el método que pintaba se ejecuta en función del orden de los métodos que van apareciendo, y nosotros lo teniamos al revés, nos pintaba el fondop antes de rellenar el color, por eso salía, el negro, porque es el que hay por defecto!
En el ejercicio 3.2, nos pedían “hacer” las clases Boton y Menu, y bueno, ya curtidos del anterior ejercicio, uno ya estaba mas inspirado, y como el ejercicio 1 nos sirvió de bastante vimos que el método paint tenía que pintar el boton usando paint de la clase padre, y esto nos salió casi sin pensar jajja, super.paint(g). Luego ya tuvimos que tirar de API, y encontramos el método necesario para escribir tano en el boton como en el menú setText(String texto), después añadimos las opciones al menú y bueno creo que por hoy ya basta, me enrollado demasiado!! jejeje, la proxima práctica se nos dará mejor..eso espero jejejje, espero que al menos las explicaciones vengan bien!
Un saludo a todos!!
Escrito en Prácticas
 | joyce en Acerca de |
 | jose william en Acerca de |
 | Jose Jesus en Últimas Valoraciones Del … |
| Jose Jesus en Octava Práctica |
 | pablotania en Octava Práctica |
