Hola a todos!!!!!!!

Vamos a comenzar a explicar la PENÚLTIMA práctica!!!!!!

Empezamos leyéndonos la introducción de la práctica. Cuando tuvimos bastante claro lo que íbamos a hacer empezamos con los ejercicios.

Con el primer ejercicio no tuvimos demasiado problema. Uno JFrame, un JPanel, un JButton y unos pocos conocimientos y ya está.

Con el segundo estuvimos un poco más de tiempo, aunque al final lo acabamos sacando. Tuvimos un problema en como cambiar el fondo, porque teníamos que hacer el fondo opaco y al principio pues no lo sabíamos, pero preguntamos a unos compañeros muy majos que teníamos al lado y rápido se dieron cuenta de nuestro problema y nos dijeron la solución. También nos dijeron que teníamos que poner el método setBackground (Color.RED), o el color que querías que cambiara. Con todo esto el problema se completaba y conseguimos hacerle.

El ejercicio 3, aparte de lo que te hace ahora cada vez que el usuario pulsara la tecla enter también tenía que cambiár la etiqueta. Es decir teníamos que meter 2 hilos, en vez de uno como en elejercicio anterior. Miramos la práctica anterior que trataba de hilos pero no llegamos a terminarlo, ya que se hizo la hora y nos tuvimos que marchar a clase.

Hasta aquí llegamos en la práctica, espero que os sirva de ayuda.

Hasta la próxima!!!!

Holaaaaaaaaaaa!!!!!

Volvemos otra vez a la carga después de algún tiempo, ya que entre puentes y acueductos no hemos tenido clase de prácticas en el laboratorio.

En esta práctica empezamos leyendo el ejercicio 1, en el nos trataba de explicar como actúa la CPU cuando tiene varios procesos a la vez para realizarse y como actúan cada uno de los procesos. Estos se piensan que están solos en la CPU y por eso no saben cuando son explusados de ella para que entre otro proceso. La CPU intenta ser proporcional en cuanto al tiempo que da a cada proceso. Después de entender todo esto copiamos la clase Ding, la compilamos y la ejecutamos; y efectivamente cada vez que pulsabamos el enter aparecía un Ding. Después copiamos la case Dong, la compilamos y la ejecutamos; y cada segundo aparecía un Dong. Después copiamos la case DingDongPoor y compilamos y ejecutamos, pero ERROR!!!!, no hace lo que le pedimos, lo que hace es que cada vez que el usuario presiona un enter aparece un DIng y al segundo un Dong. Si seguimos leyendo la práctica te va dando indicaciones de como lo debes ir haciendo.

Pasamos al ejercicio 2, y empezamos a leer que son los hilos. Los hilos sirven para que un programa realice varias tareas a la vez. Para lanzar un hilo se crea un objeto de la clase java.lang.Thread e invocar a su método start( ). El código que ejecutará ese hilo será el contenido en el método run( ), de un objeto que implemente la interfaz  java. lang. Runnable. Después de comprender esto, copiamos la clase TwoThreads, la compilamos y la ejecutamos. También hacemos lo mismo con TwoThreadsSimple y TwoThreadsSimple2 e intentamos comprender en que se diferencian y porque hacen lo mismo. Al final nos damos cuenta que en el primero es el que más código tiene porque implementa el run( ) dentro de la creación del objeto Runnable. La segunda clase implementa la interfaz Runnable, por tanto no hay que crear ningun objet Runnable, sino un objeto de la clase que estas haciendo y con lo cual el método run( ) lo implementamos dentro de la clase y no al crear el objeto Runnable como antes. Y en la tercera clase extendemos de Thread, por tanto no hay que crear ningun hilo sino que lo crea la clase, no como sucedía con los anteriores que en el main había que crear un hilo nuevo.

Hasta aqui llegamos en la práctica, asique el resto lo intentaremos hacer en casa.

Hasta la semana que viene.

Saludos otra semana más!!!!

Bueno deciros que esta semana se nos dió un poquito mejor que la otra (aunque tampoco era muy dificiñ ).

Empezamos con el ejercicio 1, el profesor nos estuvo explicando un poco que eran las tablas Hash. Con lo que nos explicó y con lo que habíamos dado en clase, nos pusimos a hacer una tabla Hash que implementara una serie de trucos para un videojuego, como por ejemplo, dame 3 vidas más, dame 1000 puntos más,… Esto no nos resultó muy dificil asi que la hicimos, compilamos, ejecutamos y a otra cosa mariposa,jejeje

