Mensajes

[Carta]

Primero, es conveniente colocar en la clase Carta unos getters para obtener la carta y el palo. La razón es sencilla, como en el arreglo se guardan las cartas con el formato carta + palo si comparamos las cartas así nomás, nunca habrá coincidencias, porque solo va a existir una carta del palo.

Código (=java) [Seleccionar] Expandir


/* Getters en clase Carta para obtener el palo y la carta */
public String getCarta(){
return this.carta;
}

public String getPalo() {
return this.palo;
}


Código (=java) [Seleccionar] Expandir


public class CardsPack {
   
    // Abre clase PaqueteDeCartas
    private Card mazo[];
    private int cartaActual;
    private final int NUMERODECARTAS = 52;
    private Random numerosAleatorios;
   
public CardsPack()
{   // Abre constructor PaqueteDeCartas
    String caras[] = { "AS", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE",
            "OCHO", "NUEVE", "DIEZ", "JOTO", "QUINA", "REY"};
    String palos[] = { "CORAZONES", "DIAMANTES", "TREBOLES", "ESPADAS"};
       
    mazo = new Card[ NUMERODECARTAS ];
    cartaActual = 0;
    numerosAleatorios = new Random();
       
    for ( int cuenta = 0; cuenta < mazo.length; cuenta++ )
    mazo[ cuenta ] = new Card( caras[cuenta % 13], palos[cuenta/13]);
}   // Cierra constructor PaqueteDeCartas
   
/* BARAJA LAS CARTAS */
public void barajar()
{   
    cartaActual = 0;

    for ( int primera = 0; primera < mazo.length; primera++ )
    {
      int segunda = numerosAleatorios.nextInt(NUMERODECARTAS);

      Card temp = mazo[primera];
      mazo[primera] = mazo[segunda];
      mazo[segunda] = temp;
    }
}
   
/* METODO DE AYUDA - REPARTE UNA CARTAC */
private Card repartirCarta()
{ 
    if (cartaActual < mazo.length )   
           return mazo[cartaActual++];
    else
           return null;       
}
   
/* REPARTE UNA MANO DE 5 CARTAS */
public Card[] repartirMano() {
        Card[] mano = new Card[5];
         System.out.println("*** Tu mano es: ***\n\n");
            for (byte carta = 0; carta < 5; carta++) {
                mano[carta] = this.repartirCarta();
                System.out.println(mano[carta].toString());
            }
         return mano;
    }
   
   
/* RESULTADOS DE LA MANO */
public void analizarMano(Card[] mano) {
    String[][] manoHecha = new String[5][2];
    manoHecha[0][0] = "¿Hay par?";
    manoHecha[1][0] = "¿Hay doble par?";
    manoHecha[2][0] = "¿Hay tercia?";
    manoHecha[3][0] = "¿Hay poker de ases?";
    manoHecha[4][0] = "¿Hay color?";
   
   
    System.out.println("\n\n*** Resultados de la mano: ***\n\n");
    for (byte indice = 0; indice < manoHecha.length; indice++) {
        byte col = 1;
        switch(indice) {
                case 0:  manoHecha[indice][col] = String.valueOf(this.hayPar(mano)); break;
                case 1:  manoHecha[indice][col] = String.valueOf(this.hay2pares(mano)); break;
                case 2: manoHecha[indice][col] = String.valueOf(this.hayTercia(mano)); break;
                case 3:  manoHecha[indice][col] = String.valueOf(this.hayPokerAses(mano)); break;
                case 4: manoHecha[indice][col] = String.valueOf(this.hayColor(mano)); break;
            }
    }
   
     for (byte fila = 0; fila < manoHecha.length; fila++) {
        for (byte col = 0; col < manoHecha[fila].length; col++) {
            if (col == 0) {
            System.out.print(manoHecha[fila][col] + " - ");
            }
            else {
                System.out.print(manoHecha[fila][col]);
                System.out.println();
            }
        }
    }
    }
   
/* DETERMINA SI HAY UN PAR EN LA MANO */
private boolean hayPar(Card[] mano) {

    boolean isPar = false;
    for (byte fila=0; fila<mano.length; fila++) {
        for(byte elemento=0; elemento<mano.length; elemento++) {
            if (fila != elemento) {
                if (mano[fila].getCara().equals(mano[elemento].getCara())) {
                    isPar = true;
                    break;
}
            }
}
    }
        return isPar;
}

/* DETERMINA SI HAY 2 PARES */
private boolean hay2pares(Card[] mano) {

boolean is2par = false;
byte pares = 0;
for(byte fila = 0; fila < mano.length; fila++) {
for( byte elemento = 0; elemento < mano.length; elemento++) {
if (fila != elemento) {
if(mano[fila].getCara().equals(mano[elemento].getCara())) {
pares++;
}
}
}
}
if(pares == 2) {
is2par = true;
}
        return is2par;
}

/* COMPRUEBA SI HAY TERCIA */
private boolean hayTercia(Card[] mano) {
boolean hayTrio = false;
byte tercia = 0;

for(byte fila = 0; fila < mano.length; fila++) {
for( byte elemento = 0; elemento < mano.length; elemento++) {
if (fila != elemento) {
if(mano[fila].getCara().equals(mano[elemento].getCara())) {
tercia++;
}
}
}
}

if(tercia == 3) {
hayTrio = true;
}

return hayTrio;
}

/* DETERMINA SI HAY 4 ASES */
private boolean hayPokerAses(Card[] mano) {
boolean haypoker = false;
byte asescount = 0;
final String as = "AS";

for(byte fila = 0; fila < mano.length; fila++) {
for( byte elemento = 0; elemento < mano.length; elemento++) {
if (fila != elemento) {
if(mano[elemento].getCara().equals(as)) {
asescount++;
}
}
}
}

if (asescount == 4) {
haypoker = true;
}

return haypoker;
}

/* DETERMINA SI HAY CINCO CARTAS DEL MISMO PALO */
private boolean hayColor(Card[] mano) {
boolean haycolor = false;
byte colorcount = 0;

for(byte fila = 0; fila < mano.length; fila++) {
for( byte elemento = 0; elemento < mano.length; elemento++) {
if (fila != elemento) {
if(mano[fila].getPalo().equals(mano[elemento].getPalo())) {
colorcount++;
}
}
}
}

if(colorcount == 5) {
haycolor = true;
}

return haycolor;
}

public static void main(String... args) {
    CardsPack pack = new CardsPack();
    pack.barajar();
    Card[] mano = pack.repartirMano();
    pack.analizarMano(mano);
   
  }
}


