martes, 27 de junio de 2017
miércoles, 31 de mayo de 2017
viernes, 26 de mayo de 2017
Práctica final 1 juego cartas siete y media 2016-2017
Clase Carta:
package es.unex.cum.edi.PracticaFinal;
/**
* Clase abstracta que contendrá carta alemana,carta francesa y carta española
* @author Ricardo Meza Díaz
*
*/
public abstract class Carta {
//Atributos:
//Path al nombre de la imagen de la celda cuando está dada la vuelta (Nose usará para nada, pero por si se hiciera gráficamente.
protected String imagenReverso;
//Path al nombre de la imagen de la celda cuando se muestra (No se usar para nada, pero por si se hiciera gráficamente).
protected String imagenFrontal;
/*
* Indica el valor de la carta.En el atributo se define como char,pero en el getValor hay que ponerlo como float.
* Puede valer:
* ▪ Carta Española: 1,2 ,3 4, 5, 6, 7, Sota (S), Caballo (C), Rey (R)
* ▪ Carta Francesa: 1,2 ,3 4, 5, 6, 7, 8 , 9 , 10 (A), y tres figuras, que se llaman Valet(V), Dame (D) y Roi (R).
* ▪ Carta Alemana: Consiste en un mazo de 36 naipes o cartas, clasificadas en cuatropalos. La numeración es: del 6 al 10 (X), Unter (U), Dame (D), König (K) y Daus(A)
*/
protected char valor;
//Indica si la carta esta “boca-abajo” .
protected boolean oculta;
/**
* Contructor por defecto.Inicializa por defecto los valores de los atributos de esa clase.
*/
public Carta(){
imagenReverso= ""; //También se puede inicializar como, imageReverso= new String();
imagenFrontal=""; //También se puede inicializar como, imageReverso= new String();
valor= ' '; //Ojo! ' ' va con un espacio entre ellas.
oculta=false; //Es recomendable inicializarla a false siempre.
}
/**
* Constructor parametrizado.Inicializa los valores recibisos por parametros.
* @param imagenReverso Foto de la parte trasera de la carta
* @param imagenFrontal Foto de la parte delantera de la carta
* @param Valor Numero o letra de carta
* @param Oculta SI está boca-abajo o boca-arriba
*/
public Carta(String imagenReverso,String imagenFrontal,char valor,boolean oculta){
this.imagenReverso=new String(imagenReverso);
this.imagenFrontal=new String(imagenFrontal);
this.valor=valor;
this.oculta=oculta;
}
/**
* Devuelve el valor(la ubicación de la imagen) del atributo imagenReverso
* @return String con la imagen de la parte de atrás de la carta.
*/
public String getImagenReverso(){
return imagenReverso;
}
/**
* Devuelve el valor(la ubicación de la imagen) del atributo imagenFrontal
* @return String con la imagen de la parte frontal de la carta.
*/
public String getImagenFrontal(){
return imagenFrontal;
}
/**
* Devuelve el valor(el numero o letra) de la carta.Ojo! es abstract el método porque se va desarrollar este método en la clases Carta Francesa,Española y Alemana.
* Cada una tienen sus propias letras y numeros.
* @return float como la representacion numerica de la carta caracter dependiendo de si está boca-abajo o boca-arribaque será una letra o un número de la carta.
*/
public abstract float getValor();
/**
* Devuelve el valor de si la carta está boca a bajo o boca arriba.Es decir, un valor numérico asociada a la carta que será usado posteriormente.
* @return boolean que será un true o un false dependiendo de si está boca-abajo o boca-arriba.
*/
public boolean getOculta(){
return oculta;
}
/**
* Cambia el estado de la carta.
* @param oculta True boca-abajo.False boca-arriba.
*
*/
public void setOculta(boolean oculta){
this.oculta=oculta;
}
/**
* Cambia la ubicación de la imagen en el sistema operativo de la parte de atrás de la carta.
* @param imagenReverso modifica la ruta de la foto de detrás de la carta
*/
public void setImageReverso(String imagenReverso){
this.imagenReverso=imagenReverso;
}
/**
* Cambia la ubicación de la imagen en el sistema operativo de la parte de alante de la carta.
* @param imagenFrontal modifica la ruta de la foto de alante de la carta
*/
public void setImageFrontal(String imagenFrontal){
this.imagenFrontal=imagenFrontal;
}
/**
* Cambia el valor de de si esta la carta boca a bajo o boca arriba.
* @param valor de la carta
*/
public void setValor(char valor){
this.valor=valor;
}
/**
* Devuelve una cadena,mostrando los valores de los atributos deseados.
*/
@Override
public String toString(){
return "[Numero/letra de la carta: "+valor+"]";
}
/**
* Redefine el método equals de la clase Object.No olvidar poner @override encima del método.
*/
@Override
public boolean equals(Object o){
//Upcasting
Carta c=(Carta)o;
return this.imagenReverso.equals(c.imagenReverso)&&this.imagenFrontal.equals(c.imagenFrontal)&&this.valor==c.valor&&this.oculta==c.oculta;
}
}
lunes, 20 de febrero de 2017
martes, 22 de noviembre de 2016
sábado, 25 de junio de 2016
Practica final 2-Bingo
CLASE BINGO:
package es.unex.cum.edi.practicafinal2;
//Importo la libreria list para poder usar el LinkedList
personas
import java.util.List;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class Bingo extends JuegoBingo {
/**
* Atributo personas: LinkedList llamada
personas, de la clase Persona
*/
//*
private
LinkedList<Jugador> personas=new LinkedList<Jugador>();
//*
JuegoBingo
jb = new JuegoBingo();
//*
//COMIENZO
MAIN
public
static void main(String args[]) throws IOException{
//*
Bingo
b = new Bingo();
int
opcion=0;
int
ohpcion=0;
String
nhombre;
String
identificator;
Date
fecha;
long
tiempo=0;
opcion=b.Menu();
while(opcion!=7){
switch(opcion){
case 1:
ohpcion=b.tipoUsuario();
if(ohpcion==1){
System.out.println("Jugaras
como jugador");
}
else{
System.out.println("Jugaras
como invitado");
}
break;
case
2:
if(ohpcion==1){
System.out.println("####BINGO
UEX####");
System.out.println("Eres
Jugador.Introduzca un nombre como jugador:");
nhombre=Entrada.cadena();
System.out.println("Introduzca
un id para identificarle como jugador:");
identificator=Entrada.cadena();
Jugador
p=new Jugador(nhombre,identificator);
b.aniadirPersonaLista(p);
b.inicializar();
b.cambiaEstadoa1();
b.repartir();
System.out.println("Tablero
inicial");
b.tiempoInicio();
b.jugar();
System.out.println("Tablero
Inicial");
b.mostrar();
tiempo=b.tiempoFinal();
System.out.println("Tiempo:"+tiempo);
fecha=b.fechadeJuego();
Jugada
ju=new Jugada(tiempo,fecha);
p.addJugada(ju);
}
if
(ohpcion == 2) {
System.out.println("####BINGO
UEX####");
System.out.println("Eres
Invitado");
b.inicializar();
b.cambiaEstadoa1();
b.repartir();
b.tiempoInicio();
System.out.println("Tablero
inicial");
b.mostrar();
System.out.println("Hola");
b.jugar();
System.out.println("Tablero
Final");
b.mostrar();
tiempo
= b.tiempoFinal();
System.out.println("Tiempo
: " + tiempo);
}
break;
case
3:
String
ihd;
System.out.println("Introduce
id para mostrar jugador:");
ihd=Entrada.cadena();
b.mostrarInfoyJugadas(ihd);
break;
case
4:
int
carga=0;
try{
b.cargar();
}catch
(Exception e){
carga
=1;
}
if(carga==1)
System.out.println("Lista
de personas no cargada");
else{
System.out.println("Lista
de Personas Cargada");
}
break;
case
5:
try
{
b.salvar();
}
catch
(Exception e) {
System.out.println(e);
}
System.out.println("Se
ha almacenado correctamente al lista de personas en el fichero");
break;
case
6:
b.mostrarColaMovimientos();
break;
}
opcion=b.Menu();
}
System.out.println("Hasta
pronto");
}
//
Hago la llamada de los modulos
//FIN
MAIN
/**
* Modulo 1.cargarListaPersonas: Carga la lista
de las personas en un
* fichero "datos.dat"
*/
public
void cargar() throws FileNotFoundException, IOException, ClassNotFoundException
{
//List<Persona>
personas=new LinkedList<Persona>();
//Se
crea un fichero "datos.dat" para abrir la lista de Personas
ObjectInputStream
archivoObjetosEnt = new ObjectInputStream(new
FileInputStream("datos.dat"));
//Los
datos que se hayan salvado previamente te los carga en la lista de personas
personas=(LinkedList)archivoObjetosEnt.readObject();
//Se
cierra el fichero "datos.dat"
archivoObjetosEnt.close();
}
/**
* Modulo 2.añadirPersonaLista :
*
Añadir una nueva persona de tipo jugador a la lista de personas (los
* invitados juegan
pero no están registrados)
*/
public
void aniadirPersonaLista(Jugador j) {
//Utilizo
add para aniadir una persona
//Tengo
una herencia de clase
//He
agregado una persona de tipo jugador a la lista de personas
//haciendo
upcasting
//*
personas.add(j);
}
/**
* Modulo 3.jugarJuego
:Pedir si es un usuario jugador o invitados
•
*
Coger el tiempo de comienzo (se proporciona el código más abajo)
• Jugar
* •
Coger el tiempo de fin (se proporciona el código más abajo)
•
*
Si el usuario es un jugador salvar la jugada en su lista de jugadas
*/
public
void jugarJuego() {
jb.jugar();
}
/**
* Modulo 4.mostrarInfoyJugadas :
*
Mostrar la información y jugadas realizadas para una determinada persona (
* dado su id)
*/
//*
public
void mostrarInfoyJugadas(String identificacion) {
//Recorro
la lista personas de la clase jugador
Iterator<Jugador>it=personas.iterator();
//While
para saber si no hay siguiente
while(it.hasNext()){
//Upcasting?
Jugador
j=(Jugador) it.next();
//If
para comprar que el id del jugador pasado es igyal al id del jugador
if(j.id.equals(identificacion)){
System.out.println("Informacion
y jugadas realizadas de un jugador:");
//Se
muestra el id del jugador de la clase Jugador
System.out.println(j.id);
//Se
muestra el toString() del jugador,que contiene
System.out.println(j.toString());
//Se
muestran las jugadas de la clase jugador a traves del getL que obtiene la lista
l
System.out.println(j.getL()+"
"+"jugadas");
}
}
}
//*
/**
* Modulo 5.mostrarColaMovimientos :
Mostrar la cola de movimientos /celdas de la última partida
*
*/
//*
public
void mostrarColaMovimientos(){
System.out.println("Cola
de movimientos de la ultima partida:");
//Se
obtiene la cola c del la clase Juego Bingo
System.out.println(jb.getCola());
}
//*
/**
* Modulo 6.salvarListapersonas: Guarda la lista
de personas en un fichero "datos.dat"
*/
public
void salvar() throws FileNotFoundException, IOException {
ObjectOutputStream
archivoObjetosSal = new ObjectOutputStream(
new
FileOutputStream("datos.dat"));
//Se
guardan los datos de la lista personas en el fichero "datos.dat"
archivoObjetosSal.writeObject(personas);
//Se
cierra el fichero "datos.dat"
archivoObjetosSal.close();
}
/**
* Modulo 7.jugaralJuego
*/
public
void jugaralJuego(){
//Se
pide si es un jugador o invitado
System.out.println("Desea
jugar como jugador o invitado?:");
//Se
coge el tiempo de comienzo
//long
tInicial=new Date().getTime();
//Se
juega
jb.jugar();
//Se
coge el tiempo fin
//long
tFinal= new Date().getTime();
//Se
compara para saber si es un jugador o invitado
//Si
es jugador se salvara la jugada en la lista de jugadas
}
public
void jugadoroInvitado(){
}
/**
*
Modulo 8.TipoUsuario() : Se escogera si se quiere jugar como jugador o
como inivitado
*
*/
public
int tipoUsuario()throws IOException{
int
opcion=0;
System.out.println("Pulse:
1.jugador o 2.Invitado:");
opcion=Entrada.entero();
while(opcion<1||opcion>2){
System.out.println("Error.Ha
introducido un numero incorrecto");
System.out.println("Introduzca
1 o 2:");
opcion=Entrada.entero();
}
return
opcion;
}
/**
*
Modulo 9.FechadeJuego
*
*/
public
Date fechadeJuego() throws IOException {
String
fechajuego;
System.out.println("Introduzca
la fecha del dia de hoy ");
fechajuego=Entrada.cadena();
SimpleDateFormat
formato = new SimpleDateFormat("dia/mes/anio");
Date
fechaDate = null;
try
{
fechaDate
= formato.parse(fechajuego);
}
catch (ParseException ex) {
System.out.println(ex);
}
return
fechaDate;
}
/**
*
Modulo 10.Menu()
*
*/
public
int Menu(){
int
opcion=0;
System.out.println("Elija
una opcion:");
System.out.println("1.
Jugar como invitado o como jugador");
System.out.println("2.
Jugar");
System.out.println("3.Mostrar
informacion y jugadas de un jugador:");
System.out.println("4.Cargar
Lista");
System.out.println("5.Guardar
Lista");
System.out.println("6.Mostar
movimientos de la ultima partida:" );
System.out.println("7.Salir");
opcion=Entrada.entero();
while(opcion<1||opcion>7
){
System.out.println("Error.Ha
introducido un numero incorrecto");
System.out.println("Introduzca
una numero del uno al cinco");
opcion=Entrada.entero();
}
return
opcion;
}
//*
//Se calcula
el tiempo de Inicio del juego
public
long tiempoInicio(){
long
tInicial=new Date().getTime();
return
tInicial;
}
//Se
calcula el tiempo Final del juego
public
long tiempoFinal(){
long
tFinal= new Date().getTime();
return
tFinal;
}
//*
}
CLASE CELDA:
/**
* Clase Celda: Es la clase base
*/
package es.unex.cum.edi.practicafinal2;
/**
*
* @author Ricardo Meza Dìaz
*
*/
public abstract class Celda {
/**
* Atributo fila:El valor de la fila donde se encuentra situada la celda en la matriz juego
*/
protected int fila;
/**
* Atributo columna:El valor de la columna donde se encuentra situada la celda en la matriz juego
*/
protected int columna;
protected String imageReverso;
protected String imageFrontal;
/**
* Atributo Estado: Tendrá distinto signficado dependiendo de la celda usada
* Tendra distinto significado dependiendo de la celda usada
0 sin significado (de momento) ,1 número en cartón y 2 número encartón cantado
*/
protected int estado;
/**
* Constructores
* Constructor por defecto
*/
public Celda(){
fila=0;
columna=0;
estado=0;
}
/**
*Constructor parametrizado
*/
public Celda(int fila,int columna,int estado){
this.fila=fila;
this.columna=columna;
this.estado=estado;
}
/**
*Constructor parametrizado de reverso
*/
/**
* Getters
* Get de fila
*/
public int getFila(){
return fila;
}
/**
* Get de columna
*/
public int getColumna(){
return columna;
}
/**
* Get de ImageReverso
*/
public String getImageReverso() {
return imageReverso;
}
/**
* Get de ImageFrontal
*/
public String getImageFrontal() {
return imageFrontal;
}
/**
* Get de estado
* Modificacion: He colocado int fila ,int columna
* para usar el metodo getEstado de la calse Tablero
*/
public int getEstado(){
return estado;
}
/**
* Setters
* Set de fila
*/
public void setFila(int fila){
this.fila=fila;
}
/**
* Setters
* Set de Columna
*/
public void setColumna(int columna){
this.columna=columna;
}
/**
* Setters
* Set de Estado
*/
public void setEstado(int estado){
this.estado=estado;
}
/**
* Setters
* setImageReverso
*/
public void setImageReverso(String imageReverso) {
this.imageReverso = imageReverso;
}
/**
* Setters
* Set ImageFrontal
*/
public void setImageFrontal(String imageFrontal) {
this.imageFrontal = imageFrontal;
}
/**
* equals()
*/
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Celda other = (Celda) obj;
if (columna != other.columna)
return false;
if (estado != other.estado)
return false;
if (fila != other.fila)
return false;
return true;
}
/**
* to string()
*/
public String toString(){
String cadena="Fila:"+fila+"Columna:"+columna+"Estado:"+estado;
return cadena;
}
}
CLASE CELDA BINGO:
package es.unex.cum.edi.practicafinal2;
import es.unex.cum.edi.practicafinal2.Celda;
public class CeldaBingo extends Celda {
/**
* Atributo cartononocarton: Representa el numero que contiene la celda
*/
protected int cartononocarton;
//Constructores
//Constructor por defecto
public CeldaBingo(){
super();
cartononocarton=0;
}
//*
//Constructor parametrizado
public CeldaBingo(int fila,int columna,int estado,int cartononocarton){
super(fila,columna,estado);
this.cartononocarton=cartononocarton;
}
//Getters
//Get de cartononocarton
public int getCartononocarton(){
return cartononocarton;
}
//Setters
//Set de color
public void setCartononocarton(int cartononocarton){
this.cartononocarton=cartononocarton;
}
//Equals()
public boolean equals(Object o){
CeldaBingo cb=(CeldaBingo)o;
return this.cartononocarton==cb.cartononocarton&&super.equals(cb);
}
//ToString()
public String toString(){
return super.toString()+"Numero carton:"+cartononocarton;
}
}
CLASE INVITADO:
package es.unex.cum.edi.practicafinal2;
/**
*
* Clase Invidato: Sin ningun atributo
*
*/
public class Invitado extends Persona {
/**
*
*/
private static final long serialVersionUID = 1L;
//Constructor por defecto
public Invitado(){
super();
}
//Constructor parametrizado
public Invitado(String nombre,String id){
this.nombre=nombre;
this.id=id;
}
/**
* equals()
*/
public boolean equals(Object obj)
{
return super.equals(obj);
}
/**
* to String()
*/
//*
public String toString()
{
StringBuilder sb=new StringBuilder();
sb.append(super.toString());
return sb.toString();
}
//Get de invitado
}
CLASE JUEGO BINGO:
/**
d * Modificacion de la practica final 1 para la practica final 2:
* Modificar la clase JuegoBingo/JuegoCelda/JuegoRayas
* JuegoBingo: Cada vez que se saque una bola del “bombo” se creará una celdaBingo
*que se añadirá a esta cola
*/
package es.unex.cum.edi.practicafinal2;
import java.util.Queue;
//Para trabajar con LinkedList
import java.util.*;
import es.unex.cum.edi.practicafinal2.CeldaBingo;
import es.unex.cum.edi.practicafinal2.TableroBingo;
public class JuegoBingo extends Tablero {
// He creado un objeto de la clase TableroBingo t
TableroBingo t = new TableroBingo();
//*
private Queue<CeldaBingo>c=new LinkedList<CeldaBingo>();
//*
/**
* Debo definir queue<Celda>c;
* y hacerle un add para añadir los numeros que saque de la bombo a la cola
*
*/
//Queue<CeldaBingo>c;
// Metodos
/**
* Metodo Jugar:
* Bucle que se encarga de sacar un número aleatorio (que no se haya
* cantado previamente)
*
**/
/*
// Debo llamar los metodos y crear un objeto de JuegoBingo
public static void main(String[] args) {
JuegoBingo jb = new JuegoBingo();
// Hago la llamada de los modulos
jb.inicializar();
jb.cambiaEstadoa1();
jb.repartir();
jb.mostrar();
jb.jugar();
}
*/
// Modulos
public void inicializar() {
t.inicializar();
}
public void repartir() {
t.repartir();
}
public void mostrar() {
t.mostrar();
}
public void cambiaEstadoa1() {
// For para ir recorriendo el tablero
for (int i = 0; i < t.numFilas; i++) {
for (int j = 0; j < t.numColumnas; j++) {
// Metodo para cambiar el estado y ponerlo a uno en todo el
// tablero
t.setEstado(i, j, 1);
}
}
System.out.println("Ahora todos los estados valen 1");
}
/**
* Metodo VerSiFin:
* Se encarga de ver si el juego ha acabado (todos los números del cartón
* están cantados)
**/
public boolean VerSiFin() {
boolean comprobacion = true;
for (int i = 0; i < t.getNumFilas(); i++) {
for (int j = 0; j < t.getNumColumnas(); j++) {
if (t.getEstado(i, j) != 2) {
comprobacion = false;
}
}
}
return comprobacion;
}
public void jugar() {
//Creo una variable random
Random r =new Random();
//Declaracion vector que contendra los numeros aleatorios
int[] vectoraleatorios = new int[90];
int numAleatorio=0 ;
//*
int contador=0;
boolean salir=false;
char respuesta;
while(!VerSiFin()&&!salir){
// for(int i=0;i<t.numFilas;i++){
// for(int j=0;i<t.numFilas;j++){
//Upcasting
TableroBingo aux=(TableroBingo)t;
boolean numPorCantar=true;
do{
numPorCantar=true;
numAleatorio=r.nextInt(aux.numeromaxcarton+1);
for(int k=0;k<contador;k++){
if(vectoraleatorios[k]==numAleatorio){
numPorCantar=false;
break;
}
}
if(numPorCantar)
break;
}while(true);
vectoraleatorios[contador]=numAleatorio;
contador++;
c.offer(new CeldaBingo(0,0,0,numAleatorio));
if(resolver(numAleatorio)){
t.mostrar();
}
else{
System.out.println("Este numero cantado no esta en el carton");
}
System.out.println("Desea cantar otro numero? s/n");
respuesta=Entrada.caracter();
if(respuesta=='n'){
salir =true;
break;
}
}
if(VerSiFin()){
System.out.println("\n !Bingo!.Has ganado");
}
/**
// For para recorrer el tablero
while (!VerSiFin()) {
//Generar numero aleatorio
numAleatorio=(int) (Math.random()*90+1);
//Llamada al modulo resolver
resolver(numAleatorio);
//Llamada al modulo mostrar
mostrar();
//Ahora debo hacer un for para que comparar que no se repita un numero
for(int i = 0; i < 90; ++i){
//Pongo todo a cero
vectoraleatorios[i] = 0;
}
*/
}
/**
* Metodo Resolver:
* Se encarga de cambiar el estado del número si coincide con el número que
* ha salido cantado
**/
public boolean resolver(int numeroAleatorio) {
//*
boolean numCantado=true;
// For para ir recorriendo el tablero
for (int i = 0; i < t.getNumFilas(); i++) {
for (int j = 0; j < t.getNumColumnas(); j++) {
TableroBingo aux=(TableroBingo)t;
CeldaBingo aux1 = (CeldaBingo) aux.getCelda(i, j);
if(aux1.getCartononocarton()==numeroAleatorio){
System.out.println("El numero"+" "+aux1.getCartononocarton()+" "+"ha sido cantado y esta en el carton.El estado sera cambiado");
aux.setEstado(i, j, 2);
numCantado=true;
}
}
}
return numCantado;
}
//Metodo necesario
//Le he pasado un objeto de CeldaBingo llamada C1, para poder hacer el add con la cola c
public void addCelda(CeldaBingo c1){
c.add(c1);
}
//Practica final 2
//*
//getCola
public Queue<CeldaBingo>getCola(){
return c;
}
}
CLASE JUGADA:
package es.unex.cum.edi.practicafinal2;
//Importo la libreria java.util.*; para poder usar el Date fecha
import java.util.*;
/**
* Clase Jugada: Almacena el tiempo que tardo un determinado jugador en resolver el juego
*(Bingo en cantar el bingo, parejas en resolver el tablero y en el caso de Rayas en ganar).
* Se encuentra formado por dos atributos:
*/
public class Jugada {
/**
* Atributo tiempo,clase Juagada: Almacena en formato long el tiempo que ha tardado
*/
private long tiempo;
/**
* Atributo fecha,clase Juagada: Almacena la fecha en la que realizó dicha jugada
* Se trata de una clase básica con los métodos habituales
*/
private Date fecha;
/**
* Constructor por defecto,clase jugada
*/
public Jugada(){
tiempo=0;
//Inicilizalicacion por defecto para datos de tipo Date
//que representan a fecha
fecha=new Date();
}
/**
* Constructor parametrizado,clase jugada
*
*/
public Jugada(long tiempo,Date fecha){
this.tiempo=tiempo;
this.fecha=fecha;
}
/**
*Getters y Setters,clase jugada
*
*/
public long getTiempo() {
return tiempo;
}
public void setTiempo(long tiempo) {
this.tiempo = tiempo;
}
public Date getFecha() {
return fecha;
}
public void setFecha(Date fecha) {
this.fecha = fecha;
}
/**
*Metodo toString()
*
*/
public String toString() {
return "Jugada [tiempo=" + tiempo + ", fecha=" + fecha + "]";
}
/**
*Metodo equals()
*
*/
//*
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Jugada other = (Jugada) obj;
if (fecha == null) {
if (other.fecha != null)
return false;
} else if (!fecha.equals(other.fecha))
return false;
if (tiempo != other.tiempo)
return false;
return true;
}
}
CLASE JUGADOR:
package es.unex.cum.edi.practicafinal2;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
* Clase Jugada: Tiene una lista (ArrayList) de Jugadas
*
*/
public class Jugador extends Persona implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* Para los datos de tipo long?
*/
//private static final long serialVersionUID = 1L;
/**
* Atributo ArrayList de jugadas:
*/
private List<Jugada>l;
/**
* Cosntructor por defecto
*/
public Jugador(){
super();
l=new ArrayList<Jugada>();
}
/**
* Constructor Parametrizado de Jugador: Se le pasan por parametros los atributos
* de la clase Persona
*/
//*
public Jugador(String nombre,String id){
this.nombre=nombre;
this.id=id;
l=new ArrayList<Jugada>();
}
//*
/**
* Getters y setters:
*/
public List<Jugada> getL() {
return l;
}
public void setL(ArrayList<Jugada> l) {
this.l = l;
}
@Override
//*
public String toString() {
//StringBuilder para poder utilizar append()
StringBuilder sb=new StringBuilder();
//Se utiliza el append() para poder concatenar Strings
sb.append(super.toString()+l.toString());
return sb.toString();
}
//*
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Jugador other = (Jugador) obj;
//*
//equals del super
super.equals(obj);
//*
if (l == null) {
if (other.l != null)
return false;
} else if (!l.equals(other.l))
return false;
return true;
}
//Metodo addJugada: Permite aniadir una lista de jugada
public void addJugada(Jugada j){
//Se añado una lista de jugada a la lista de jugada que se llama "l"
l.add(j);
}
}
CLASE PERSONA:
package es.unex.cum.edi.practicafinal2;
//Importo el Serializable para poder trabajar con la Interfaz
import java.io.Serializable;
/**
*
* Clase Persona(Clase Base)
* implemento el interfaz Serializable para que cargar y salvar se haga automaticamente
*
*/
public class Persona implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* Atributo nombre,clase Persona: Nombre del usuario
*/
protected String nombre;
/**
* Atributo id,clase Persona: Identificacion del usuario
*/
protected String id;
/**
* Constructores por defecto
*/
public Persona(){
nombre="";
id="";
}
/**
* Constructores parametrizado
*/
public Persona(String nombre,String id){
this.nombre=nombre;
this.id=id;
}
public String getNombre() {
return nombre;
}
/**
* Getters y Setters de los atributos nombre y id
*/
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
/**
* Metodo:to string()
*/
public String toString() {
return "Persona [nombre=" + nombre + ", id=" + id + "]";
}
/**
* Metodo:equals()
*/
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Persona other = (Persona) obj;
if (id != other.id)
return false;
if (nombre == null) {
if (other.nombre != null)
return false;
} else if (!nombre.equals(other.nombre))
return false;
return true;
}
}
CLASE SERIALIZABLE:
package es.unex.cum.edi.practicafinal2;
public interface Serializable {
}
CLASE TABLERO:
package es.unex.cum.edi.practicafinal2;
import java.util.Arrays;
//Para poder trabajar con el modulo Repartir
import es.unex.cum.edi.practicafinal2.Celda;
/**
* Clase Tablero: Es una clase abstracta que contiene a la clase derivada Juego
**/
public abstract class Tablero{
/**
* Atributo numFilas: Numero de filas (modificable en el constructor)
**/
protected int numFilas;
/**
* Atributo numColumnas: Numero de columnas (modificable en el constructor)
**/
protected int numColumnas;
/**
* Atributo Celda[][]Tablero: Matriz bidimensional de Celdas
**/
protected Celda[][]Tablero;
/**
* Constructores
* Constructor por defecto
*/
public Tablero(){
numFilas=5;
numColumnas=5;
Tablero= new Celda [numFilas][numColumnas];
}
/**
*Constructor parametrizado
*/
public Tablero(int numFilas,int numColumnas){
this.numFilas=numFilas;
this.numColumnas=numColumnas;
//Tablero= new Celda [numFilas][numColumnas];
}
/**
* Getters
* Get de Numfilas
*/
public int getNumFilas() {
return numFilas;
}
/**
* Get de NumColumnas
*/
public int getNumColumnas() {
return numColumnas;
}
/**
* Get de Tablero
*/
public Celda[][] getTablero() {
return Tablero;
}
/**
* Setters
* Set de NumFilas
*/
public void setNumFilas(int numFilas) {
this.numFilas = numFilas;
}
/**
* Set de NumColumnas
*/
public void setNumColumnas(int numColumnas) {
this.numColumnas = numColumnas;
}
/**
* Set de Tablero
*/
public void setTablero(Celda[][] tablero) {
Tablero = tablero;
}
/**
* to string()
*/
public String toString() {
return "Tablero [numFilas=" + numFilas + ", numColumnas=" + numColumnas + ", Tablero=" + Arrays.toString(Tablero)
+ "]";
}
//Metodos
/**
* Metodo setEstado: Se encarga de cambiar el estado (e) de la celda
* indicada por la fila (f) y la columna (c)
**/
public void setEstado(int f,int c,int e ){
//En el tablero que esta compuesto por filas y columnas voy cambiando
//el estado de la celda 0 para sin significado,1 para carton y 2 para sin carton
//luego uso el setEstado para cambiar el estado y lo guardo en estado
Tablero[f][c].setEstado(e);
}
/**
* Metodo getEstado: Devuelve el estado de la celda indicada en la fila (f) y la
*columna (c)
* He modificado el getEstado de la clase Celda
**/
public int getEstado(int f,int c){
return Tablero[f][c].getEstado();
}
//return Tablero[f][c].geEstado();
/**
* Metodo getCelda: Devuelve la Celda indicada en la fila (f) y la columna (c)
*
**/
public Celda getCelda(int f,int c){
return Tablero[f][c];
//Celda aux = this.Tablero[f][c];
//return aux;
}
//Metodos abstractos
//Debo implementar los metodos abstractos
/**
*Metodo abstracto inicializar: Se encarga de inicializar el tablero a las celdas (será llamado
*desde el constructor de la clase derivada)
**/
abstract void inicializar();
/**
*Metodo abstracto repartir: Se encarga de repartir (sólo válido para TableroPareja y
*TableroBingo)
**/
abstract void repartir();
/**
*Metodo abstracto mostrar: Se encarga de mostrar el Tablero en un formato gráfico
*(puede valer con toString)
**/
abstract void mostrar();
}
CLASE TABLERO BINGO:
package es.unex.cum.edi.practicafinal2;
import java.util.Random;
import es.unex.cum.edi.practicafinal2.CeldaBingo;
import es.unex.cum.edi.practicafinal2.Tablero;
/**
* Clase derivada TableroBingo:
* Tiene como atributo el número máximo del Cartón (90 por defecto). La
* implementación
* que realizaremos nosotros se supondrá que el cartón sólo contiene celdas con
* números (en los cartones reales hay celdas del cartón que están vacías).
* Debe implementar los métodos abstractos
*/
public class TableroBingo extends Tablero {
protected int numeromaxcarton;
/**
* Constructores Constructor por defecto
*/
public TableroBingo() {
super();
numeromaxcarton = 90;
}
/**
* Constructor parametrizado
*/
public TableroBingo(int numFilas, int numColumnas, Celda[][] Tablero, int numeromaxcarton) {
super(numFilas, numColumnas);
this.numeromaxcarton = numeromaxcarton;
}
/**
* Getters Get de numeromaxcarton
*/
public int getNumeromaxcarton() {
return numeromaxcarton;
}
/**
* Set de numeromaxcarton
*/
public int setNumeromaxcarton() {
return numeromaxcarton;
}
/**
* equals()
*/
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
TableroBingo other = (TableroBingo) obj;
if (numFilas != other.numFilas)
return false;
if (numColumnas != other.numColumnas)
return false;
if (Tablero != other.Tablero)
return false;
return true;
}
/**
* to string()
*/
public String toString() {
return super.toString() + this.numFilas + this.numColumnas + this.Tablero;
}
// Metodos
public void inicializar() {
// For para ir recorriendo el tablero
for (int i = 0; i < numFilas; i++) {
for (int j = 0; j < numColumnas; j++) {
// Le doy valores del parametrizado CeldaBingo
Tablero[i][j] = new CeldaBingo(i, j,0,0);
}
}
}
public void repartir() {
// Creo un objeto de random
// Para poder repartir aleatoriamente
Random aleatorio = new Random();
// Creo una matriz llamada numero de enteros
int[] numerosbingo = new int[numeromaxcarton];
numerosbingo[0] = 1;
int numero = 0;
// For para ir recorriendo el tablero
for (int i = 0; i < numFilas; i++) {
for (int j = 0; j < numColumnas; j++) {
while (numerosbingo[numero] != 0) {
numero = aleatorio.nextInt(numeromaxcarton);
}
((CeldaBingo) Tablero[i][j]).setCartononocarton(numero);
numerosbingo[numero] = numero;
}
}
}
public void mostrar() {
// For para ir recorriendo el tablero
for (int i = 0; i < numFilas; i++) {
System.out.println("");
for (int j = 0; j < numColumnas; j++) {
CeldaBingo aux = (CeldaBingo) Tablero[i][j];
if (aux.getEstado() == 1 & aux.getCartononocarton() < 10) {
System.out.print("[" + 0 + aux.getCartononocarton() + "]");
} else if (aux.getEstado() == 1 & aux.getCartononocarton() >= 10) {
System.out.print("[" + aux.getCartononocarton() + "]");
} else {
System.out.print("["+aux.getCartononocarton()+"*]");
}
}
}
}
}
CLASE ENTRADA:
package es.unex.cum.edi.practicafinal2;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Entrada {
static String inicializar() {
String buzon = "";
InputStreamReader flujo = new InputStreamReader(System.in);
BufferedReader teclado = new BufferedReader(flujo);
try {
buzon = teclado.readLine();
} catch (Exception e) {
System.out.append("Entrada incorrecta)");
}
return buzon;
}
static int entero() {
int valor = Integer.parseInt(inicializar());
return valor;
}
static double real() {
double valor = Double.parseDouble(inicializar());
return valor;
}
static String cadena() {
String valor = inicializar();
return valor;
}
static char caracter() {
String valor = inicializar();
return valor.charAt(0);
}
}
Suscribirse a:
Entradas (Atom)