En el ejercicio 2 tampoco tuvimos mucha dificultad, ya que solo había que constestar a unas preguntillas y el código te lo daban ya hecho. Además como era de contestar pues entre todos los que estábamos en clase y con ayuda del profesor pues lo fuimos haciendo. Este ejercicio nos sirvió para darnos cuenta en si de la recursividad, porque en clase la habíamos visto, pero como dice Jorge Ruiz: “hasta que no te pongas delante de un ordenador y te pelees con ella, no os vaís a enterar”, y tiene mucha razón.

Al ejercicio 3 ya no llegamos porque no nos dió tiempo, pero queda pendiente de terminarlo en casa jeje.

Hasta la semana que viene.

Hola a todos una semana mas.

Para ser sinceros, esta semana se nos ha dado un poquito mal la práctica por varios motivos. El primero es que llegamos a clase poco motivadas, no sabemos porqué, pero el caso es que llegamos sin ganas de hacer nada. Otro motivo es que al leernos la práctica vimos que tenía muy poco enunciado, y por tanto nos guiaban poco en lo que teníamos que hacer. Y otro motivo es que la clase no tuvo nada que ver con la anterior, ya que el profesor no nos guió, nos dijo que nos pusiéramos a hacerla pero sin ninguna indicación, no como en la anterior clase que, entre todos, estuvimos viendo todo lo que teníamos que hacer.

Por tanto, entre las pocas ganas que teníamos, lo poco que nos decían en la práctica y lo poco que nos indicó el profesor, pues, la verdad, es que hicimos mas bien poco, pero bueno de todas formas, os comentamos lo que llegamos a hacer.

Primero, nos leímos la práctica entera. Vimos que necesitábamos las clases que habíamos hecho en la anterior práctica, con lo que fuimos a ella y nos las descargamos. Después nos pusimos a pensar en qué era lo que nos pedían. Sabíamos que era más o menos un vector ya que lo habíamos visto en clase de teoría, con lo cual cambiamos el array de Cola de la práctica anterior por un Vector Cola de objetos Pieza. Ahí, nos paramos y estuvímos pensando que teníamos que hacer después, como no se nos ocurría nada, mirámos a ver en la clase Cola podíamos cambiar algo más, pero no veíamos nada. También estuvimos mirando los apuntes que teníamos sobre la clase Vector, pero tampoco se nos venía nada a la cabeza, asi que lo dejamos por imposible.

Si alguien más hizo algo le agradeceríamos que nos dijese que hizo y porqué y sino pues esperaremos a las soluciones y a ver si en la próxima práctica nos ponemos al día.

Un saludo y sentimos que en esta práctica nos os podamos haber ayudado como con las demás.

Hellooooooooo!!!!! Esta semana nos hemos adelantado, y después de la práctica nos hemos quedado para escribir el blog.

Esta práctica ha sido diferente a las demás, ya que el profesor nos estuvo guiando bastante tiempo porque consistía en empezar a implementar el juego del Tetris.

Al principio de la clase sacó a una chica (Biko por si alguien la conoce XD) para que escribiera en la pizarra todas las clases que se nos ocurrían que podía llevar el tetris. Además de los atributos y métodos que llevaban estas clases.

La primera clase que puso fue Pieza, decidimos entre todos que fuera abstracta y que modelaría el comportamiento general de todas las piezas. Se nos ocurrió que como atributos podía tener color y la posición en que se encontraba la pieza. Color nos dijo el profesor que no la pusiéramos porque complicaríamos demasiado en juego y de momento lo queríamos hacer “simple”, más tarde lo podríamos poner. Los métodos que tenía la clase era el constructor, un método mover, que de momento no lo implementaríamos, que servía para mover la pieza, otro método pintar, que tampoco lo implementaríamos de momento y otro método abstracto llamado quienSoy, que nos indicaría la pieza que es.

Después pensamos en otra clase llamada Cola en la que se almacenarían las piezas, por tanto, como atributos tiene un array de piezas y otros dos atributos de tipo int llamados primero y ultimo que corresponden al primero y ultimo de los elementos del array de piezas. Los métodos que contiene esta clase son encolar, para meter piezas en el array; desencolar, para quitarlas; vacia y llena, para saber si la cola esta vacia o llena; y siguienteIndice, para saber cual es la siguiente pieza que llega a la cola.

