import java.awt.* ;

import java.awt.event.* ;

import javax.swing.* ;

public class Juego extends Jframe implements KeyListener{

JPanel p = new JPanel();

int barrax=200; //especifico la posición en x donde estará la barra

int barray;

int pelx; // posición en x de la pelota

int pely; // posición en y de la pelota

float dirx=1; // nos dirán si tiene que cambiar de dirección la pelota cuando rebote en las

float diry=1; // paredes

int puntos=-1; //se inicializa a –1 porque cuenta el toque de comienzo

boolean comienzo=false;

public Juego(){

super(“El Juego de la pelota”);

setSize (500,400);

getContentPane().add(panel);

pelx=250;

pely=this.getHeight()-60;

addKeyListener(this);

}

//Se dibujan la barra y la pelota, no sabía cómo hacerlo, busqué en API e Internet y lo hice así:

public void pintar(){

Graphics gr=panel.getGraphics(); //todo los dibujos que haga irán al panel

gr.clearRect(0,0,thisgetWidth(),this.getHeight()); //con esto se borra la estela que va dejando la

//pelota y la barra al moverse

gr.setColor(Color.yellow); //le doy color a la pelota

gr.fillOval((int)pelx,(int)pely,20,20); //así hago la pelota

gr.setColor(Color.black); //color del borde de la pelota

gr.drawOval((int)pelx,(int)pely,20,20); //borde de la pelota

gr.setColor(Color.blue); //le doy color a la barra

gr.fillRect((int)barrax,(int)barray,100,50); //así hago la barra

gr.setColor(Color.magenta); //color para la letra

gr.drawString(“Puntos Conseguidos:”,200,15);

gr.drawString(String.valueOf(puntos),325,15); //aquí irá el contador de puntos

gr.setColor(Color.cyan);

gr.drawString(“————————————————————————-”,1,21);

//esta línea va justo debajo de la puntuación y es donde rebotará la pelota arriba

} //Fin pintar()

public void mover(){

if(comienzo==true){

}else{

pelx=2*dirx;

pely=2*diry;

}

if(pely>this.getHeight()){ //cuando fallamos

comienzo=false; //paramos el juego

puntos=-1; // inicializamos los puntos

barrax=200; //pongo la barra en su sitio de origen

}

if((pely==barray)&&(barrax<pelx)&&(pelx<barrax+80)){

puntos++; // aumento los puntos cuando coincide barra y pelota

diry*=-1; //cambiamos sentido

}

if ((pelx<0)|| (pelx>this.getWidth()-20)){

dirx*=-1; //para que vaya en sentido opuesto

}

if(pely<20){

diry*=-1;

}

if(barrax>this.getWidth()-80){ //para que la barra no se salga de la ventana

barrax=this.getWidth()-80;

}

barray=this.getHeight()-50; // eje y por donde se mueve la barra

} //Fin mover()

public void mostrar(){

while(true){

this.mover();

this.pintar();

try{ // pongo esto para que la pelota no vaya tan rápido

Thread.sleep(45);

}catch(InterruptedException IE){}

}

} //Fin mostrar()

public static void main(String args){

Juego juego=newJuego();

juego.mostrar();

juego.setVisible(true);

juego.show();

juego.setDefaultCloseOperation(EXIT_ON_CLOSE);

juego.setResizable(true);

juego.requestFocus();

juego.pack();

} //Fin main

public void keyPressed(KeyEvent e){

if(comienzo==false){

if((e.getKeyCode()==KeyEvent.VK_LEFT)&&(barrax>0))

barrax–;

if((e.getKeyCode()==KeyEvent.VK_RIGHT)&&(barrax<(500-1)))

barrax++;

}

}

public void keyReleased(KeyEvent e){}

public void keyTyped(KeyEvent e){}

} // Fin clase Juego

Saludossss!!

Enunciado:

Tenemos que programar una cola empleando una lista enlazada, con los siguientes métodos:

-encolar elementos(public void enqueue(tipoElem elemento))

-desencolar elementos( con el método dequeue)

-método que diga si la cola está vacía (al ser una lista dinámica, jamás se puede llenar, luego el método que nos dice si está llena la cola, no existe)

-método que imprime por pantalla todo el contenido de la cola.

Nuestra cola almacenará pilas, es decir, tenemos que programar una clase Pila que contenga los siguientes métodos:

-método para introducir un elemento en una pila(push)

-método para extraer un elemento de una pila(pop)

-método que indique si la pila está vacía

-método que indique si la pila está llena

-método que imprima por pantalla el contenido de la pila.

A su vez, cada pila almacenará vectores, habrá un vector en cada una de las posiciones de cada pila, es decir, cuando invoquemos los métodos push y pop, introduciremos un vector y nos devolverá un vector, respectivamente.

 *He hecho el esquema con un dibujito…pero no sé cómo meterlo aqui, lo siento.

Conceptos fundamentales:

Listas enlazadas(dinámicas): Es una lista de datos que puede crecer o disminuir con el tiempo. Estas listas son un conjunto de ‘cajas’ enlazadas, las cuales contienen objetos guardados. El objeto nodo es donde metemos lo que queremos añadir (en este caso pilas), es un envoltorio. La clase Nodo tiene 2 atributos, uno es el objeto guardado(no es que esté guardado físicamente, sino que hay una referencia a dicho objeto) y otro es la referencia, objeto de tipo Nodo ya que apunta a otro nodo.

Cola y Pila: Son estructuras de datos básicas que permiten almacenar elementos, estableciendo un orden de llegada y salida. Utilizan las políticas de inserción/obtención de elementos FIFO y LIFO, respectivamente

Solución:

//clase Pila

import java.util.Vector ;