Lo del full ya hazlo tú

Estás haciendo algo mal, no tiene por qué decir eso.

Esto corre perfectamente:

Código (=java) [Seleccionar] Expandir


package javase.matrices.cine.film;

import java.util.Random;
import javase.matrices.cine.ticket.Ticket;


public class Fiml {
   
    private float ticketPrice = 0f;
    private static final int MAX_FREE = 10;
    private static final float PRICE = 7.50f;
    private String id, descripcion;
    Ticket[][] tickets = new Ticket[10][40];

    public void generarTicket(String id, String descripcion) {
        Random generator = new Random();
        int tipoEntrada = 1 + generator.nextInt(400);

        for (byte fila = 0; fila < tickets.length; fila++) {
            for (byte columna = 0; columna < tickets[fila].length; columna++) {

                if (tipoEntrada % 7 == 0) {
                    this.ticketPrice = 0;
                }
                else {
                    this.ticketPrice = PRICE;
                }

                Ticket ticket = new Ticket(id, descripcion, this.ticketPrice, false);
                tickets[fila][columna] = ticket;
            }
        }
    }
   
    public void printTickets() {
        for(byte fila = 0; fila < tickets.length; fila ++) {
            for (byte columna = 0; columna<tickets[fila].length; columna ++) {
                System.out.println(tickets[fila][columna].toString());
            }
        }
    }
   