Luego, pensamos que tendría que haber otra clase con el main y desde donde comenzara el juego. A esa clase la llamaríamos Main. En ella implementaríamos los “estados” por los que tendría que pasar nuestro juego. El primero sería crear una cola, despues crear todas las piezas para poderlas encolar e imprimir de que tipo son con el método quienSoy, después desencolarlas y volverlas a imprimir.

Cuando terminamos esto, empezamos a pensar en los tipos de piezas que tiene el Tetris. Primero se nos ocurrió el cuadrado, asi que nombramos una clase llamada PiezaCuadrado que heredaría de Pieza. No tendría atributos, pero tendría que implementar el método quienSoy y el constructor. Esto lo hicimos con todas las demás clases (PiezaLinea, PiezaL, PiezaT y Pieza4invertida).  

En la próxima práctica se sigue con el juego, asi  que ya escribiremos nuestros avances.

Un saludo.

Hola a todos. Ya estamos aquí otra semanita más, para explicar un poco la práctica.

Esta práctica se nos dió un poco mal, ya que avanzamos poco, solo nos dió tiempo a hacer hasta el ejercicio 3.1. Bueno pero vamos a empezar por el principio.

Cuando llegamos cogímos un ordenador. El profesor (Pablo Basanta) preguntó si había gente que no se había leído la práctica y como si que había gente dejó 5 minutos para leerla. Después empezó ha hacer preguntas, algunas no supimos responderlas como por ejemplo “¿qué es polimorfismo?”, ahora mismo tampoco lo tenemos muy claro, si alguien nos puede ayudar se lo agradeceríamos; en cambio otras preguntas nos quedaron bastante claras, como por ejemplo “¿qué es sobrecarga de métodos?” o “¿qué es sobreescritura de métodos?”. También preguntó que era una clase abstracta y una interfaz, y aunque al principio tampoco teníamos mucha idea luego nos quedó bastante claro.

Una vez que se acabaron las preguntas nos pusimos en serio ha hacer el ejercicio 1. Al ver lo que teníamos que hacer, nos dimos cuenta que en la práctica pasada ya habíamos hecho lo que se nos pedía en esta, es decir, poner en las clases atributo método y constructor, super.toString() para que heredaran el método toString() de la clase Miembro ya que esta es la clase base. Después en la clase Clase modificamos miembros[i].toString() por miembros[i] y así sobreescribir el método toString de la clase Clase. También el la clase PruebaObjetos suprimimos cualquier referencia al método toString().

En el ejercicio 2, fue donde encontramos el mayor problema y fue el que nos retraso ya que no sabíamos hacer lo que se nos pedía. Nos descargamos la interfaz Almacenable y despues fuimos a la clase Clase y la modificamos para que implementara la interfaz, es decir pusimos:

public class Clase implements Almacenable

y depués intentamos implementar el método guarda pero no sabíamos fuimos al API a buscar información sobre FileWriter, pero aun así no sabíamos que teníamos que poner, así que llamamos al profesor y más o menos nos explicó que es lo que había que hacer, por lo que volvímos al API y  encontramos el método “write”, al final y después de darlo muchas vueltas logramos poner:

out.write(toString(),0,toString.lenght());

y que nos funcionara. Los parámetros que había que poner eran el primero, lo que querías escribir, el segundo, desde donde querías empezar a escribir y el tercero, cual era el tamaño de lo que ibas a escribir. Y así logramos terminar el ejercicio 2.

Con el ejercicio 3, nos descargarmos las clase ComponenteGráfico e implementamos el constructor. Después volvimos al API para ver como como pintábamos un rectángulo, una vez que encontramos como se hacía lo implementamos compilamos y ejecutamos y vimos que nos salí un rectángulo dentro de una ventana.

Y hasta aquí llegamos.

Saludos y hasta la próxima semana.

Hola!!!!!!! ¿Qué tal las vacaciones? Espero que os hayan ido tan bien como a nosotras.XD

Bueno vamos a comentar que tal nos fue en la práctica del viernes pasado, que ya casi ni nos acordamos, pero haremos un esfuerzo.