import java.util.Enumeration;

public class Pila{

private int numVectores;

private Vector vectores[]; //Array de tipo Vector

private int indice; //apunta al ultimo vector insertado

public Pila (int numVectores){

this.numVectores=numVectores;

indice=-1;

vectores=new Vectores[numVectores];

}

//pila vacia

public bolean vacia(){

return(indice== -1);

}

//pila llena

public bolean llena(){

return(indice==numVectores-1);

}

public void push(Vector vector){

indice++;

vectores[indice]=vector;

}

public Vector pop(){

Vector vector=vectores[indice];

indice–;

return vector;

}

public void imprimir(){

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

System.out.println(this.get(i)+”,”);

}

}//fin clase Pila

//Clase Nodo

public class Nodo{

private Nodo nodoSiguiente;

private Pila ppila;

public Nodo(){

nodoSiguiente=null;

ppila=null;

}

public Nodo(Pila pila,Nodo n){

ppila=pila;

nodoSiguiente=n;

}

public void setPila(Pila pila){

ppila=pila ;

}

public void setSiguiente(Nodo n){

nodoSiguiente=n;

}

public Pila getPila(){

return ppila;

}

public Nodo getSiguiente(){

return nodoSiguiente;

}

}//fin clase Nodo

public class Cola{

Nodo superior=null;

Nodo inferior=null;

public void enqueue(Pila pila){

if(pila !=null)

Nodo n=new Nodo();

n.setPila(pila);

if(inferior!=null){

inferior.setSiguiente(n);

inferior=n;

}else{

superior=inferior=n;

}

public Pila dequeue(){

if (superior=null)

return null;

Pila pila=superior,getPila();

superior=superior.getSiguiente();

if(superior==null)

inferior=null;

return pila;

}

public boolean vacia(){

return (superior==null);

}

public void imprimir(){

if (vacia()){

System.out.println(“La Cola está vacía”);

}else{

System.out.println(“Dame un elemento (pila) de la cola:”+dequeue().imprimir());

}//fin else

}//fin imprimir

}//fin clase Cola

Documento1 (El enunciado)

Consiste en un juego de rol, el cual dispondrá de 4 clases y una interfaz.

Primera clase:

Personaje: Recoge las características generales comunes a cualquier tipo de personaje. Se tendrá que programar de forma que no se puedan crear instancias (objetos) de esta clase, es decir, será una clase padre abstracta cuya principal utilidad es ser heredada por clases hijas.

       Información:  Vida del personaje.

       (Atributos)     Fuerza.

Inteligencia.

Astucia.

Vigor inicial: Esta característica tendrá en todo momento el mismo valor para todos los personajes, esto es, si alguno cambia su vigor, el nuevo valor cambiará para todos, luego lo pondremos static y lo inicializaré a cero.

Métodos: Constructores varios: Además de inicializar la información del personaje, deberán tomar nota del objeto que los llamó, para poder  llamarlo más tarde. Aquí aparecerá la sobrecarga de métodos.

                  Un método imprimir sin implementar, es decir, será abstracto.

                  Métodos de acceso a la información (atributos), los cuales tendrán que hacer saber al método personajeCambiado(Personaje) todo cambio que se produzca en la información de cada personaje. En esta clase no pongo el método personajeCambiado(Personaje).

Segunda clase:

Guerrero: Guardará la misma información y tendrá los mismos métodos que Personaje, es decir, hereda de Personaje, y además añadirá atributos y métodos de la propia clase:

Atributos: Habilidad.

                 Puntería.

     Una variable que lleve la cuenta de cuantos guerreros hay en cada          momento

Métodos: Un método imprimir() que imprima por pantalla toda la información           del guerrero. Aquí lo que hace es implementar el método imprimir() de la clase Personaje ya que es abstracto y Guerrero hereda de Personaje.

Tercera clase:

Maga: Guardará la misma información y tendrá los mismos métodos que Personaje, es decir, hereda de Personaje, y además añadirá atributos y métodos de la propia clase:

Atributos: Magia

                 Poder de la luz

                 Una variable que lleve la cuenta de cuantas magas hay en cada                momento.

Métodos: Un método imprimir() que imprima por pantalla toda la información de la maga. Aquí lo que hace es implementar el método imprimir() de la clase Personaje ya que es abstracto y Maga hereda de Personaje.

Además, la clase Maga implementa la interfaz Hechicero, es decir,    implementa todos sus métodos.

Cuarta clase:

Clase Prueba: El método “main” de esta clase de prueba dará un valor inicial al vigor de los personajes, tanto el método main como el vigor son static, después procederá a crear una maga (¡CUIDADO!,no podemos crear instancias de Personaje, lo haremos así: Personaje maga1= new Maga (…parámetros en Constructor…) ; ). Debe incluir también un método personajeCambiado(Personaje), que simplemente imprima por pantalla las características del personaje cambiado, aquí imprimiremos los nuevos valores de los atributos.

Interfaz

Hechicero: Tiene dos métodos:

                        Doblar magia y Doblar poder de la luz.