    public static void main(String... args) {
        Fiml film = new Fiml();
        film.generarTicket("1252", "Campo de entrenamiento.");
        film.printTickets();
    }

}


Ticket puede ser una pojo. Una pojo es una clase que va a interactuar con el exterior por medio de setters y getters solamente. Tú la has creado como pojo.

La matriz de tickets la he colocado en la clase Film.

Ahora bien, la estructura de la matriz son: [filas] [columnas]. Así que al hacer esto:

Código (=java) [Seleccionar] Expandir


Tickets[][] tickets = new Tickets[10][40]; // 10 filas 40 columnas


TipoEntrada determina cuál es el tipo de entrada, si es gratuita o precio regular, por eso hago (tipoEntrada % 7 == 0). Si es múltiplo de 7 la entrada será gratuita, de lo contrario, tendrá un precio regular.

Sobre por qué uso byte en vez de int, pues lo que pasa es que soy un maníaco con el manejo de la memoria xD. Seguramente ya sabes que int ocupa 4 bytes mientras que byte 1 solo. En un int puedes almacenar una gran cantidad de números, es por eso, que utilizo byte, por que el valor máximo que va a almacenar es el máximo de entradas gratis (10).


Saludos.

No entiendo bien tu código, además no puedo saber qué métodos y atributos tiene Ticket, pero yo lo haría así:

Código (=java) [Seleccionar] Expandir


Tickets[][] tickets = new Tickets[10][40];

private void generarTicket(String id, String descripcion) {
Random generator = new Random();
int tipoEntrada = 1 + generator.nextInt(MAX_FREE);
Ticket ticket;

for (byte fila = 0; fila < tickets.length; fila++) {
for (byte columna = 0; columna < tickets[fila].length; columna++) {

if (tipoEntrada % 7 == 0) {
this.ticketPrice = 0;
}
else {
this.ticketPrice = PRICE;
}

Ticket ticket = new Ticket(id, descripcion, this.ticketPrice, false);
tickets[fila][columna] = ticket;
}
}
}


En donde creo una matriz de Tickets, para guardar allí los tickets. No sé si querrás esto, de todos modos te lo dejo.


Saludos.

[especifica]

Toda interfaz es abstracta. No es necesario especificar en la interfaz qué variables recibirán valores. Una clase abstracta significa que estamos abstrayendo una idea, las especificaciones se hacen a partir de éstas, ya sea por herencia o por implementación.

En la interfce escribe los métodos como: getNombre(), setNombre(), getEdad(), setEdad(), etc. Luego, en la clase que implementa esa interfaz, especifica lo que debe hacer ese método.


Saludos.

Código (=java) [Seleccionar] Expandir


JFileChooser chooser = new JFileChooser();
javax.swing.filechooser.FileFilter filtro = new FileNameExtensionFilter("",".mp3");
chooser.setFileFilter(filtro);

int returnVal = chooser.showOpenDialog(null);
if(returnVal == JFileChooser.APPROVE_OPTION) {

// crea un modelo de lista
DefaultListModel model = new DefaultListModel();
JList list = new JList(model);
int pos = list.getModel().getSize();
// agrega el mp3 al modelo
model.add(pos, chooser.getSelectedFile());
}


Igual mira Java Media Framework, te simplifica el trabajo mucho, es sencillo de manejar.

Hola.

1) Lo que te he dado es un simple Demo para 'plantear' la idea que se me ocurrió. Puntos como el que acabas de dar son los que hacen que la idea general se pueda mejorar y posteriormente plasmar en el código.

Puedes hacer listas de médicos y de ćodigos de citas, para simular diversas citas (con diversos médicos o con el mismo) en la pojo Paciente. También puedes especificar una lista estática de médicos disponibles, cada uno con su especialidad, turno, etc. Y así al hacer la consulta, revisar qué medicos están disponibles y si su especialidad concuerda con el problema del paciente.

Deja fluir tu imaginación.