Cuando llegamos a clase, dimos un par de vueltas hasta que encontramos un ordenador que funcionase (como siempre, pero ya estamos acostumbrados). Nos pusimos a leer la introducción y nos dimos cuenta que nos acordabamos de algo de herencia, ya que nosotras lo habíamos visto en la asignatura de RDA del año pasado. Creemos que el profesor lo tenía que haber explicado un poco más a fondo, porque aunque nos suene, los nuevos no tienen ni idea y nos hubiera venido bien a todos.

Después de leer la introducción nos pusimos manos a la obra. Creemos que poner una introducción en todos los enunciados de las prácticas nos viene muy bien porque te explica a grandes rasgos toda la práctica y te sirve para “ponerte en situación”.

En el ejercicio 1 nos descargamos la clase Modificador y el esqueleto de la clase Miembro e implementamos el constructor y el método toString sin ningún problema.

En el ejercicio 2 nos descargamos la clase Atributo. Esta clase heredeba de Miembro, por lo tanto teníamos que usar el super(), para poder heredar. También implementamos el constructor y el método toString(). Cuando fuimos a implementar el método toString() no sabíamos como heredar el mismo método de la clase Miembro, pero haciendo un poco de memoria nos acordamos que era asi: super.toString().

En el ejercicio 3, primero nos descargamos la clase Parámetro y después el esqueleto de la clase Método que también heredea de Miembro. Para implementar el constructor tampoco tuvimos ningún problema ya que es igual que todos, en cambio para implementar el método toString(),nos atascamos un poco porque no sabíamos que teníamos que hacer con el array de parámetros, pero pensando lo arreglamos con un bucle for.

El ejercicio 4, era un poco repetitivo. Ya que nos descargamos también el esqueleto de la clase Constructor, esta clase heredaba de Método. Implementamos el constructor, pero en el tipo de retorno, dentro del super, tenías que poner que no tenía y el método toString() lo heredamos directamente de la clase base Método.

En el ejercicio 5, llegaron los problemas porque no sabiamos que teníamos que hacer. Entonces fue cuando llamamos al profesor y nos dijo más o menos lo que había que hacer. Después de dar muchas vueltas logramos sacar los métodos getAtributos(), getConstructores() y getMétodos(). También empezamos a hacer el método esEjecutable(), pero no nos dió tiempo a acabarlo, así que hasta aquí hicimos.

Esto es todo y esperamos que os sirva de ayuda.

Hola a todos!!!!!!!!

Ya estamos aquí para comentar,otra vez, que nos pasó en la práctica del viernes.

Empezamos por el ejercicio 0, lo primero que hicimos fue descargarnos la clase Punto. Después el profesor (Pablo Basanta) nos estuvo preguntando uno por uno cada una de las preguntas. Esto estuvo bien ya que pudimos participar todos, o la gran mayoría. Las preguntas no tenían mucha dificultad. Después programamos la clase PruebaObjeto, no tardamos mucho en hacerlo ya que era bastante fácil.

A continuación, nos leímos la parte de introducción y comenzamos a hacer el ejercicio 1, también nos tuvimos que descargar la clase Modificador y a partir de ella empezamos a trabajar. Primero la compilamos y la ejecutamos y le metímos como constantes varios números y nos salía los nombres de los modificadores a los que correspondían.

Luego empezamos con el ejercicio 2, también nos descargamos la clase atributo e implementamos el constructor y el método toString(). El principio de leer el ejercicio no sabíamos exactamente lo que nos pedía pero luego, la volvímos a leer y tampoco nos resultó tan dificil.

El ejercicio 3, era parecido al anterior, los métodos que te pedían eran muy parecidos a los de la clase atributo, asi que tampoco tardamos mucho, ya que no teníamos que pensar demasiado por que ya lo habíamos hecho antes.

El ejercicio 4 no nos dió tiempo a terminarlo, pero conseguimos hacer los métodos get del atributos, constructores y metodos. Y cuando empezamos a hacer el método toString() terminó la clase y nos tuvimos que ir.

Espero que os sirva de ayuda y si quereís que os pasemos los códigos nada más que nos lo digaís.

Un saludo y espero que nos dejeís algún comentario XD,jeje.

Hasta la semana que viene!!!!!!

Ya estamos aquí otra vez, para comentar que tal nos fue en la segunda práctica. Cambiamos de aula y nos fuimos con Pablo Basanta para ver como explicaba y si nos gustaba más la manera de dar clase.