 Documento 2 (Solución, con varios fallos creo)

public abstract class Personaje{

//Atributos

int vidaPersonaje;

int fuerza;

int inteligencia;

int astucia;

static int vigorInicial;

//Constructores

public Personaje(){

}

public Personaje( int vidaPersonaje, int fuerza, int inteligencia, int astucia, int vigorInicial){

vidaPersonaja= nuevaVidaPersonaje;

fuerza=nuevaFuerza;

inteligencia=nuevaInteligencia;

astucia=nuevaAstucia;

vigorInicial=0; // inicializamos a 0

}

//Métodos de acceso

public int dameVidaPersonaje(){

return vidaPersonaje;

}

public int dameFuerza(){

            return fuerza;

}

public int dameInteligencia(){

            return inteligencia ;

}

public int dameAstucia(){

            return astucia;

}

public int dameVigorIncial(){

            return vigorIncial;

}

public void nuevaVidaPersonaje(int vidaPersonaje){

            vidaPersonaje = nuevaVidaPersonaje;

}

public void nuevaFuerza(int fuerza){

            fuerza=nuevaFuerza;

}

public void nuevaInteligencia(int inteligencia){

            inteligencia=nuevaInteligencia;

}

public void nuevaAstucia(int astucia){

            astucia=nuevaAstucia;

}

public void nuevaVigorInicial(int vigorInicial){

            vigorInicial=nuevaVigorInicial;

}

//Método que imprime por pantalla la información, sin implementar

public abstract void imprimir();

}//fin de la clase Personaje.

public class Guerrero extends Personaje{

int habilidad;

int puntería;

int numGuerreros=0; // inicializamos a 0

int numTotalGuerreros;

public Guerrero(){

super();

habilidad=0;

puntería=0;

numGuerreros=0;

}

public Guerrero(int vidaPersonaje, int fuerza, int inteligencia, int astucia, int vigorInicial, int habilidad, int puntería){

super(vidaPersonaje, fuerza, inteligencia, astucia, vigorInicial);

habilidad=nuevaHabilidad;

puntería=nuevaPuntería;

numGuerreros++; //incrementamos el número de guerreros

numTotalGuerreros= numGuerreros;

}

public int dameHabilidad(){

            return habilidad ;

}

public int damePunteria(){

            return punteria;

}

public int dameNumGuerreros(){

            return numTotalGuerreros ;

}

public void nuevaHabilidad(int habilidad){

            habilidad=nuevaHabilidad;

}

public void nuevaPunteria(int punteria){

            punteria=nuevaPunteria;

}

public void imprimir(){

System.out.println(“Vida del Guerrero”+ dameVidaPersonaje());

System.out.println(“Fuerza del Guerrero”+ dameFuerza());

System.out.println(“Inteligencia del Guerrero”+ dameInteligencia());

System.out.println(“Astucia del Guerrero”+ dameAstucia());

System.out.println(“Vigor Inicial del Guerrero”+ dameVigorInicial());

System.out.println(“Habilidad del Guerrero”+ dameHabilidad());

System.out.println(“Puntería del Guerrero”+ damePunteria());

System.out.println(“Nº total de guerreros”+ dameNumGuerreros());

}

}//fin clase Guerrero

public interface Hechicero{

int magia;

int poderLuz;

public void doblarMagia(int magia);

public void doblarPoderLuz(int poderLuz);

}// fin de la interfaz

public class Maga extends Personaje implements Hechicero{

int magia;

int poderLuz;

int numMagas=0;

int numTotalMagas;

public Maga(){

super();

magia=0;

poderLuz=0;

numMagas=0;

}

public Maga(int vidaPersonaje, int fuerza, int inteligencia, int astucia, int vigorInicial, int magia, int poderLuz){

super(vidaPersonaje, fuerza, inteligencia, astucia, vigorInicial);

magia=nuevaMagia;

poderLuz=nuevaPoderLuz;

numMagas++; //incrementamos el número de magas

numTotalMagas= numMagas;

}

public int dameMagia(){

            return magia;

}

public int damePoderLuz(){

            return poderLuz;

}

public int dameNumMagas(){

            retunr numTotalMagas ;

}

public void nuevaMagia(int magia){

            magia=nuevaMagia;

}

public void nuevaPoderLuz(int poderLuz){

            poderLuz=nuevaPoderLuz;

}

public void doblarMagia(int magia){

magia= 2*magia;

}

public void doblarPoderLuz(int poderLuz){

            poderLuz=2*poderLuz;

}

public void imprimir(){

System.out.println(“Vida de la Maga”+ dameVidaPersonaje());

System.out.println(“Fuerza de la Maga”+ dameFuerza());

System.out.println(“Inteligencia de la Maga”+ dameInteligencia());

System.out.println(“Astucia de la Maga”+ dameAstucia());

System.out.println(“Vigor Inicial de la Maga”+ dameVigorInicial());

System.out.println(“Magia de la Maga”+ dameMagia());

System.out.println(“Poder de la luz de la Maga”+ damePoderLuz());

System.out.println(“Nº total de magas”+ dameNumMagas());

}

public class ClasePrueba{

public static void main (String args [ ] ){

            int valorIncial; // el main le da un valor por defecto

            Personaje maga1 =  new Maga( 500,60,1000,800,2,2000,1500);

           }

public void personajeCambiado(Personaje p){

p.nuevaVidaPersonaje(400);

p.nuevaFuerza(70);

p.nuevaInteligencia(950);

p.nuevaAstucia(900);

p.nuevaVigorInicial(10);

p.nuevaMagia(4000);

p.nuevaPoderLuz(2000);

}

maga1.nuevaVidaPersonaje(500);

maga1.nuevaFuerza(60);

maga1.nuevaInteligencia(1000);

maga1.nuevaAstucia(800);

maga1.nuevaVigorInicial(2);

maga1.nuevaMagia(2000);

maga1.nuevaPoderLuz(1500);

personajeCambia(maga1);

System.out.println(“Nueva Vida de la Maga”+ maga1.dameVidaPersonaje());

System.out.println(“ Nueva Fuerza de la Maga”+ maga1.dameFuerza());

System.out.println(“Nueva Inteligencia de la Maga”+ maga1.dameInteligencia());

System.out.println(“Nueva Astucia de la Maga”+ maga1.dameAstucia());

System.out.println(“Nuevo Vigor Inicial de la Maga”+ maga1.dameVigorInicial());

System.out.println(“Nueva Magia de la Maga”+ maga1.dameMagia());

System.out.println(“Nuevo Poder de la luz de la Maga”+ maga1.damePoderLuz());

System.out.println(“Nuevo Nº total de magas”+ maga1.dameNumMagas());

}//fin de la clase prueba