2) El enunciado es una cagada, está mal redactado (siempre veo esto en la universidad xD).

3) Puedes crear una interfaz con nombre, dirección, teléfono, edad, etc, que puedes implementar en los pacientes y también en los empleados.

4) Trastea todo lo que se te ocurra!


Saludos.


PD: Un POJO es una instancia de una clase que no extiende ni implementa nada en especial. Una pojo debe tener atributos private y setters y getters para éstos. Se usa para crear instancias en donde éstas interactúan con otros objetos a través de setters y getters.

[es un]

Para que puedas usar herencia, debes preguntarte si hay una relación es un. Si es así, este es un caso en donde podrás usar herencia.

Ahora bien, como Médico no es un empleado, entonces no debe heredar de Empleado, en mi opinión no debe heredar de ninguna clase. Lo mejor sería hacer a ese médico una especie de pojo, así como a Paciente.

Cuando creamos la clase CitaMédica, puedes crear una Lista de citas y usar a Medico para registrar sus datos en la consulta.

Cuando se registra la cita:



Cuando se consulta una cita:



NOTA: YA TÚ CÁMBIALE EL TÍTULO A LOS DIÁLOGOS PARA DIFERENCIARLOS, XD.



Paciente:

Código (=java) [Seleccionar] Expandir


package javase.poo.empleados.pojo;

import javase.poo.empleados.medico.Medico;


public class Paciente {
   
   private String nombre;
private long codigoCita;
private int edad;
private String causaCita;
private String telefono;
private Medico medico;

public Paciente() {
this.nombre = "";
this.codigoCita = 0;
this.edad = 0;
this.causaCita = "";
this.telefono = "";
this.medico = null;
}

   public String getNombre() {
       return nombre;
   }

   public void setNombre(String nombre) {
       this.nombre = nombre;
   }

   public long getCodigoCita() {
       return codigoCita;
   }

   public void setCodigoCita(long codigoCita) {
       this.codigoCita = codigoCita;
   }

   public int getEdad() {
       return edad;
   }

   public void setEdad(int edad) {
       this.edad = edad;
   }

   public String getCausaCita() {
       return causaCita;
   }

   public void setCausaCita(String causaCita) {
       this.causaCita = causaCita;
   }

   public String getTelefono() {
       return telefono;
   }

   public void setTelefono(String telefono) {
       this.telefono = telefono;
   }

   public Medico getMedico() {
       return medico;
   }

   public void setMedico(Medico medico) {
       this.medico = medico;
   }
       
   @Override
   public String toString() {
       String data = "";
       data = "Nombre del paciente:\t" + this.getNombre();
data += "\nCausa de la cita:\t" + this.getCausaCita();
data += "\nEdad del paciente:\t" + this.getEdad();
data += "\nTelefono:\t" + this.getTelefono();
data += "\n\nMedico a cargo:\t" + this.getMedico().toString();

return data;
   }
       
}


Medico:

Código (=java) [Seleccionar] Expandir


package javase.poo.empleados.medico;


public class Medico {
   
   private String nombre;
   private String especialidad;
   
   public Medico() {
       this.nombre = "";
       this.especialidad = "";
   }
   
   public Medico (String nombre, String especialidad) {
       this.nombre = nombre;
       this.especialidad = especialidad;
   }

   public String getNombre() {
       return nombre;
   }

   public void setNombre(String nombre) {
       this.nombre = nombre;
   }

   public String getEspecialidad() {
       return especialidad;
   }

   public void setEspecialidad(String especialidad) {
       this.especialidad = especialidad;
   }
   
   @Override
   public String toString() {
       String data = "";
       data += "\nNombre:\t" + this.getNombre();
       data += "\nEspecialidad:\t" + this.getEspecialidad();
       
       return data;
   }
}


CitaMedica:

Código (=java) [Seleccionar] Expandir


package javase.poo.empleados.citas;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import javase.poo.empleados.medico.Medico;
import javase.poo.empleados.pojo.Paciente;
import javax.swing.JOptionPane;


