Pablotania’s Weblog

Bueno xic@s, aquí pongo mi ejercicio, que me ha costao’ lo suyo…, se me ha pasado el finde, lo siento!!

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!!

Hola a tod@s!! Ahí va ejercicio:

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