 Documento 3 (Conceptos fundamentales.)

1.- La herencia (extends): Tenemos una clase padre llamada Personaje y dos clases hijas, Guerrero y Maga.

2.- La implementación (implements): Existe una interfaz llamada Hechicero, donde ninguno de sus métodos está implementado, luego la clase Maga que es la que implementa dicha interfaz (implements) es la encargada de implementar cada uno de sus métodos. Además, al ser la clase padre abstracta, tiene métodos abstractos, es decir, métodos que no están implementados, y son las clases hijas las que deben implementar estos métodos.

3.-Sobrecarga de métodos: Aparece tanto en la clase padre como en las clases hijas, en los métodos constructores. La sobrecarga se da cuando existen más de un método con el mismo nombre pero con diferente número de parámetros.

4.-Clase y métodos abstractos: Una clase abstracta no puede crear instancias, es decir, no se pueden crear objetos de esta clase, la única utilidad que tiene estas clases es que hereden de ella (como es el caso de nuestra clase Personaje). Las clases abstractas pueden tener métodos abstractos y métodos no abstractos. Las clases que hereden de una clase abstracta deberá implementar todos sus métodos abstractos.

Cuando queramos crear un objeto, teniendo como clase padre una clase abstracta, lo podremos hacer de la siguiente manera:

                        Personaje maga1= new Maga();

Con esto nos estamos refiriendo a que hemos creado un objeto Maga, que a su vez es un Personaje. Si pusiéramos: Personaje maga1 = new Personaje(); nos daría error, pues como ya se ha dicho antes, una clase abstracta no puede crear objetos.

5.-Elementos de clase (static): Así son llamados a los atributos y métodos precedidos por la palabra static. Sólo existe uno de dichos elementos para todos los objetos, por tanto, los elementos de clase son compartidos por todas las instancias de la clase. Si se modifica dicho atributo estático, todas las instancias de la clase ven dicha modificación.

Antes que nada pediros perdón por el retraso al subir esta práctica, pero hemos tenido problemas técnicos, jeje, ademas de muchas cosas que hacer, ya sabeis, por estas fechas. en fin, espero que os sirva de ayuda. Ahí va!

1.   (el breikindans)  Es simple, esperemos que sepais hacerlo puesto que sino, podriais empezar a preocuparos. Creamos la clase, como atributos un JPanel, un JButton y y un escuchador. Lo colocamos todo y añadimos el escuchador al boton. En la clase del escuchador, (del tipo ACTIONLISTENER) pondremos que cada vez que pinche dicho botón se haga un System.out.println(“apartado 1 correcto”);

2. (El Crusaíto)  Añadimos a la clase anterior una JLabel con el texto “pichame y verás”. Ahora quitamos el System. out..etc y ponemos un random, que genere valores entre 0 y 255 aleatorios. llamamos al random y el valor lo almacenamos en un entero a, lo volvemos a llamar y lo guardamos en b finalmente el tercer valor aleatorio se guarda en c. (EN EL API VIENE EL METODO RANDOM (clase MATH)).

Ponemos la JLabel como setOpaque(true); y cada vez que el boton reciba un pinchazo se ejecuta el codigo anterior y justo a continuación:

JLabel.setBackground(new Color(a,b,c));  

NOTA: importar la clase Color y Math!!

El hilo que ejecuta todo esto es el eventDispactched…o algo asi:) es el hilo por defecto de java (TEORIA)

3. (El maikelYaison) añadimos ahora la clase oyenteTeclado que implemente a KeyListener, esta clase recibe los eventos de teclado. Ponemos el metodo correspondiente (keyEvent….) y dentro de él añadiremos la tecla que realiza la acción:

/*en pseudocódigo*/

if

VK_ENTER

ejecutamos el mismo código que generaba el random en el ejercicion 2.

//fin

El código que genera el aleatorio puede ser introducido dentro de un método generaRandom() que devuelve el color. (ahorramos código que no está el mundo pa gastar)

4.(EL RO_BO_COP!) Muy parecido al dos. Utilizamos otra vez nuestro método generaRandom() y lo implementamos (su código) en la clase MultiColorButton. Esta clase hereda de JButton y simplemente incluye el escuchador, que indica que al ser pulsado la única accion  a realizar sea

setBackground(new Color(a,b,c));

5. Este sin apodo chikilicuátrico. En este punto la práctica da un salto de calidad, de los buenos, de esos que saben con tostada y mantequilla:)

bueno, hemos intentado hacerlo con una HastTable, es decir, la clave es el NIA y el valor es el nombre del alumno. Para interaccionar con el usuario hemos utilizado un JDialog que te pide el NIA y lo pasa a un método que busca en la TablaHash! funciona, pero es muy costoso de implementar!

La espera la hemos hecho con un Thread.sleep(5000); importando la clase Thread, al introducir el NIA y pretar el boton aceptar, se ejecuta el sleep(); y el sistema tarda 5 segundos en mostrar la respuesta.

abortQuery no tiene implementación ya que para nuestra dataBase esta espera es tan corta que no le da tiempo a ejecutar:$

6. No lo hemos llegado a implementar del todo, pero seria añadirle un botón que haga lo que hacia en el apartado 2. El de abortQuery, cuando se pincha este botón se ejecuta el código en el interior  del metodo abort, es decir Thread.stop() esto último no se si funciona porque no me ha dado tiempo a implementarlo!