Esta vez, al llegar al laboratorio no tuvimos problemas con los ordenadores.

Con el primer ejercicio no tuvimos ningún problema, creamos un directorio temporal, añadimos el path y comprobamos que funcionaba java y javac. Después abrimos el API de java y buscamos la clase java.lang.Math. También contestamos las preguntas. Para la ecuación de segundo grado necesitabamos el método “pow” y “sqrt” y el método que nos devuelve valores aleatorios es el “random”.

El ejercicio 2 tampoco nos resultó demasiado complicado. Compilamos el código de ErrorDivisión y no nos dió ningún error, después al ejecutarlo nos dimos cuenta que el código finalizaba en “Vamos a ver si el programa divide bien” y daba la excepción “java.lang.ArithmeticException: /by zero”. Cuando añadimos una aserción al código dejo de producirse la excepción. La aserción fue la siguiente:

if (d<0) {  

System.out.println("Error: valor negativo de d");  

System.exit(1);  

}

El crear la clase LogTrace tampoco nos supuso mucho problema. Los dos métodos los hicimos estáticos para no tener que crear ningún objeto. Al final la clase nos quedo así:

public class LogTrace{

public static void assertion(boolean condicion, String message){
if(condicion){
System.err.println(message);
System.exit(1);
}
}
public static void log(String message){
System.err.println(message);
}}

Luego utilizamos la clase LogTrace en ErrorDivisión para quitar las aserciones que habíamos puesto antes. Por tanto el código se simplifico bastante. También sustituímos los valores por aleatorios, pero como no creamos en el ejercicio 1 la clase Math, pues lo hicimos directamente en el código. En el ejercicio 3 nos resulto más complicado, ya que al principio no entendiamos que habia que hacer y después, cuando lo entendimos, no sabíamos como hacerlo. Después de mucho pensar y que nos echara una ayudita el profesor conseguimos sacar algo en claro. Aunque lo hemos estado repasando nos da error y ya no sabemos que más hacer. Os dejamos el código y si a alguien se le ocurre algo pues que nos lo diga.

import java.io.File;
public class Cp{

public void copy(File src, File dst) {
InputStream in = new FileInputStream(src);
OutputStream out = new FileOutputStream(dst);// Transfer bytes from in to out
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
in.close();
out.close();
}
public static void main(String args[]){
File f = new File(“aa”);
File f1 = new File(“bb”);
(new Cp()).copy(f,f1);
}
}

Muchas gracias de antemano y espero que os sirva.

Y esto es todo ya que no nos dio tiempo a hacer más.

Nos vemos la próxima semana.

Ya estamos aquí otra vez para comentar la primera clase en el laboratorio de prácticas.

Al llegar a clase nos encontramos con un problema importante, ¡no había ordenadores libres que funcionaran!, pero al cabo de un par de minutos encontramos uno y nos pusimos en funcionamiento.

Cuando llegó el profesor (Alberto Cortés) nos dijo como iban a ser sus clases y que iba a cambiar un poco el método del año pasado, en vez de hacer la práctica cada uno por su cuenta y preguntarle si tenías dudas, este año íbamos a hacerlas todos juntos, eso me parece bien ya que vamos todos al mismo ritmo y se solucionan las dudas conjuntamente.

Empezamos con el ejercicio 0, que después de una explicación del profesor, que nos ayudó a aclarar algunos conceptos, como el path, terminamos sin ninguna complicación.

El ejercicio 1 también lo solucionamos muy rápido, primero compilamos y ejecutamos el código que nos ponía el enunciado y después para hacer el apartado 4 utilizamos un bucle.

Los dos primeros aparatados del ejercicio 2 eran fáciles. El siguiente nos atascamos un poco, pero al final echándole un poco de lógica y preguntando a algún compañero logramos sacarle. Y en el apartado 4 tampoco tuvimos ningún problema.

Hasta aquí nos dio tiempo de hacer en la clase de prácticas, a nosotras nos parece que ponen demasiados ejercicios para el tiempo que dan; y ya se que hay que trabajar también fuera de clase, pero es que no llegamos ni a la mitad de la práctica.

Los demás ejercicios los haremos en alguna hora libre que podamos quedar algunos compañeros, ya que es más ameno y nos podemos resolver las dudas unos a otros.

Un saludo y hasta la semana que viene.

To be continued…….