public class CitaMedica {
   
   List<Paciente> listaCitas;
   
   public CitaMedica() {
listaCitas = new ArrayList<>();
   }

   public void registrarConsulta() {

Paciente paciente = new Paciente();
Medico medico = new Medico();
Random generador = new Random(System.currentTimeMillis());

String nombrePaciente = txtNombrePaciente.getText();
int edad = Integer.valueOf(txtEdadPaciente.getText());
String causa = txtCausaCita.getText();
String telefono = txtTelefono.getText();
String nombreMedico = txtNombreMedico.getText();
       String especialidad = txtEspecialidadMedico.getText();
       
int codigoCita = generador.nextInt(10000);

       medico.setNombre(nombreMedico);
       medico.setEspecialidad(especialidad);
       
paciente.setNombre(nombrePaciente);
paciente.setCodigoCita(codigoCita);
paciente.setEdad(edad);
paciente.setCausaCita(causa);
paciente.setTelefono(telefono);
paciente.setMedico(medico);

listaCitas.add(paciente);
       JOptionPane.showMessageDialog(null,paciente.toString(),"Info de cita",0);
       codigo = (long) codigoCita;
   }

   public void buscarConsulta(long codigoCita) {

boolean existeCita = false;
int indicePaciente = 0;

for (Paciente paciente : listaCitas) {
if(paciente.getCodigoCita() == codigoCita) {
existeCita = true;
indicePaciente = listaCitas.indexOf(paciente);
                          break;
}
}

if(existeCita) {
String data;

data = "Nombre del paciente:\t" + listaCitas.get(indicePaciente).getNombre();
data += "\nCausa de la cita:\t" + listaCitas.get(indicePaciente).getCausaCita();
data += "\nEdad del paciente:\t" + listaCitas.get(indicePaciente).getEdad();
data += "\nTelefono:\t" + listaCitas.get(indicePaciente).getTelefono();
data += "\n\nMedico a cargo:\t" + listaCitas.get(indicePaciente).getMedico().toString();

JOptionPane.showMessageDialog(null,data,"Informacion de la cita",JOptionPane.INFORMATION_MESSAGE);
}
else {
JOptionPane.showMessageDialog(null,"No se ha registrado la cita","No encontrada",1);
}

   } // fin buscarCita
   
}



En la clase CitaMedica, lo que hago es crear una lista que hace uso de Generics, en este caso es una lista de Pacientes. A este paciente le asigno los datos que se han ingresado, además del nombre y la especialidad del médico, pero éstos datos se los asigno al objeto Medico, luego le asigno al objeto Paciente para asociar un paciente a su médico. Además, genera un número aleatorio que simulará un código de consulta.

La clase Medico sobreescribe el método toString(), para obtener en forma de Texto los datos del mismo.

En la clase CitaMedica también programo el método buscarConsulta, que recibe un código long (código de cita) y en caso haya coincidencias, muestra la información de la cita en un diálogo, de lo contrario, informará que no se ha registrado esa cita.

La clase Paciente es una pojo, vamos a crear objetos de esta clase para asignarle los datos y posteriormente agregarlos a lista.


Espero te haya sido de ayuda.

¿Lo que deseas es cargar en memoria todos los módulos de tu aplicación desde el principio?

Al parecer tienes problemas de rendimiento, eso no es problema de Java, si no de los algoritmos. Analiza tus algoritmos con Big O para que puedas hacer más eficiente tus algoritmos.

Si optas por la misma opción, vas a sobrecargar la aplicación con módulos innecesarios, como tener el JDialog de opciones abierto todo el tiempo, que consumirá ram en todo el tiempo que la aplicación esté ejecutándose.

Si accedes por esto último, en StackOverFlow te darán una respuesta muy acertada.


Saludos.

Así es. No olvides siempre usar paquetes para tus clases. Cuando estés trabajando en un proyecto mediano, los paquetes serán escenciales para ordenar tu proyecto 

Un saludo.