De la composición gráfica, es lo de menos, liaros a hilos y dejar la presentación pa otro dia!!jeje

7. (EL NOTEPAD) jeje, parece mas dificil de lo que es, nosotros hemos decidido intentar hacerlo y..bueno, mas o menos se aprecia como tal.Ire por pasos.

1. El panel principal se divide en un BorderLayout.

• El Panel del NORTH es u n grid Layout de 10 x2 para poner todos los botones de la barra de herramientas. Este panel añadira (add) un array de 20 botones por orden, de forma que queden todos colocados.
• El panel CENTER es un JScrollPane, en el cual añadimos un JTextField. Así podemos poner la barra de scroll vertical y a la vez nos permite escribir.
• El panel SOUTH contiene 2 etiquetas, las cuales informan del número de páginas que llevas (aun no las cuenta ) y también informa si esta guardado el documento o no.

2. EL MENU

• Tal y como viene en el ejemplo de Teoria, implementamos el menú, añadimos la JMenuBar, y los JMenuItems, en nuestro caso solo hemos puesto: FILE|EDIT|HELP
• Cada uno de estos JMenuItems añade nuevos JMenuItem,

        FILE: añade, save (cambia el texto de la etiqueta a “guardado”), print(“imprime por pantalla normal que tienes que configurar la impresora”). Ahora tiene un add.Separator(), que separa estas opciones de la última que es exit (claro no? System.exit(0));

       EDIT: Copy,paste (sin acción

       HELP: Saca un cuadro de texto, por favor dirijase a tal email…

Y bueno,a grandes rasgos (pero que muy grandes) este seria el NOTEPAD! jeje

un saludo y ánimo a todos! ya estamos cerca del final!!!!!

Besos

Tania y Pablo

El ejercicio1 es comprensible y aceptable. Importante importar el java.io.IOException cuando queramos que nos lea desde el teclado (System.in.read()==’/n’ ) en este caso un Enter. Estuvimos comparando los 3 programas, en el apartado3 pensamos que tras salir Ding! saldria un seg.depués Dong! (tal y como es) pero que además seguiría saliendo Dong! cada segundo.Al compilarlo vimos claramente que no era así!!

El ejercicio2  nos explica que si has lanzado ya un hilo y quieres volver a lanzar otro, debes crear un objeto de la clase Thread e invocar al método start() de dicha clase. Observamos que en el apartado1 es asi como lo hace:       

1.          Thread t = new Thread(r);

2.               t.start();

Se crea un objeto de la clase Thread pasándole como parámetro el objeto anteriormente creado, que implementa la interfaz Runnable.

start() : hace que este hilo comience la ejecución, la máquina llama al método run() de dicho hilo. 

run() : cuando un objeto que implementa la interfaz Runnable es usado para crear un hilo, dicho hilo, al comenzar, llama por separado al método run() del objeto, y a la ejecución del hilo.

currentThread(): devuelve una referencia al objeto actual del hilo de ejecución

Al compilar este programa sale por pantalla los nombres de los hilos: main y Thread-0, podemos observar que el primer hilo que se ejecuta es el main y el segundo el Thread-0 aunque en el código hayamos llamado antes a Thread-0. Esto es debido a que no hay ninguna garantía de en qué orden van a ser ejecutados los hilos, ni  tampoco cuándo van a ser interrumpidos para dejar paso a otro thread.

En el apartado2 al implementar nuestra clase la interfaz Runnable, ya no es necesario crear un objeto que implemente esta interfaz, nos basta con crear un objeto de nuestra clase y pasársela como parámetro al objeto de la clase Thread posteriormente creado:

1.       TwoThreadsSimple tts = new TwoThreadsSimple();

2.               Thread t = new Thread(tts);

En el apartado3 como la clase hereda de la clase Thread, y sabemos que la clase Thread implementa la interfaz Runnable, directamente nuestra clase implementa dicha interfaz y no es necesario poner implements Runnable. Dicho todo esto, se crea un objeto de nuestra clase, sin pasarle nada como parámetro, y llamamos con este objeto al método star().

Para el ejercicio3 pensamos poner un sleep() o un timer para solucionar la condición de carrera…pero bueno, vemos que utiliza vectores y mete otro hilo evenDispacher, vemos algo lioso este ejercicio.

En el ejercicio4 vemos Swing como una biblioteca de multithread, donde aparece un nuevo hilo, el event-dispaching thread el cual se encarga de dibujar por pantalla. Desde aquí se hace cualquier cambio de componentes gráficos para evitar condiciones de carrera en las aplicaciones gráficas.

Hicimos sólo hasta el apartado1:

class BN{
       public static void main(String args[]){
         try {
            while(true){
               Thread.sleep(2*1000);

               //Thread.sleep(100);
               System.out.println(“WHITE”);
               Thread.sleep(2*1000);

               //Thread.sleep(100);
               System.out.println(“BLACK”);
            }
         }catch(InterruptedException e){
               System.out.println(“Interrupted while sleeping”);
            }
      }
   }

Hoy,antes de nada me gustaria resaltar la asistencia a clase, como alumno de 5ª convocatoria me gustaria intentar explicar algo que quiza no se entiende. Si yo fuera director coordinador o responsable de una asignatura, más allá de si es dificil o no, si es extensa en temario o no, intentaria hacerla interesante a los alumnos, que “se enganchen”, ante todo, no quiero decir que yo lo haria mejor, que no lo hagan bien, ni muchisimo menos, pero el viernes dia 25 de abril, en una de las clases de programación, éramos 5 alumnos. Si si, habeis leido bien, 5 alumos, ocupando 3 ordenadores, 4 de los 5 alumnos presentes éramos de 5ª y un chico que hizo la práctica nose en que convocatoria se encuentra. A mi, particularmente me resulta benefcioso este caso ya que tenemos al profesor para nosotros (es como un tutoria de dos horas pero con ordenador) pero creo que esto no es normal, nose, si la gente se borra de esta forma colosal sera por algo…digo yo:$

Vayamos ahora con la tutoria en forma de práctica.

En lo que viene siendo las dos horas lectivas, la verdad, estuvimos hablando con Pablo profe acerca de nuestro juego, tenemos que tratar eventos y no hay manera de conseguir capturar los eventos para tratarlos como nosotros queremos. Llevamos ya más de una semana anclados en este punto “facil” de juntar la parte lógica y la parte gráfica, horroroso.

También hablamos acerca de bolonia, del palo que nos van a meter a los que,como yo nos encontramos en medio de dos planes, con la uni favoreciendo un plan nuevo…un caos.

En cuanto la práctica, por fin empezamos en clase a ver Swing (yo nose la gente que sea la 1ª o 2ª vez que hace esta asignatura como hara su juego,si empezamos hoy con esto), en la intro se nos indica que la practica es larga de narices y que la hagamos aunque nos vaya la vida en ello. También explica algo acerca de las GUI’s de interacción con el usuario (los key listeners, los mouse listeners..etc API)

EJERCICIO 1:

1) Compilamos y ejecutamos el codigo de la GUI, y vemos una ventanita de java con una etiqueta en la que esta el texto de la JLabel.

2) Durante la ejecucion del main, se crean por este orden, un JFrame (marco) un JPanel (panel) y una JLabel (etiqueta), luego se añade la etiqueta al panel y se muestra el marco. NOTA: El JPanel es el que hay por defecto en java y hay que instanciarlo con getContentPane().

3) setDefaultCloseOperation(EXIT_ON_CLOSE);

Al pinchar en el aspa de cerrar la ventana la aplicacion y la GUI se cierran dando un 0 como resultado de una salida correcta (system.exit(0)) (equivale a pulsar ctrl + c en el cmd)

getContentPane()

Panel contenedor de java, tenemos que llamarlo puesto que es sobre el sobre el que se pintan todos los componentes

add()

añade un elemento a otro, en este caso, una etiqueta a nuestro panel

setVisible(true)

hace visible todo lo “pintado” anteriormente

setSize(X,Y)

establece en pixels el tamaño de la ventana

4) Lo que hace este pedacito de código realmente es lo siguiente. Importamos los paquetes correspondientes, creamos un Marco (JFrame), por herencia se le puede pasar por parámetro al constructor el titulo que saldrá sobre la ventana en la barra azul (para este blog seria JFrame = new JFrame(“Pablotania’s Weblog>”);) Luego creamos nuestro panel como el getContentPane () de java y creamos tambien una etiqueta con un texto (String). finalmente, añadimos la etiqueta al panel, ponemos el tamaño y lo hacemos visible

5) solo habria que cambiar en el método setSize(400,200);

6) Segun el API (JLabel…) tenemos el metodo setOpaque() para cambiar el fondo de la etiqueta (NO USAMOS EL setBackGround!)

7) Este codigo extra produce que el proceso de hacer la ventana visible se duerma 10 segundos (sleep (10 *1000)) y por lo tanto que salga mas tarde, ademas en caso de excepcion sale de la ejecucion indicando problemas (system.exit(1))

(arriba)

9) Si eliminamos las llamadas a setVisible y set size no veremos nada, pero la ventana estara creada en “la nada”, yo creo que se lanza un hilo por cada llamada a set… algo, por lo que tendremos dos.

10) El systema no habre la ventana puesto que saldria el setVisible 10 segundos despues de crearla y antes de que eso ocurra lee system.exit(0) y cierra la ejecucion sin excepciones:)

EJERCICIO 2:

Mojaditos de bucear en el API, explicamos que para cerrar una ventana sin el system.exit ni nigun metodo alternativo paramos la ejecucion en el cmd con ctrl + c.

para no decorarla ponemos el setUndecorated(true) y para utilizar el look&field de java usamos este otro setDefaultLookAndFeelDecoration(true), que decora la ventana como todas las de java, bastante majo:P

EJERCICIO 3:

Para cambiar el fondo de la etiqueta utilizamos setOpaque(), el texto se puede cambiar con setFontColor() o sino, con alternativas del API, para maximizar la ventana utilizamos el método definido marco.setMaximumSize(true); en caso de no poder utilizarlo como indica la práctica podemos usa setSize(1024,760);

2) utilizamos un setLayout(new BorderLayout()); que nos divide el panel en 5 zonas, norte,sur,este,oeste y centro. para colocar la etiqueta en la posicion deseada marco.add(JLabel, BorderLayout.CENTER/NORTH…). Con el metodo pack(); aseguramos la correcta colocacion de todos los elementos

Para añadir una imagen a la etiqueta, se declara la imagen con la ruta de acceso Icon imagen = new ImageIcon(“flecha.jpg”); y luego se añade a la etiqueta etiqueta.add(imagen)

Como hemos comentado anteriormente el metodo pack() asegura que todos los elementos de la ventana entren correctamente en los paneles etc.

EJERCICIO 4:

Para crear lo que vemos en la imagen, lo mas intuitivo que se nos ocurre es poner un grid layout de 1,19 y con un bucle for de 0 a 18 insertar el texto de las etiquetas. con una extructura if, vemos si es par setOpaque(Color.WHITE) y si es impar setOpaque(Color.BLACK); o al reves:$…jejeje

Y bueno,para el regalito final que nos han puesto, con paciencia se puede crear el LayoutManagerShow.java, yo lo he “hecho” pero no pondre aqui el codigo porque esto es demasiado largo ya e igual los de wordpress se rallan y nos echan,con arandanos Uc3m a la cabeza:P jaja! pensad que para crearlo, teneis que ir creando paneles segun pone en el ejemplo, es decir, de atras alante y con paciencia, mucha paciencia, vais declarando Jatributos a medida que los vais necesitando, cada panel contiene otro, y cada panel lo teneis que crear con mimo,y esas cosas

ESPERO QUE ESTE ROLLAZO OS SIRVA DE ALGO Y QUE DE VERDAD, PODAIS TIRAR PALANTE CON ESTA OCA ASIGNATURA, LA PRACTICA DE HOY ES DE ESAS POR LAS QUE UNO DECIDE DEJAR LA ASIGNATURA, Y DESPUES DE LO VISTO EN TEORIA ESTA SEMANA LA GENTE QUE NO HA TRATADO ESTO NUNCA DEBE ESTAR OJIPLATICA, PERO TRANQUILOS, SEGUID ASI QUE EN BOLONIA NO TENDREIS EL GUSTO DE VERME EL PELO POR ESTA ASIGNATURA,O LO MISMO NO TENEIS ASIGNATURA, NO QUIERO QUE NADIE SE OFENDA, PERO SINCERAMENTE, METER ESTE PRACTICON COMO PRIMERA PRACTICA DE SWING ES UNA PASADA PARA LA GENTE QUE EMPEZABA HOY,POR SI NO TENIAN MIEDO A LAS GUI’s HABEIS CAUSADO PANICO.

un saludo con cariño a absolutamente todo el mundo que lea mis 4 horas de curro un sabado por la mañana, aunque lo mismo no me de ni medio punto. Que paseis buen finde, yo seguire con la pata en alto, cuidaos!

TANIA Y PABLO

Empecemos por la práctica….Se divide en tres ejercicios,que a su vez se descomponen en dos grupos, uno dificil y uno facil:

En el grupo facil encontramos el ejercicio 1, que de manera juvenil y con lenguaje coloquial es bastante sencillo == esta chupao!, tenemos que implementar una tabla hash con acceso para 10 trucos de un supuesto videojuego…pues nada,nos ponemos el bañador,las gafas de nadar,las aletas y nos metemos en el API,ese mar,que esta frio de cojones y que a veces nos consigue ahogar…pero esta vez no! esta vez buscamos por la h, hashtable…

clickamos y ves esto:

Hashtable numbers = new Hashtable();
     numbers.put("one", new Integer(1));
     numbers.put("two", new Integer(2));
     numbers.put("three", new Integer(3));

Sencillo pasar esto a Strings, puesto que Integer es una clase como tal.Ponemos nuestros truquitos, vida,nextLevel,inmortal…etc, hacemos el “get” los trucos, y nos devuelve la frase correcta, todo perfecto!!

NOTA: Hay que importar java.util.Hashtable.*

En el EJERCICIO 2, estudiamos la recursividad que nos explicaron en teoria el lunes,nos dan metodos y mas metodos recursivos y nos preguntan sobre ellos…nosotros, conscientes de que estos,nuestros BLOGS son mirados con LUPA,disponemos a continuacion una selecta lista de respuestas elaborada por nosotros mismos con todo el cariño que nos transmitieron nuestros abuelos y con el que llevamos haciendo las cosas desde 1985…(en plan tarradellas:P)

METODO P1, p1(int a), comprueba que a>1, la imprime por pantalla y le resta uno, cuando a no es mayor a uno (a=0) se acaba el algoritmo,obtenemos una cuenta atras mazo graciosa:)

METODO P2, p2(int a, int b), comprueba,al igual que p1 que a es mayor que 0 para almacenar en b un nuevo valor correspondiente a la suma entre el anterior b y a (b+a) , cuando a=0, imprime b que es la suma de todas las sumas.

SUMA(long[]tabla,int posActual,int tamaño), si la posicion en la que nos encontramos actualmente es igual al tamaño menos uno del array tabla (es decir, estamos en la ultima posicion) nos devuelve el valor de que hay en la cima. Sinó nos devuelve lo que hay en la posActual restandole uno,para acabar imprimiendo la cima.(cada iteracion posActual suma un valor)

INVERSO(int n), pide un numero n para imprimir los numeros alreves, es decir si metes el 124,imprimira el 421. Esto lo hace comprobando si n>=10, si esto es asi,llama al método inverso pero pasa como parametro n el resultado exacto de la division n%10, obteniendo cifra a cifra el inverso.

FIBONACCI, fib(long num), “la serie de las flores” como dice Guille,si el num es 1 ó 2, devuelve 1, sino devuelves la suma de resultados de ejecutar fib(num-2)+fib(num-1), obteniendo asi el valor que hay en la posición n de la serie de este buen hombre.

Por otro lado, tenemos el grupo dificil de ejercicios,donde esta el ejercicio 3 que no pudo ser tratado puesto que dedicamos un ratito de clase a consultar acerca del juego a Pablo…nuestro pequeño gran dominó ya tiene logica e interfaz grafica,pero no sabemos como juntar las piezas!!!!!

Bueno, un saludito a todos, GOLFOS, golfitas,jovenes, mayores, radicales tira litronas y normales recibe mails…HOY ES VIERNESS!!!

YUM YUM

Pablo y Tania

public(para que lo pueda leer todo el mundo,está claro no?…;-)

Comenzamos la mañana…

Mi compi,Pablito, estaba liaillo con el juego haciéndole unas preguntitas a Pablo para que nos resolviera algunas lagunillas que teníamos con nuestro Dominó, asi ke ,aunque de vez en cuando le preguntaba dudas a Pablito y me ayudaba, me enfrenté prácticamente solita yo a la práctica!! Bueno, empecé con el ejercicio 1, el cual decía que teniamos que realizar algunos cambios en la clase Cola de la práctica anterior, donde hubiera arrays cambiarlos por vectores, y algunas cosillas más…Me atasqué en el método desencolar() ya que no sabia como escribir correctamente el método v.remove() del vector, y tampoco sabía bien que me tenía que devolver desencolar() ,yo ponía return pieza; y pum! error al canto…desesperaita ya, me solucionó el problemilla el compañero de atrás, nada pues, tenia que crear otro objeto de la clase Pieza, al cual le llamé pi  y  hacer un casting (Pieza) para que lo que me devolviera el vector fuera del tipo Pieza:

Pieza pi=(Pieza)v.remove(0)

Ejecuto la clase Main{} ,yo ya contentisima de la muerta que pensaba ke me habia salido ya el ejercicio 1 y me doy cuenta que me escribe siempre que la cola siempre esta vacia y nunca llena(lógico esto último, pues es un vector ahora, el cual no se llena, a diferencia que un array), luego IMPOSIBLE, pues la cola estaría sólo vacía en la ultima sentencia…asi ke, manos a la obra otra vez, a ver que tenia organizada en el maldito método! Cambié return(primero==ultimo) por  return v.isEmpty() y mano santa chicos, se resolvió mi problema!! jejeje.

Pablito ya había acabado con lo de nuestro juego, y empezamos a leer juntos el ejercicio 2, pero como el profe estaba ocupaillo con los demás compañeros, kienes tenian dudas con el ejercicio1 o con sus propios juegos, pues no le dio tiempo a explicar lo de los iteradores, asi ke empezamos a recoger xq sólo kedaban 10 minutos para acabar la clase y ni lo intentamos por nuestra cuenta…

Saludos a todos…

} //fin de la clase.

Pablo llega tarde a clase por motivos ajenos a su persona, y que no suene a excusa, por favor…Una vez realizada su entrada estan explicando herencia entre clases de tetris, Piezas, pieza cuadrado, pieza L…etc, algo sencillo.

También algun que otro metodo abstracto, a reescribir en las clases heredadas…Algo en teoria sencillo, pero claro, de ahí al tetris en si, hay algun salto. Yo no se si piensan,pensais o creen,  que somos entes increibles, que repetimos o tripitimos una asignatura por el mero hecho de que nos gusta o que, pero si yo que llevo unos añitos peleandome con esto, me quedé blanco (y creedme que es dificil) al leer la practica, la gente que haya entrado este año… ahora entiendo mi pregunta del P.D. del dia anterior, el pq, se a reducido la asistencia a clase.

No creais que todo esto es lo que se puede hacer en dos horas, en caso de haberlo sido…(como hemos comentado, Pablo llego tarde) (Pablo alumno eh?), Tenemos también el Dominó entre manos, y claro, aprovechamos las horas de clase como tutorias, pq otra vez por motivos ajenos, los viernes esta jodidilla la cosa de venir a tutorias.

En fin, podria colgar el código, pero lo que hicimos no se asemeja en exceso,mas bien nada, a la solucion, por lo que os dejo que lo veais vosotros mismos…

www.it.uc3m.es/tsioca

un saludo grande, a quienes en Abril todavia leen esto

Intentaremos explicar la práctica de hoy con el lexico juvenil y sencillo que nos pidieron el primer dia…

En la introducción, nos explican conceptos básicos como el polimorfismo, sobrescritura y sobrecarga de métodos etc…San Pablo nos ha explicado estas definiciones, no entendiamos bien polimorfismo, pero a base de preguntarnos las demas hemos obtenido una respuesta juvenil, apta para nuestras pequeñas cabezas pensantes…

En definitiva, yo e entendido por polimorfismo, cuando tu requieres un objeto de un metodo, es decir, una accion de un objeto, este tiene que decidir de que metodo ha de tirar, si del que ya esta escrito, u otros que nadan por el mar del api, escritos o abstractos == vacios

En el ejercicio 1, nos pedian poquita cosa,revisar un codigo del viernes santo, y una preguntilla del tipo, decid que hace java en este caso, concretamente, que hacia para acceder mediante toString() a cada una de las posiciones de un array miembros []

Pues bien, java en este caso y como se hace en la clase Clase (valga la redundancia) la sentencia q nos daban, tenia un += que incrementa cada vez, permitiendo acceder al metodo toString() cada vez a una posicion mas del array.

En el ejercicio 2 recibimos la ayuda de SAN Pablo de OCA, el cual nos ayuda no ha poner implements en la clase, para poder rellenar desde esta el metodo guarda, sino a entender, de manera casi completa y obligandonos a buscar en el API para que sirve ese método asi como el write. Capturamos las excepiones con el throws Exception y listo. Tenemos guardado lo q genera nuestro archivo.

LLEGAMOS AL 3!

Interfaz gráfica, algo se supone superado tras dos años de asignatura:) hemos creado una ventana,un rectangulo con el metodo drawRect() encontrado en el fabuloso mundo del API y NO hemos conseguido encontrar la manera de rellenarlo, yo creo que es el metodo setColor(Color.Yellow); pero San Pablo se tuvo que ir, y no lo pude confirmar, se aceptan sugerencias

y bueno, aqui acaba nuestro sueño, los demas apartados no son del todo largos ni dificiles, pero hemos perdido algo de tiempo con el juego…cosas que pasan.

UN SALUDITO A TODOS CRACKS!!!

TANIA Y PABLO

PD: Por cierto, no habeis notado una decadencia en la asistencia a clase? pq sera…