Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - Kabuto

Páginas: 1 ... 4 5 6 7 8 [9] 10 11 12 13 14 ... 50
161
Aprender a programar desde cero / Re: Ejercicios de Java
« en: 29 de Julio 2022, 13:31 »
Hola.

Mira, para publicar código aquí en el foro, has de ponerlo entre las etiquetas code
Estas etiquetas aparecen automáticamente en el texto de los botones de arriba del campo de texto, si pulsas el botón con esta imagen -->

Yo a veces, cuando quiero resaltar texto en colores para poder explicarme mejor, uso como alternativa las etiquetas quote, que es el botón con la imagen -->
No es lo ideal para compartir código, pero sí para dar explicaciones.

Sobre tu código, hay algunos fallos totalmente comprensibles si no se conoce bien el lenguaje Java.

El array te sale con valor nulo porque NUNCA se inicia con unos valores. Tu crees que sí, pero no es así.
El array que señalo en azul, en realidad, es otro array distinto del que señalo en rojo:
Citar
public class Filtro {
   
   private static Salud[] arrayFiltro;

   public static void main(String[] args) {
      Salud[] arrayRecords = new Salud[]{
            new Salud("Sangre", "Colesterol"),
            new Salud("Termometro", "Temperatura"),
            new Salud("Oximetro", "Oxigeno"),
            new Salud("Tensiometro", "Presion Arterial"),
            new Salud("Glucosa", "Azucar en la Sangre"),

      };

      Salud[] arrayFiltro = new Salud[]{
            new Salud("Gasa", "Suturas"),
            new Salud("Tensiometro", "Alcohol")
      };
Aunque se llamen igual, son arrays diferentes.
¿Por qué? Porque en el array que señalo en rojo, delante del nombre has puesto Salud[]
Citar
Salud[] arrayFiltro = new Salud[]

Al hacerlo así, Java interpreta que estás declarando un array totalmente nuevo, a pesar de que tiene el mismo nombre que el que hay señalado en azul. Y en esta ocasión te permite usar el mismo nombre para dos arrays, porque están en distintos ámbitos(lo de los ámbitos no lo vamos a explicar ahora porque será demasiada info de golpe...)

La cuestión es que para que Java sepa que en realidad lo que quieres inicializar es el array declarado previamente, para inicializarlo has de poner solamente su nombre, sin indicar su tipo de dato.
Citar
public class Filtro {
   
   private static Salud[] arrayFiltro;

   public static void main(String[] args) {
      Salud[] arrayRecords = new Salud[]{
            new Salud("Sangre", "Colesterol"),
            new Salud("Termometro", "Temperatura"),
            new Salud("Oximetro", "Oxigeno"),
            new Salud("Tensiometro", "Presion Arterial"),
            new Salud("Glucosa", "Azucar en la Sangre"),

      };

      arrayFiltro = new Salud[]{
            new Salud("Gasa", "Suturas"),
            new Salud("Tensiometro", "Alcohol")
      };
Aquí ahora, sí estamos tratando con el mismo array, y no con dos.


Sobre el método filtrados(), aquí hay mucho que comentar... ;)

Comencemos por la comparación que señalo en rojo.
Citar
   public static ArrayList<Salud> filtrados(Salud[] arrayRecords) {
      ArrayList<Salud> objetosFiltrados = new ArrayList<>();

      for(int i=0; i<arrayRecords.length; i++) {
         if(arrayRecords[ i] == arrayFiltro[ i] || arrayRecords[ i].item == arrayFiltro[ i].item || arrayRecords[ i].item == arrayFiltro[ i].item2 || arrayRecords[ i].item2 == arrayFiltro[ i].item)
            objetosFiltrados.add(arrayFiltro[ i]);
      }

      return objetosFiltrados;
   }

Ahí estás preguntando (bueno, pretendes preguntar...) si dos elementos de clase Salud son iguales

El comparador == solo sirve para comparar tipos de datos primitivos.
Los tipos int, double, char, float, boolean, byte, short y long son los llamados tipos primitivos.
Se les llama primitivos porque son datos simples, básicamente son valores numéricos y por eso es muy fácil compararlos para saber si son iguales == , si uno es mayor > , si es menor < ...
Para el ordenador es muy fácil determinar si 5 es mayor que 4.

En cambio, el resto de datos que vamos a manejar en Java, serán objetos de clase
String, ArrayList, Scanner, Math, Salud, Object, Persona, Animal, Estudiante, Vehículo,...
La lista es infinita porque nosotros mismos podemos crear tantas nuevas clases como nos de la imaginación.

Todos estos datos son mucho más complejos internamente y no es fácil hacer comparaciones entre ellos.
Ya no es solo una cuestión de complejidad interna, si no también de la naturaleza de cada clase.
Si comparamos dos objetos Persona para saber si son iguales, no podemos usar simplemente == y ya está.
Porque, ¿cómo puede saber el computador si son iguales?
¿Por tener mismo nombre y apellidos? Pues no, hay cientos de personas que se llaman Francisco Rodriguez Lopez y no son la misma...

Para comparar objetos de clases, hay que escribir código y decirle al computador cómo queremos que decida si son iguales, o quien es mayor y menor.
Para el ejemplo de objetos Persona, probablemente le pediremos que compare sus DNI / cédula identificativa para determinar si dos personas "son iguales".

Aunque quizás en nuestro programa nos da igual sus nombres e ID, quizás sea un programa para crear dietas saludables y entonces vamos a querer considerar a dos Personas iguales si tienen la misma edad y peso...

Pero bueno, no vamos a profundizar más en esto.
Lo importante es que recuerdes que hay dos tipos de datos:
- los primitivos (se escriben en minúscula) con los que podemos usar los operadores de comparación
- las clases (se escriben con la primera letra mayúscula) que por su complejidad y naturaleza variable se necesita escribir código extra para decidir cómo se comparan

Si para objetos de clase utilizas el comparador ==, Java te lo admite como sintaxis correcta, pero no va a hacer lo que tú necesitas.
Lo que va a hacer es comprobar si esos objetos, en realidad son uno solo pero con distintas referencias.
Tampoco quiero divagar mucho con esto ahora, pero has de saber que un mismo objeto de clase puede tener muchas referencias (nombres).
Si yo hago esto:
Código: [Seleccionar]
Persona persona1 = new Persona("Perico", "Palotes");
Persona persona2 = persona1;
Persona persona3 = persona2;Hay tenemos tres referencias: persona1, persona2 y persona3.
Pero en realidad solo hay un objeto, lo que pasa es que esas tres referencias están apuntando al mismo objeto.
Entonces, si preguntamos esto:
Código: [Seleccionar]
if (persona1 == persona3)La respuesta será TRUE, porque apuntan al mismo objeto.

Ahora, si escribimos esto:
Código: [Seleccionar]
Persona persona1 = new Persona("Perico", "Palotes");
Persona persona2 = persona1;
Persona persona3 = new Persona("Perico", "Palotes");Y volviéramos a preguntar si persona1 es igual que persona3, la respuesta sería FALSE.
Porque ahora apuntan a dos objetos distintos. No importa si tienen el mismo nombre y apellido, internamente ocupan distintas posiciones de memoria así que son dos objetos diferentes.



Vale, te he escrito media Biblia para decirte que no puedes usar el comparador == con la clase Salud
De hecho, el resto de comparaciones donde comparas los "item" tampoco van a funcionar bien, porque los item son de clase String, así que tampoco nos sirve el comparador ==  :o
Citar
   public static ArrayList<Salud> filtrados(Salud[] arrayRecords) {
      ArrayList<Salud> objetosFiltrados = new ArrayList<>();

      for(int i=0; i<arrayRecords.length; i++) {
         if(arrayRecords[ i] == arrayFiltro[ i] || arrayRecords[ i].item == arrayFiltro[ i].item || arrayRecords[ i].item == arrayFiltro[ i].item2 || arrayRecords[ i].item2 == arrayFiltro[ i].item)
            objetosFiltrados.add(arrayFiltro[ i]);
      }

      return objetosFiltrados;
   }

 >:( ¿Entonces cómo carajo podemos comparar las clases?
Hay varias formas, pero la principal es utilizar el método equals(). Este es un método especial que TODAS las clases de Java poseen.
Sí, tu clase Salud también lo tiene aunque tú no se lo hayas escrito. Es un método que todas las clases heredan automáticamente (no voy a explicar ahora herencia de clases), sin embargo, por sí solo no sirve para nada. Los programadores debemos sobreescribir dicho método para dotarlo de las instrucciones necesarias para que el computador sepa como ha de comparar los objetos de nuestra clase.

Así que nos vamos a tu clase Salud(que también requiere de otras correcciones que veremos luego) y comenzamos añadiendo lo siguiente:
Citar
class Salud {

   public final String item;
   public final String item2;
   private Salud[] arrayRecords;

   public Salud(String item, String item2){
      this.item = item;
      this.item2 = item2;
   }

   public void display(){
      System.out.println("Los record que coinciden son: " + Filtro.filtrados(arrayRecords));
   }

   public String getItem() {
      return this.item;
   }
   public String getItem2() {
      return this.item2;
   }
   
   @Override
   public boolean equals(Object objeto) {
      
   }

}
Ahí dentro de ese método, vamos a decidir como deben compararse dos objetos Salud para determinar si son iguales.
La etiqueta @Override no es obligatoria, pero si recomendable. Sirve para decirle a Java que ese método va a sobrescribir un método que se recibe por herencia, así el compilador se encargará de comprobar que lo estamos sobrescribiendo correctamente.
Además también sirve para que otros programadores que lean nuestro código, sepan enseguida que es un método heredado.

Fíjate que el método recibe como argumento un tipo de dato Object, esta es una clase especial, es la madre de TODAS las clases. De hecho, es de ella de quien las otras clases heredan el método equals() y otros más.
Esto significa que este método puede recibir un objeto que no sea de clase Salud, cosa que hemos de tener en cuenta a la hora de compararlos

Bien, ahora es cuando hemos de decidir cuándo dos objetos Salud son iguales.
A priori, lo normal sería considerar dos objetos Salud iguales, si sus dos items son también iguales.
Sin embargo, para hacer el filtrado nos basta con que al menos uno de sus items coincidan. Así que eso es lo que vamos a decidir:
- Dos objetos Salud serán iguales si al menos uno de sus items coinciden
Citar
   @Override
   public boolean equals(Object objeto) {
      
      if (objeto instanceof Salud) { //Si objeto recibido es de clase Salud...
         //Lo instanciamos como Salud
         Salud otroObjeto = (Salud) objeto;
         //Si al menos uno de sus items coinciden, se considerarán iguales
         if (this.item.equals(otroObjeto.item) || this.item.equals(otroObjeto.item2)
               || this.item2.equals(otroObjeto.item) || this.item2.equals(otroObjeto.item2))
            return true;
         else
            return false; //Ningún item coincide
         
      }
      else
         return false; //Objeto recibido no es clase Salud
      
   }

Lo primero que hacemos es comprobar si el Object recibido es en realidad de clase Salud.
Si no lo es, retornamos FALSE y se acabó.
Si lo es, entonces hacemos un casting para tratarlo como un objeto Salud y pasamos a comparar sus items.
Si alguno coincide, retornamos TRUE.
Si no coincide, retornamos FALSE.

Fíjate que para compara los items, también estamos usando un método equals(). Este equals() pertenece a la clase String.
Así que para comparar cadenas String usaremos también equals(), la diferencia es que este método ya viene escrito "de fábrica" por el Sr. Java, no hace falta que también lo escribamos nosotros. Los String ya saben como han de compararse entre ellos.

Vale, pues ya tenemos nuestro método equals(), ¿cómo le damos uso?
Volvemos a la clase Filtro, al método donde hacíamos las comparaciones.
Ahora basta con comparar de esta manera:
Citar
   public static ArrayList<Salud> filtrados(Salud[] arrayRecords) {
      ArrayList<Salud> objetosFiltrados = new ArrayList<>();

      for(int i=0; i<arrayRecords.length; i++) {
         if(arrayRecords[ i].equals(arrayFiltro[ i]))
            objetosFiltrados.add(arrayRecords[ i]);
      }

      return objetosFiltrados;
   }

¿Solucionado?
Pues no, hay otro problema que no he comentado antes.
Estás usando el mismo índice para recorrer los dos arrays y comparar sus elementos.
Esto en realidad, conlleva dos problemas:

1- Hay elementos que no se comparan entre ellos. Como solo usas un índice, el elemento de la posición[ 0] del arrayRecord, solo se compara con el elemento [ 0] de arrayFiltro.
Pero no se compara con [ 1], ni con [ 2].., ni con ningún otro.

2- Como los arrays tienen longitudes distintas, se va a producir una Excepción (un error) cuando el índice intente apuntar a elementos que no existen.
arrayRecord es más grande, longitud 5, así que tiene las posiciones: [ 0], [ 1], [ 2], [ 3] y [ 4]
Pero arrayFiltro solo tiene longitud 2, o sea, posiciones [ 0] y [ 1].
Cuando el índice intente comparar las posiciones [ 2] de ambos arrays, no podrá porque arrayFiltro no tiene. Y eso interrumpirá el programa con un mensaje de error.

Ambos problemas se pueden solucionar usando dos bucles anidados
De esta forma, cada array tiene su propio índice, el cuál solo apuntará a posiciones que sí existen.
Y además, se garantizan todas las posibles comparaciones, porque por cada repetición del bucle principal, el bucle anidado hará un recorrido completo del segundo array. Así cada elemento del primer array, se comparará con TODOS los elementos del segundo array.

Citar

   public static ArrayList<Salud> filtrados(Salud[] arrayRecords) {
      ArrayList<Salud> objetosFiltrados = new ArrayList<>();

      for(int i=0; i<arrayRecords.length; i++) { //Bucle principal, recorre arrayRecord
         for (int j=0; j<arrayFiltro.length; j++) { //Bucle anidado, recorre arrayFiltro
            if(arrayRecords[ i].equals(arrayFiltro[j])) //Cada array usa su propio indice
               objetosFiltrados.add(arrayRecords[ i]);
         }   
      }

      return objetosFiltrados;
   }

Por último, volviendo a la clase Salud.
Esta clase se supone representa un "objeto de salud" y consta de dos ítems.
Vale, eso me parece bien.

Lo que no tiene sentido es que tenga como atributo un array de objetos Salud.
En el mundo real, ¿un Tensiómetro contiene dentro a su vez una serie de otros objetos como Glucosa o Gasas?
No tiene sentido, ¿verdad?
Si no lo tiene en el mundo real, tampoco lo tiene en el código.

Su método display() tampoco tiene sentido. Un objeto Salud no tiene que saber que objetos han sido filtrados y cuáles no.
Su existencia ha de ser ajena a ese tema, de eso ya se ocupa la clase Filtro.
Su método display() lo único que ha de hacer es mostrar los datos de ESTE(this) objeto, lo que pase con otros objetos ajenos a él, ni le va ni le viene.
Citar
class Salud {

   public final String item;
   public final String item2;
   private Salud[] arrayRecords;

   public Salud(String item, String item2){
      this.item = item;
      this.item2 = item2;
   }

   public void display(){
      System.out.println("Los record que coinciden son: " + Filtro.filtrados(arrayRecords));
   }

   public String getItem() {
      return this.item;
   }
   public String getItem2() {
      return this.item2;
   }
   
   @Override
   public boolean equals(Object objeto) {
      
      if (objeto instanceof Salud) { //Si objeto recibido es de clase Salud...
         //Lo instanciamos como Salud
         Salud otroObjeto = (Salud) objeto;
         //Si al menos uno de sus items coinciden, se considerarán iguales
         if (this.item.equals(otroObjeto.item) || this.item.equals(otroObjeto.item2)
               || this.item2.equals(otroObjeto.item) || this.item2.equals(otroObjeto.item2))
            return true;
         else
            return false; //Ningún item coincide
         
      }
      else
         return false; //Objeto recibido no es clase Salud
      
   }

}

Mejor dejarlo así:
Citar
class Salud {

   public final String item;
   public final String item2;

   public Salud(String item, String item2){
      this.item = item;
      this.item2 = item2;
   }

   public void display(){
      System.out.println("Item 1: " + this.item + " -- Item 2: " + this.item2);
   }

   public String getItem() {
      return this.item;
   }
   public String getItem2() {
      return this.item2;
   }
   
   @Override
   public boolean equals(Object objeto) {
      
      if (objeto instanceof Salud) { //Si objeto recibido es de clase Salud...
         //Lo instanciamos como Salud
         Salud otroObjeto = (Salud) objeto;
         //Si al menos uno de sus items coinciden, se considerarán iguales
         if (this.item.equals(otroObjeto.item) || this.item.equals(otroObjeto.item2)
               || this.item2.equals(otroObjeto.item) || this.item2.equals(otroObjeto.item2))
            return true;
         else
            return false; //Ningún item coincide
         
      }
      else
         return false; //Objeto recibido no es clase Salud
      
   }

}

Y con todos estos cambios, el programa ya corre y parece cumplir con lo que se le ha pedido.

Siento si he escrito demasiado, pero corregir sin explicar motivos, sería una oportunidad perdida para aprender.

Revísalo con calma todo y pregunta lo que necesites.
Un saludo.

162
C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Menú en Java para Pilas
« en: 29 de Julio 2022, 00:32 »
Yo lo que veo es que tienes dos métodos llamados getTamanio()(los marco en rojo), y eso no es permisible.

Citar
package menu;

public class Pila {
   
     //Definiendo los atributos de la pila
   
    private Nodo inicio;
   
    private int tamanio;

    //Constructor
    public void Pila(){
        inicio=null;
        tamanio=0;
    }
   
    /** Consulta si la pila esta vacia
    *@return true si el primer nodo (inicio), no apunta a otro nodo.
    */
    public boolean esVacio(){
        return inicio==null;
    }
   
     /**
     * Consulta cuantos elementos (nodos) tiene la pila.
     * @return numero entero entre (0,n)donde n es el numero de elementos
     * que contenga la lista
     */
    public int getTamanio(){
        return tamanio;       
    }
   
     public void apilar(int valor){
     //Definir nuevo nodo
     Nodo nuevo= new Nodo();
     //Agrega al valor Nodo
     nuevo.setValor(valor);
     //Consultar si la pila esta vacia.
     
     if(esVacio()){
         //Inicializa la pila con el nuevo valor
         inicio=nuevo;
     }
     //en caso contrario agrega el nuevo nodo al inicio de la pila
     else{
         nuevo.setSiguiente(inicio);
         inicio= nuevo;
        }
     //Incrementa el contador del tamaño de la pila
        tamanio++;
     }   
    //Elimina el elemento que se encuentra en el tope de la pila
    public void retirar(){
        if(!esVacio()){
            //Asigna como primer nodo al siguiente de la pila
            inicio= inicio.getSiguiente();
            //Decremento de la variable del contador del tamaño de la pila
            tamanio--;
           
        }
    }

    //Metodo que regresa el valor que esta en la cima de la pila
   
    public int cima() throws Exception{
    if(!esVacio()){
        return inicio.getValor();
        }   
    else
        {
        throw new Exception("La pila se encuentra vacia");
        }
    }
   
    public boolean buscar(int referencia){
        //Crear una copia de la pila
        Nodo aux = inicio;
        //Verificar si existe el elemento a buscar
        boolean existe= false;
       
        //Recorre la pila hasta llegar a encontrar el nodo o
        //llegar al final de la pila
       
        while(existe !=true && aux!=null){
            //Compara si el valor del nodo es igual al valor de la referencia
            if(referencia==aux.getValor()){
                existe=true;
            }
            else
            {
                //Avanza al siguiente nodo
                aux= aux.getSiguiente();
            }
        }
        return existe;
    }

    String getTamanio() {
        throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
    }
}   

163
Aprender a programar desde cero / Re: Ejercicios de Java
« en: 29 de Julio 2022, 00:22 »
Sí, el siguiente ejercicio es muy similar. Lo único que puede ser algo más difícil es idear como representar eso de "los filtros", ya que el enunciado no da indicaciones precisas y lo deja todo en manos de nuestra imaginación.

Mejor si intentas tú dar con alguna solución. Aunque no lo consigas, no importa, el simple hecho de intentarlo, atascarte, ver cuáles son las dificultades,... eso ya sirve para aprender mucho.

Aún así, voy a dejar aquí la solución que he concluido yo.
Mi idea ha sido modelar una clase que represente "objetos de salud", con los atributos nombre, descripción y filtros
Este último atributo, los filtros, sería una serie de palabras "clave" que servirían para identificar un objeto según unas categorías.

Por ejemplo, unas mascarillas podrían tener como filtros las palabras "desechable"(son de usar y tirar), "prevencion"(no sirven para curar, sirven para prevenir infecciones), "bucal", "nasal" (protegen nariz y boca)

Un Termometro Digital podría tener como filtros "temperatura"(sirve para medir eso), "digital" (para diferenciarlo de uno de mercurio, aunque están prohibidos en la mayor parte del mundo) y "diagnostico"(no sirve para curar ni prevenir, si no para diagnosticar el estado de salud)

Entonces, el programa consistiría en pedir al usuario que nos indique un filtro, o varios filtros, y entonces buscar cuáles son los objetos que coinciden con esos filtros y mostrarlos en pantalla.

Como para los filtros vamos a usar varias palabras, en lugar de usar muchos Strings, podemos tratarlos como una única cadena, separando cada palabra con un punto y coma para distinguir un filtro de otro.
Por ejemplo: "temperatura;digital;diagnostico"
Ahí tenemos tres filtros en una única cadena. Y podríamos tener cinco, diez..., tantos como queramos.

Bueno, pues como antes, haremos una clase para modelar el "Objeto de Salud" y otra con el programa principal main().

Esta sería la clase ObjetoSalud. En esta ocasión no he puesto todos los métodos get y set, ya que total para este ejercicio no los vamos a utilizar.
Solo le he puesto los dos métodos que necesitamos.
Uno es el "clásico" método toString(), que construye una cadena con los datos que queremos mostrar en pantalla para representar un objeto de esta clase.

El otro, es un método boolean que recibe una cadena de filtros como argumento.
Separa estos filtros en cadenas separadas (con el método split() de la clase String).
Una vez separados, comprueba si alguno de esos filtros coincide con los indicados en el atributo "filtros" de este objeto.

Si coincide alguno, retorna true. Si no coincide ninguno, retorna false.
Así gracias a este método sabremos que objetos hay que seleccionar según los filtros indicados por el usuario.
Código: [Seleccionar]
package objetosSaludFiltro;

public class ObjetoSalud {

private String nombre;
private String descripcion;
private String filtros;

public ObjetoSalud(String nombre, String descripcion, String filtros) {
this.nombre = nombre;
this.descripcion = descripcion;
this.filtros = filtros;
}

/*
* Recibe una cadena con varios filtros y comprueba
* si al menos uno coinciden con los de este objeto
*/
public boolean coincideFiltro(String filtros) {
/*
* Recibimos una cadena con varios filtros
* separados por un punto y coma.
* Vamos a separar cada filtro como una cadena
* única y los agruparemos en un array
*/
String[] flt = filtros.split(";");

/*
* Ahora recorremos este array y si algún filtro coincide
* con los de este objeto, retornamos true
*/
for (String filtro: flt)
if (this.filtros.contains(filtro))
return true;

//Si este bucle termina sin retornar true, es que ningún filtro coincide
return false;
}

/*
* Construye una cadena descriptiva de este objeto
* y la retorna para que pueda ser mostrada en pantalla
*/
public String toString() {
return "Nombre: " + nombre + " ----- Descripcion: " + descripcion;
}

Y ahora la clase principal.
Como antes, crearemos un array con varios objetos predefinidos. Esta vez si les he dado valores "reales" para hacer más interesante el ejercicio.
Además hay una lista de los posibles filtros que el usuario puede elegir.

Y esta vez, usaremos un bucle para que el programa se repita una y otra vez, hasta que el usuario elija cuando terminar.
En cada repetición del bucle, le mostraremos la lista de filtros disponible y le pediremos que introduzca uno o varios filtros, separados con punto y coma.

Cuando nos de una lista de filtros, usaremos un método que creará un segundo array solo con los objetos que coincidan con esos filtros, se mostrarán en pantalla y el proceso volverá a repetirse.
Si el usuario quiere terminar el programa, tiene que pulsar ENTER sin teclear nada cuando le pidamos filtros.


Como ves la lógica es muy similar al ejercicio anterior, pero esta vez lo hacemos más interesante porque le vamos a pedir datos por teclado al usuario y el programa no termina hasta que no lo elija el usuario.

Código: [Seleccionar]
package objetosSaludFiltro;

import java.util.Scanner;

public class Filtrado {

public static void main(String[] args) {
//Objeto Scanner para solicitar entradas por teclado
Scanner teclado = new Scanner(System.in);

//Lista de filtros disponibles
final String FILTROS = "temperatura;digital;diagnostico;prevencion;bucal;nasal;topico"
+ "desechable;tratamiento;respiratorio;infrarrojo;oxigeno;";

//Objetos para la salud
ObjetoSalud[] objetos = new ObjetoSalud[] {
new ObjetoSalud("Termometro Digital", "Termometro para medir temperatura corporal por contacto",
"temperatura;digital;diagnostico"),
new ObjetoSalud("Termometro Infrarrojo", "Termometro para medir temperatura corporal sin contacto",
"temperatura;digital;diagnostico;infrarrojo"),
new ObjetoSalud("Oximetro Digital", "Dispositivo para medir saturación oxigeno en sangre",
"oxigeno;digital;diagnostico"),
new ObjetoSalud("Mascarilla FFP2", "Mascarilla para filtrado de particulas y aerosoles",
"bucal;nasal;prevencion;desechable"),
new ObjetoSalud("Jeringa sin aguja", "Jeringa con émbolo de apertura ancha para tomar muestras",
"desechable;diagnostico"),
new ObjetoSalud("Jeringa con aguja", "Jeringa con émbolo de apertura estrecha para inyecciones",
"desechable;tratamiento"),
new ObjetoSalud("Nebulizador eléctrico", "Dispositivo para vaporizar medicamentos y poder inhalarlos",
"digital;tratamiento;respiratorio;bucal"),
new ObjetoSalud("Gel hidroalcoholico", "Gel para desinfeccion de manos",
"prevencion;topico"),
new ObjetoSalud("Povidona Yodada", "Yodo antiséptico para desinfección de heridas",
"tratamiento;topico"),
};

/*
* A continuación haremos un bucle donde pediremos al usuario una serie de filtros.
* En cada iteración del bucle, mostraremos los Objetos de Salud que coincidan con esos filtros.
* El bucle termina cuando el usuario pulsa ENTER sin introducir ningún filtro
*/
String filtros = ""; //Aquí guardamos los filtros que el usuario introduzca
do {
System.out.println("\nFiltros disponibles:\n" + FILTROS);
System.out.println("\nIndique los filtros deseados, separados por ;");
System.out.println("O pulse ENTER sin teclear nada para FINALIZAR");
System.out.print("\nFiltros: ");
filtros = teclado.nextLine(); //Leemos filtros por teclado

if (!filtros.isBlank()) { //Solo buscamos objetos si el usuario nos ha dado algún filtro
ObjetoSalud[] filtrados = filtrarObjetos(objetos, filtros);
if (filtrados.length == 0)
System.out.println("\nNo hay Objetos de Salud que coincidan con esos filtros");
else {
System.out.println("\n\t********************************");
System.out.println("\n\t\tOBJETOS DE SALUD\n");
for (ObjetoSalud objeto: filtrados)
System.out.println(objeto);
System.out.println("\n\t********************************");
}
}

}while(!filtros.isBlank()); //Bucle termina si el usuario no introduce ningún filtro.

teclado.close();
System.out.println("\n\t\tFIN DE PROGRAMA");
}

/*
* Este método recibe un array con ObjetosSalud y una cadena con filtros.
* Se hace una selección de los objetos que coincidan con esos filtros
* y se retornan en un nuevo array.
*/
private static ObjetoSalud[] filtrarObjetos(ObjetoSalud[] objetos, String filtros) {

int contObjetos = 0;
for (int in = 0; in < objetos.length; in++)
if (objetos[in].coincideFiltro(filtros))
contObjetos++;

ObjetoSalud[] filtrados = new ObjetoSalud[contObjetos];
int indiceFiltrados = 0;

for (int indiceObjetos = 0; indiceObjetos < objetos.length; indiceObjetos++) {
if (objetos[indiceObjetos].coincideFiltro(filtros)) {
filtrados[indiceFiltrados] = objetos[indiceObjetos];
indiceFiltrados++;
}
}

return filtrados;
}

}

Y bueno, con los comentarios que he puesto en el código y en el ejercicio anterior, está todo más o menos explicado.
Pero no dudes en preguntar si algo no se entiende.

Y no te desesperes si no has podido encontrar tú soluciones. En mi humilde opinión, son ejercicios un tanto avanzados para pretender que sean resueltos por alguien recién iniciada y sin más explicaciones ni indicaciones que "búscate la vida por Internet"  :-\

164
Aprender a programar desde cero / Re: Ejercicios de Java
« en: 28 de Julio 2022, 21:19 »
Java tiene la ventaja de que efectivamente hay mucha documentación y ejemplos por la red.
Pero, aunque no es un lenguaje difícil, tampoco es el más fácil de aprender. Y como todo, al iniciarse hacen falta explicaciones.

En tu código hay numerosos errores y de todos modos no está estructurado de forma que sea un programa Java.
Mira, para no liar más la madeja, lo mejor es separar el código en distintas clases, siempre que sea posible.

Así que comienza un proyecto Java nuevo, crea una package con el nombre que te de la gana, y dentro de este package escribiremos la clase, o clases, que vamos a necesitar.

Parece ser que necesitas una clase Estudiante. Pues escribamos primero esta clase.
Dicha clase no va a ser ejecutable, por sí sola no sirve para poner en marcha ningún proceso.
Simplemente va a modelar las características que deseamos tenga un estudiante.
Y para este ejercicio vamos a querer que un estudiante tenga como atributos nombre, apellido y un boolean para indicar si ha entregado(true) o no(false) un trabajo asignado.

Además de atributos, esta clase va a tener unos métodos. Es decir, una serie de funciones que permiten realizar distintas tareas con un Estudiante.
Unos nos van a proporcionar los valores actuales de los atributos, otros permitirán modificarlos y además tendremos uno para mostrar en pantalla todos los valores de los atributos en una sola línea.

Código: [Seleccionar]
package entregasEstudiantes;

public class Estudiante {

//Atributos
private String nombre;
private String apellido;
private boolean entregado;

//Constructor
public Estudiante(String nombre, String apellido, boolean entregado) {
this.nombre = nombre;
this.apellido = apellido;
this.entregado = entregado;
}

//Metodos get y set
public String getNombre() {
return nombre;
}

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

public String getApellido() {
return apellido;
}

public void setApellido(String apellido) {
this.apellido = apellido;
}

public boolean isEntregado() {
return entregado;
}

public void setEntregado(boolean entregado) {
this.entregado = entregado;
}

//Método para mostrar datos del Estudiante
public void mostrar(){
System.out.println("Nombre: " + nombre + " Apellido: " + apellido +
" Entrego asignacion: " + entregado);
}
}

Ya tenemos clase Estudiante. Como he dicho, esta clase por si sola no sirve para ejecutar ningún programa.
Necesitamos otra clase, que será la clase principal, la cuál tendrá el método main()
Este es un método especial, que es el que se encarga de hacer que un programa se pueda ejecutar.
Si en nuestro proyecto no tenemos al menos una clase que cuente con dicho método, jamás podremos ejecutar nada.

Este método siempre se declara de esta forma:
Código: [Seleccionar]
package entregasEstudiantes;

public class ListarEntregados {

public static void main(String[] args) {

//Aquí vamos a escribir el código para el programa principal

}

}

Bien, pues dentro de sus llaves es donde vamos a escribir el código que ponga en marcha el programa.
Vamos a ir viéndolo paso a paso.

Primero, vamos a necesitar un array con unos cuantos Estudiantes:
Código: [Seleccionar]
package entregasEstudiantes;

public class ListarEntregados {

public static void main(String[] args) {

//Creamos unos estudiantes genéricos
Estudiante[] arrayEst = new Estudiante[]{

new Estudiante( "Nombre1", "Apellido1", true),
new Estudiante( "Nombre2", "Apellido2", true),
new Estudiante( "Nombre3", "Apellido3", false),
new Estudiante( "Nombre4", "Apellido4", true),
new Estudiante( "Nombre5", "Apellido5", false),
new Estudiante( "Nombre6", "Apellido6", true),
};

}

}

Ahora, habría que buscar la manera de crear un segundo array que contenga solo los estudiantes que sí han entregado sus asignaciones.
El código para hacer esto, podríamos escribirlo dentro del método main() tras la creación de los estudiantes genéricos.

Sin embargo, resulta más elegante y queda más ordenado, si creamos un método por separado que se encargue de esta tarea.
Este método se escribe dentro de esta clase, pero FUERA del método main().

Lo podemos declarar de esta manera:
Citar
public class ListarEntregados {

   //Método main principal que pone en marcha el programa
   public static void main(String[] args) {
      
      //Creamos unos estudiantes genéricos
      Estudiante[] arrayEst = new Estudiante[]{

            new Estudiante( "Nombre1", "Apellido1", true),
            new Estudiante( "Nombre2", "Apellido2", true),
            new Estudiante( "Nombre3", "Apellido3", false),
            new Estudiante( "Nombre4", "Apellido4", true),
            new Estudiante( "Nombre5", "Apellido5", false),
            new Estudiante( "Nombre6", "Apellido6", true),
      };

   }
   
   /* Este método se encarga de recibir un array de estudiantes
    * y crear un nuevo array con solo los estudiantes que han
    * entregado sus asignaciones.
    */
   private static Estudiante[] obtenerEntregados(Estudiante[] estudiantes) {
      //Código para obtener los entregados
   }

}

Fíjate en las partes que marco en rojo. Ahí estamos diciendo que ese método va a RETORNAR un array de Estudiante, y que además va a RECIBIR también como argumento (lo que está entre paréntesis) otro array de Estudiante, y que lo vamos a llamar estudiantes.
Así del array que recibe va a extraer los estudiantes que han hecho entrega, construirá un nuevo array con ellos y lo retornará.
Este array retornado, será recogido en el programa principal para mostrarlo en pantalla, eso lo veremos luego.

Vamos a centrarnos en como crear un array con los estudiantes correctos.
Primero, necesitamos saber cuántos estudiantes han hecho la entrega, porque no podemos crear un array si no sabemos de antemano cuántos elementos va a contener.

Así que lo que haremos será recorrer el array de estudiantes dos veces:
- una para contar los entregados y poder crear un array con el tamaño adecuado
- la segunda, para copiar los estudiantes correctos al nuevo array.

Citar
public class ListarEntregados {

   public static void main(String[] args) {
      
      //Creamos unos estudiantes genéricos
      Estudiante[] arrayEst = new Estudiante[]{

            new Estudiante( "Nombre1", "Apellido1", true),
            new Estudiante( "Nombre2", "Apellido2", true),
            new Estudiante( "Nombre3", "Apellido3", false),
            new Estudiante( "Nombre4", "Apellido4", true),
            new Estudiante( "Nombre5", "Apellido5", false),
            new Estudiante( "Nombre6", "Apellido6", true),
      };

   }
   
   /* Este método se encarga de recibir un array de estudiantes
    * y crear un nuevo array con solo los estudiantes que han
    * entregado sus asignaciones.
    */
   private static Estudiante[] obtenerEntregados(Estudiante[] estudiantes) {
      
      //Primero contamos cuantos estudiantes han hecho entrega
      int contEntregados = 0;
      for (int in = 0; in < estudiantes.length; in++) {
         if (estudiantes[in].isEntregado()) //Si este estudiante ha entregado...
            contEntregados++; //...lo contamos
      }
      
      //Ahora ya sabemos cuánto va a medir el nuevo array, podemos crearlo
      Estudiante[] entregados = new Estudiante[contEntregados];
      
      /*
       * Lo siguiente es volver a recorrer el array de estudiantes
       * y copiar los entregados al nuevo array.
       * Como se va a trabajar con dos arrays que son de tamaños distintos,
       * vamos a necesitar un indice diferente para cada uno, ya que cada uno
       * ha de apuntar a posiciones distintas en los arrays
       */
      int indice1 = 0; //Indice para el array de estudiantes
      int indice2 = 0; //Indice para el array de entregados
      for (indice1 = 0; indice1 < estudiantes.length; indice1++) {
         if (estudiantes[indice1].isEntregado())  {//Si este estudiante ha entregado...
            entregados[indice2] = estudiantes[indice1]; //Hacemos copia en array entregados
            indice2++; //Incrementamos el indice de los entregados
         }
      }
      
      //Por último, retornamos array de entregados
      return entregados;
   }

}


OK, ya tenemos un método que es capaz de crear un array con los estudiantes entregados, a partir de una lista de estudiantes.

Pues ahora volvemos al main() y lo que haremos será invocar a este método y recoger el array que nos va a retornar:
Citar
public class ListarEntregados {

   public static void main(String[] args) {
      
      //Creamos unos estudiantes genéricos
      Estudiante[] arrayEst = new Estudiante[]{

            new Estudiante( "Nombre1", "Apellido1", true),
            new Estudiante( "Nombre2", "Apellido2", true),
            new Estudiante( "Nombre3", "Apellido3", false),
            new Estudiante( "Nombre4", "Apellido4", true),
            new Estudiante( "Nombre5", "Apellido5", false),
            new Estudiante( "Nombre6", "Apellido6", true),
      };
      
      //El siguiente método nos retorna un array con solo los entregados
      Estudiante[] listaEntregados = obtenerEntregados(arrayEst);

   }
   
   /* Este método se encarga de recibir un array de estudiantes
    * y crear un nuevo array con solo los estudiantes que han
    * entregado sus asignaciones.
    */
   private static Estudiante[] obtenerEntregados(Estudiante[] estudiantes) {
      
      //Primero contamos cuantos estudiantes han hecho entrega
      int contEntregados = 0;
      for (int in = 0; in < estudiantes.length; in++) {
         if (estudiantes[in].isEntregado()) //Si este estudiante ha entregado...
            contEntregados++; //...lo contamos
      }
      
      //Ahora ya sabemos cuánto va a medir el nuevo array, podemos crearlo
      Estudiante[] entregados = new Estudiante[contEntregados];
      
      /*
       * Lo siguiente es volver a recorrer el array de estudiantes
       * y copiar los entregados al nuevo array.
       * Como se va a trabajar con dos arrays que son de tamaños distintos,
       * vamos a necesitar un indice diferente para cada uno, ya que cada uno
       * ha de apuntar a posiciones distintas en los arrays
       */
      int indice1 = 0; //Indice para el array de estudiantes
      int indice2 = 0; //Indice para el array de entregados
      for (indice1 = 0; indice1 < estudiantes.length; indice1++) {
         if (estudiantes[indice1].isEntregado())  {//Si este estudiante ha entregado...
            entregados[indice2] = estudiantes[indice1]; //Hacemos copia en array entregados
            indice2++; //Incrementamos el indice de los entregados
         }
      }
      
      //Por último, retornamos array de entregados
      return entregados;
   }

}

Pues ahora que ya tenemos la lista de los entregados, ya solo hay que recorrerla y mostrarla en pantalla:
Citar
public class ListarEntregados {

   public static void main(String[] args) {
      
      //Creamos unos estudiantes genéricos
      Estudiante[] arrayEst = new Estudiante[]{

            new Estudiante( "Nombre1", "Apellido1", true),
            new Estudiante( "Nombre2", "Apellido2", true),
            new Estudiante( "Nombre3", "Apellido3", false),
            new Estudiante( "Nombre4", "Apellido4", true),
            new Estudiante( "Nombre5", "Apellido5", false),
            new Estudiante( "Nombre6", "Apellido6", true),
      };
      
      //El siguiente método nos retorna un array con solo los entregados
      Estudiante[] listaEntregados = obtenerEntregados(arrayEst);
      
      //Para terminar, mostramos en pantalla los datos de los que han entregado
      System.out.println("\t\tLista de Estudiantes con asignación entregada\n");
      for (int in = 0; in < listaEntregados.length; in++)
         listaEntregados[in].mostrar();
      
      System.out.println("\n\t\tFIN DE PROGRAMA");

   }
   
   /* Este método se encarga de recibir un array de estudiantes
    * y crear un nuevo array con solo los estudiantes que han
    * entregado sus asignaciones.
    */
   private static Estudiante[] obtenerEntregados(Estudiante[] estudiantes) {
      
      //Primero contamos cuantos estudiantes han hecho entrega
      int contEntregados = 0;
      for (int in = 0; in < estudiantes.length; in++) {
         if (estudiantes[in].isEntregado()) //Si este estudiante ha entregado...
            contEntregados++; //...lo contamos
      }
      
      //Ahora ya sabemos cuánto va a medir el nuevo array, podemos crearlo
      Estudiante[] entregados = new Estudiante[contEntregados];
      
      /*
       * Lo siguiente es volver a recorrer el array de estudiantes
       * y copiar los entregados al nuevo array.
       * Como se va a trabajar con dos arrays que son de tamaños distintos,
       * vamos a necesitar un indice diferente para cada uno, ya que cada uno
       * ha de apuntar a posiciones distintas en los arrays
       */
      int indice1 = 0; //Indice para el array de estudiantes
      int indice2 = 0; //Indice para el array de entregados
      for (indice1 = 0; indice1 < estudiantes.length; indice1++) {
         if (estudiantes[indice1].isEntregado())  {//Si este estudiante ha entregado...
            entregados[indice2] = estudiantes[indice1]; //Hacemos copia en array entregados
            indice2++; //Incrementamos el indice de los entregados
         }
      }
      
      //Por último, retornamos array de entregados
      return entregados;
   }

}

Y ya está.
Hemos creado el programa en dos clases separadas: un modelo de clase Estudiante y la clase principal ejecutable.
Y esta clase principal, la hemos dividido en dos métodos: uno el main() (obligatorio en todo proyecto Java que queramos ejecutar) con el flujo del programa principal y otro método que se encarga expresamente de TOMAR un array de estudiantes y RETORNAR otro array con solo los estudiantes que han hecho la entrega.

En realidad este ejercicio se podría resolver con menos código, sin crear un método separado como hemos hecho.
Pero esto es lo que está pidiendo el enunciado, fíjate en las palabras que señalo:
Citar
"Encontrar entregas - Toma  un array de objetos nombres de estudiantes y entregas, y retorna un subset de siEntregaron de los estudiantes que si entregaron la asignacion"

Tomar y retornar... Aunque no lo diga claramente, cuando se usan esas palabras es que quieren que hagamos un método que reciba un dato, trabaje con él y retorne un resultado.

Bueno. Prueba el programa que he escrito. Revisa el código y asegurate de que entiendes cómo hemos estructurado el programa, la sintaxis del código y sobre todo la lógica que se ha seguido.

E intenta ahora escribir tú, o al menos comenzar, el segundo ejercicio.
Para ser sinceros, me parece un ejercicio algo difícil para alguien que está empezando. Además el enunciado es muy pobre, debería dar instrucciones más precisas.

Yo mismo no estoy muy seguro de cómo enfocarlo, la verdad... :(

165
C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Menú en Java para Pilas
« en: 28 de Julio 2022, 00:40 »
Bueno, en realidad lo "difícil", que es la clase Pila y Nodo, ya lo tienes.
Hacer un menú es lo fácil.

Primero una corrección en la clase Nodo.
Recuerda que los constructores NO TIENEN NINGÚN TIPO DE RETORNO.
Ni siquiera void, si se lo pones a un constructor, deja de serlo y se transforma en un método:
Citar
public class Nodo {
   //Definir los atributos
   private int valor;
   private Nodo siguiente;

   //Contructor

   public void Nodo(){
      this.valor=0;
      this.siguiente=null;
   }
Aparentemente ha estado funcionando, porque ese "no constructor", su código hace lo mismo que si no hubiera constructor.
No hace falta un constructor para hacer que un int tenga valor 0 y que un objeto de clase tenga valor null, eso son los valores que van a tener por defecto si no hay un "verdadero constructor" que diga lo contrario.

Así que el void lo tienes que quitar. Pero incluso puedes prescindir totalmente del constructor ya que por las características de esta clase no parece que sea necesario.

Con la clase Pila ocurre lo mismo, si quieres constructor has de quitar el retorno "void".
Pero en cualquier caso, para esta clase también podrías prescindir de constructores.


Dicho esto, para hacer un menú, basta con crear una clase con un objeto Pila y un objeto Scanner como atributos.
Y en el método main, un bucle que ofrezca las opciones disponibles.

Con un switch evalúas que opción ha escogido el usuario y en cada case escribes el código necesario para cumplir con lo solicitado.

Aquí te dejo un ejemplo para que lo completes. Si te atascas al desarrollar alguna de las opciones, vuelve a pedir ayuda por aquí.

Código: [Seleccionar]
import java.util.Scanner;

public class Menu {

private static Pila pila = new Pila();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;

while (opcion != 11) {

System.out.println("\n\t\tMENU PILA\n");
System.out.println("[1] -- Es vacia");
System.out.println("[2] -- Tamaño de la pila");
System.out.println("[3] -- Guardar un nuevo registro (apilar)");
System.out.println("[4] -- Eliminar un elemento de la pila(retirar)");
System.out.println("[5] -- El ultimo elemento de la pila(cima)");
System.out.println("[6] -- Buscar");
System.out.println("[7] -- Remover un elemento de la pila");
System.out.println("[8] -- Editar, cambiar un elemento de la pila por otro valor");
System.out.println("[9] -- Eliminar la pila");
System.out.println("[10] -- Listar elementos contenidos en las pilas");
System.out.println("[11] -- Salir");
System.out.print("Elija opcion: ");
opcion = teclado.nextInt();

switch(opcion) {
case 1:
System.out.println(pila.esVacio()?"La pila esta vacia":"La pila NO esta vacia");
break;
case 2:
System.out.println("Tamaño pila: " + pila.getTamanio());
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:
break;
case 10:
break;
case 11:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("\nOpcion equivocada...");
}
}

}

}

166
C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Ayuda con Java, ArrayList .
« en: 26 de Julio 2022, 23:42 »
Con un Scanner primero preguntas la cantidad de países que se quieren ingresar.
Con esa cantidad, haces un bucle for y en cada iteración pides un nombre de país que guardamos en la lista de países.

Citar
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class ListaPaises {

    public static void main(String[] args) {
        List<String> paises=new ArrayList<>();
        Scanner teclado = new Scanner(System.in);

        System.out.print("¿Cuantos paises quiere ingresar?: ");
        int cantidad = Integer.parseInt(teclado.nextLine());
       
        for (int i = 0; i < cantidad; i++) {
                System.out.print("Pais #" + (i+1) + ": ");
                paises.add(teclado.nextLine());
        }
       
        System.out.println("La cantidad de paises que existe en la lista es : "+ paises.size());       
        System.out.println("Los paises que contiene la lista, son los siguientes: ");
        for(String i:paises){
            System.out.println(" - " + i);
        }
       
        System.out.println(paises.contains("Colombia"));
       
        if(paises.contains("Ecuador")){
            System.out.println("El pais Ecuador esta dentro de la lista");
        }
        else
        {
            System.out.println("El pais Ecuador No esta dentro de la lista");
        }
    }
   
}

167
Comunidad / Re: Saludos de ingreso.
« en: 24 de Julio 2022, 23:15 »
Bienvenido.

En este enlace tienes cursos para iniciarte en distintos ámbitos de la programación.

Siéntete libre de usar este foro para compartir y preguntar lo que necesites.

Un saludo.

168
C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Ayuda con Menú en Java
« en: 21 de Julio 2022, 01:33 »
Primero, recuerda que las convenciones de Java indican que los nombres de las clases han de comenzar en mayúscula.

Mal  >:(
Código: [Seleccionar]
class funciones {
Bien ;)
Código: [Seleccionar]
class Funciones {
Esto no afecta al funcionamiento, pero conviene adaptarse a las convenciones del lenguaje.
Así al compartir código entre programadores, todos nos regimos por los mismos usos y costumbres.

Al margen de esto, para lograr una "pausa", yo lo que hago es usar una lectura con el Scanner acompañado de un mensaje en pantalla para que el usuario pulse ENTER.
Esa lectura no impide que el usuario pueda teclear lo que quiera antes de pulsar ENTER, pero no afecta al programa, más allá de quedar un poco feo que el usuario escriba.

Lo puedes poner al final del cuerpo del bucle principal. Lo marco en color azul.

Citar
public class Menu {
   public static void main(String[] args) {
      Scanner sn = new Scanner(System.in);

      boolean salir = false;
      int opcion;

      while(!salir){

         System.out.println("\n\t-- Programa que muestra un menu con opciones de ejercicios de las diferentes estructuras --");

         System.out.println("1.- Funciones");
         System.out.println("2.- Recursividad");
         System.out.println("3.- Metodo de ordenacion de insercion");
         System.out.println("4.- Metodo de ordenacion Shell");
         System.out.println("5.- Listas de personas");
         System.out.println("6.- Pilas");
         System.out.println("7.- Colas");
         System.out.println("8.- Salir");

         try{

            System.out.println("Seleccione la opcion deseada: ");
            opcion = sn.nextInt();

            switch (opcion){
            case 1:
               Ejercicios.funciones();
               break;
            case 2:
               Ejercicios.recursividad();
               break;
            case 3:
               Ejercicios.ordenacionInsercion();
               break;
            case 4:
               Ejercicios.ordenacionShell();
               break;
            case 5:
               Ejercicios.listaPersonas();
               break;
            case 6:
               Ejercicios.metodoPilas();
               break;
            case 7:
               Ejercicios.metodoColas();
               break;
            case 8:
               salir=true;
               break;   
            default:   
               System.out.println("Las opciones son entre 1 y 8");

            }
         }
         catch(InputMismatchException e){
            System.out.println("Debes seleccionar un numero de opcion");
            sn.next();
         }
         
         //Pausa en la ejecución del programa
         System.out.println("\n\t\t---Pulse ENTER para continuar---");
         sn.nextLine();
      }

      System.out.println("Gracias por utilizar el sistema, hasta luego... ");
      sn.close();
   }
   
}

Sin embargo, si lo pruebas, no va a funcionar bien :P
¿Por qué?
Porque para hacer la pausa necesitamos un nextLine(). Y antes de usar este nextLine(), hemos hecho lecturas con nextInt().

Y siempre que leemos con nextInt(), si luego hacemos una lectura con nextLine(), esta va a fallar.
Bueno, en realidad no falla, pero el programa no espera a que el usuario teclee nada, porque el nextLine() se encuentra con "restos" que ha dejado el nextInt() y piensa equivocadamente que el usuario ya ha pulsado ENTER.

Para solucionarlo, habría que cambiar todas las lecturas y hacerlas con nextLine().
Y cuando queramos enteros, pues parseamos lo leído con nextLine().

Dicho parseo, puede generar una excepción si el usuario introduce letras en lugar de números. Pero como ya tenemos un try catch en el programa, ampliamos las excepciones que puede capturar para cubrir todas las posibilidades:

Citar
public class Menu {
   public static void main(String[] args) {
      Scanner sn = new Scanner(System.in);

      boolean salir = false;
      int opcion;

      while(!salir){

         System.out.println("\n\t-- Programa que muestra un menu con opciones de ejercicios de las diferentes estructuras --");

         System.out.println("1.- Funciones");
         System.out.println("2.- Recursividad");
         System.out.println("3.- Metodo de ordenacion de insercion");
         System.out.println("4.- Metodo de ordenacion Shell");
         System.out.println("5.- Listas de personas");
         System.out.println("6.- Pilas");
         System.out.println("7.- Colas");
         System.out.println("8.- Salir");

         try{

            System.out.println("Seleccione la opcion deseada: ");
            opcion = Integer.parseInt(sn.nextLine());

            switch (opcion){
            case 1:
               Ejercicios.funciones();
               break;
            case 2:
               Ejercicios.recursividad();
               break;
            case 3:
               Ejercicios.ordenacionInsercion();
               break;
            case 4:
               Ejercicios.ordenacionShell();
               break;
            case 5:
               Ejercicios.listaPersonas();
               break;
            case 6:
               Ejercicios.metodoPilas();
               break;
            case 7:
               Ejercicios.metodoColas();
               break;
            case 8:
               salir=true;
               break;   
            default:   
               System.out.println("Las opciones son entre 1 y 8");

            }
         }
         catch(InputMismatchException | NumberFormatException e){
            System.out.println("Debes seleccionar un numero de opcion");
         }
         
         //Pausa en la ejecución del programa
         System.out.println("\n\t\t---Pulse ENTER para continuar---");
         sn.nextLine();
      }

      System.out.println("Gracias por utilizar el sistema, hasta luego... ");
      sn.close();
   }
   
}


Con esto ahora, siempre hace una pausa tras ejecutarse un ejercicio, para que el usuario pueda ver los resultados antes de que vuelva a aparecer el menú

169
C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Ayuda con Menú en Java
« en: 20 de Julio 2022, 11:04 »
Mhhh..., desde la consola no se si se puede invocar otro programa.
Y de poderse, probablemente se ejecutaría en paralelo al programa principal. Es decir, el programa principal no tendría control sobre el programa "secundario". No sabría si ya ha empezado, ni cuando termina, ni nada...

Lo que tienes que hacer es reconvertir esos programas secundarios en métodos estáticos para poder invocarlos desde el switch en el main() del programa principal.
Esto puedes hacerlo de dos maneras:

1- Escribiendo los métodos dentro del propio programa principal:

Código: [Seleccionar]
public class Menu {
public static void main(String[] args) {
Scanner sn = new Scanner(System.in);

boolean salir = false;
int opcion;

while(!salir){

System.out.println("\n\t-- Programa que muestra un menu con opciones de ejercicios de las diferentes estructuras --");

System.out.println("1.- Funciones");
System.out.println("2.- Recursividad");
System.out.println("3.- Metodo de ordenacion de insercion");
System.out.println("4.- Metodo de ordenacion Shell");
System.out.println("5.- Listas de personas");
System.out.println("6.- Pilas");
System.out.println("7.- Colas");
System.out.println("8.- Salir");

try{

System.out.println("Seleccione la opcion deseada: ");
opcion = sn.nextInt();

switch (opcion){
case 1:
funciones();
break;
case 2:
recursividad();
break;
case 3:
ordenacionInsercion();
break;
case 4:
ordenacionShell();
break;
case 5:
listaPersonas();
break;
case 6:
metodoPilas();
break;
case 7:
metodoColas();
break;
case 8:
salir=true;
break;   
default:   
System.out.println("Las opciones son entre 1 y 8");

}
}
catch(InputMismatchException e){
System.out.println("Debes seleccionar un numero de opcion");
sn.next();
}
}

System.out.println("Gracias por utilizar el sistema, hasta luego... ");
}

//Métodos para los diferentes ejercicios
public static void funciones() {
System.out.println("\nEste es el programa que realiza Funciones\n");
}

public static void recursividad() {
System.out.println("\nEste es el programa que muestra la Recursividad\n");
}

public static void ordenacionInsercion() {
System.out.println("Este es el programa que realiza el Metodo de ordenacion de insercion");
}

public static void ordenacionShell() {
int arreglo[]={5,4,2,1,3,6}, aux, salto;
System.out.println("Se muestra el contenido de la serie de datos numericos...");
for(int i=0;i<=5;i++){
System.out.print(arreglo[i]+ " - ");
}

//Ordenamiento por el metodo Shell

boolean cambios;

for (salto = 6 / 2; salto != 0; salto /= 2) {
cambios = true;
while (cambios) {   // Mientras se intercambie algún elemento                                         
cambios = false;
for (int i = salto; i < 6; i++)   // se da una pasada
{
if (arreglo[i - salto] > arreglo[i]) {       // y si están desordenados
aux = arreglo[i];                  // se reordenan
arreglo[i] = arreglo[i - salto];
arreglo[i - salto] = aux;
cambios = true;              // y se marca como cambio.                                   
}
}
}
}

//Mostrando el arreglo ordenando
System.out.println("\n\nSe esta imprimiento los valores del arreglo en forma ascendete");
for(int i=0;i<6;i++){
System.out.print(arreglo[i]+ " - ");
}
System.out.println();
}

public static void listaPersonas() {
System.out.println("\nEste es el programa que realiza Listas de personas\n");
}

public static void metodoPilas() {
System.out.println("\nEste es el programa que realiza el Metodo de pilas\n");
}

public static void metodoColas() {
System.out.println("\nEste es el programa que realiza el Metodo de colas\n");
}

}

2- Creando una clase (sin main, no ejecutable) por separado que contenga los métodos para los ejercicios:
Código: [Seleccionar]
public class Ejercicios {

public static void funciones() {
System.out.println("\nEste es el programa que realiza Funciones\n");
}

public static void recursividad() {
System.out.println("\nEste es el programa que muestra la Recursividad\n");
}

public static void ordenacionInsercion() {
System.out.println("Este es el programa que realiza el Metodo de ordenacion de insercion");
}

public static void ordenacionShell() {
int arreglo[]={5,4,2,1,3,6}, aux, salto;
System.out.println("Se muestra el contenido de la serie de datos numericos...");
for(int i=0;i<=5;i++){
System.out.print(arreglo[i]+ " - ");
}

//Ordenamiento por el metodo Shell

boolean cambios;

for (salto = 6 / 2; salto != 0; salto /= 2) {
cambios = true;
while (cambios) {   // Mientras se intercambie algún elemento                                         
cambios = false;
for (int i = salto; i < 6; i++)   // se da una pasada
{
if (arreglo[i - salto] > arreglo[i]) {       // y si están desordenados
aux = arreglo[i];                  // se reordenan
arreglo[i] = arreglo[i - salto];
arreglo[i - salto] = aux;
cambios = true;              // y se marca como cambio.                                   
}
}
}
}

//Mostrando el arreglo ordenando
System.out.println("\n\nSe esta imprimiento los valores del arreglo en forma ascendete");
for(int i=0;i<6;i++){
System.out.print(arreglo[i]+ " - ");
}
System.out.println();
}

public static void listaPersonas() {
System.out.println("\nEste es el programa que realiza Listas de personas\n");
}

public static void metodoPilas() {
System.out.println("\nEste es el programa que realiza el Metodo de pilas\n");
}

public static void metodoColas() {
System.out.println("\nEste es el programa que realiza el Metodo de colas\n");
}
}
Y en el main del programa principal llamamos a esos métodos nombrando primero a esa clase:
Citar
public class Menu {
   public static void main(String[] args) {
      Scanner sn = new Scanner(System.in);

      boolean salir = false;
      int opcion;

      while(!salir){

         System.out.println("\n\t-- Programa que muestra un menu con opciones de ejercicios de las diferentes estructuras --");

         System.out.println("1.- Funciones");
         System.out.println("2.- Recursividad");
         System.out.println("3.- Metodo de ordenacion de insercion");
         System.out.println("4.- Metodo de ordenacion Shell");
         System.out.println("5.- Listas de personas");
         System.out.println("6.- Pilas");
         System.out.println("7.- Colas");
         System.out.println("8.- Salir");

         try{

            System.out.println("Seleccione la opcion deseada: ");
            opcion = sn.nextInt();

            switch (opcion){
            case 1:
               Ejercicios.funciones();
               break;
            case 2:
               Ejercicios.recursividad();
               break;
            case 3:
               Ejercicios.ordenacionInsercion();
               break;
            case 4:
               Ejercicios.ordenacionShell();
               break;
            case 5:
               Ejercicios.listaPersonas();
               break;
            case 6:
               Ejercicios.metodoPilas();
               break;
            case 7:
               Ejercicios.metodoColas();
               break;
            case 8:
               salir=true;
               break;   
            default:   
               System.out.println("Las opciones son entre 1 y 8");

            }
         }
         catch(InputMismatchException e){
            System.out.println("Debes seleccionar un numero de opcion");
            sn.next();
         }
      }

      System.out.println("Gracias por utilizar el sistema, hasta luego... ");
   }
   
}



La segunda opción es más "profesional". El programa va a funcionar lo hagamos de una forma o de otra.
Pero siempre se recomienda "modular" el código, así que puede estar bien separar en una clase el código para efectuar los distintos ejercicios y en otra clase tener el programa principal que se encarga de mostrar el menú, llamar a esos ejercicios y poco más.



En cualquier caso, lo que hay que tener claro es que para conseguir lo que quieres, hay que transformar los ejercicios en métodos.
Si intentamos tratarlos como programas individuales, cada uno con su main ejecutable y tal..., con las limitaciones del modo consola me temo que no sería posible tener un control sobre ellos y cada uno andaría funcionando por su lado.

170
Comunidad / Re: Hola y gracias
« en: 19 de Julio 2022, 18:15 »
Bienvenido.

Y como bien dice Mario, es conveniente seguir un orden en las materias a aprender.
Luego ya profundizarás en la que más te guste, pero es importante saber lo básico en las demás.

Como tú dices, JS se ocupa del backend..., pero mucho de lo que se hace ahí ha de mostrarse en el frontend, incluso algunas tareas del backend consisten precisamente en modificar el comportamiento del frontend...

Así que para poder practicar una parte, necesitarás saber como construir la otra, pues ambas son partes de un "todo".


Así que si ya conoces HTML y CSS, pues genial, ya tienes bastante camino recorrido.
Si no fuera ese el caso, pues mejor comenzar por el orden indicado.
Tampoco hace falta convertirse en un gurú, aprender lo básico de esas materias, puede hacerse en apenas un par de semanas.
Lo demás puede ir conociéndose sobre la marcha, según vayas experimentando cosas y haciendo ejercicios.
Esto es un aprendizaje continuo

Saludos.

171
Aprender a programar desde cero / Re: Cómo crear constructores con o sin parámetros. Inicializar objetos Java.
« en: 19 de Julio 2022, 18:02 »
Los constructores se parecen a los métodos, pero no lo son.
La principal diferencia es que NO tienen retorno, así que los constructores no hay que indicar void ni nada:
Citar
    public void Bombero(String valorNombre, String valorApellido, int valorEdad, boolean valorCasado, boolean valorEspecialista){
        nombre=valorNombre;
        apellido=valorApellido;
        edad=valorEdad;
        casado=valorCasado;
        especialista=valorEspecialista;
    }

Simplemente se indica que son public, y nada más:

Citar
    public Bombero(String valorNombre, String valorApellido, int valorEdad, boolean valorCasado, boolean valorEspecialista){
        nombre=valorNombre;
        apellido=valorApellido;
        edad=valorEdad;
        casado=valorCasado;
        especialista=valorEspecialista;
    }

Otra cosa, los atributos casado y especialista son cosas distintas, no guardan relación entre ellos, por tanto cada uno debería tener su propio setter, y no uno compartido:
Citar
    public void setCasadoEspecialista(boolean valorCasado, boolean valorEspecialista){
        casado=valorCasado;
        especialista=valorEspecialista;}



Y sobre tu duda:
Los constructores con parámetros y los setters cubren necesidades distintas.

Un constructor con parámetros sirve para poder crear en una sola línea un objeto con valores aplicados en todos sus atributos.
Aquí un ejemplo de un bombero "soltero":
Código: [Seleccionar]
Bombero bombero1 = new Bombero("Paquito", "Mangueras", 25, false, true);
Ya tenemos un bombero construido, pero es posible que luego más tarde queramos cambiar los valores de esos atributos, porque nos hemos equivocado, o porque Paquito se ha casado y ya no es soltero, o por lo que sea...
Entonces que hacemos, ¿llamar a su constructor para crear un nuevo objeto con los nuevos valores de atributos?

Eso no es práctico, además en un programa real donde unos objetos están relacionados con otros, crear un nuevo objeto de cero supone perder esas relaciones e incluso otra información.

Así que lo mejor es usar los setters:
Citar
//Paquito abandona la soltería
bombero1.setCasado(true);
//Ahora además, hay que tratarle como a un señor
bombero1.setNombre("Don Francisco");

Así que como hemos dicho, el constructor con parámetros lo usaremos para la creación inicial del objeto.
Si luego queremos hacer modificaciones de sus atributos, vamos a necesitar los setters.

Un saludo.

172
Aprender a programar desde cero / Re: If else, if else if Java. Estructura o esquema de decisión condicional.
« en: 08 de Julio 2022, 10:57 »
Hola.
En principio parece estar correcto.

Solo un comentario: Evita usar nombres de variables/métodos con letras tildadas

Citar
public class Rueda
{
    private String tipo, marca;
    private double grosor, diámetro;

Citar
    public void setGrosor(double valorGrosor){
        grosor=valorGrosor;}
       
    public void setDiámetro(double valorDiámetro){
        diámetro=valorDiámetro;}
       
    public String getTipo(){return tipo;}
    public String getMarca(){return marca;}
    public double getGrosor(){return grosor;}
    public double getDiámetro(){return diámetro;}


La recomendación es no usar nunca caracteres que sean ajenos al alfabeto inglés: letras tildadas, la eñe (ñ), la cedilla (ç), letras con diéresis (cigüeña)....

Sí podemos (y debemos) usarlas en cadenas de caracteres que son para mostrarse en pantalla, o para un archivo de texto,...
Pero no para las instrucciones del código.

En tu ordenador no habrá problema en usarlas. En el mío tampoco.
Pero en la mayoría de ordenadores del mundo, sí puede ser un problema, porque sus sistemas operativos, programas de desarrollo, compiladores, etc... estarán usando un juego de caracteres (charset) que no contemplan caracteres de los alfabetos latinos y en su lugar aparecerán símbolos raros.

Incluso si alguien de EEUU, UK, Alemania, Noruega,.... estuviera leyendo ahora mismo estos mensajes nuestros en este foro, posiblemente sus navegadores web no le estarían mostrando correctamente los textos que hemos escrito (aunque hoy día la mayoría de navegadores manejan charsets más extensos para intentar mostrarlo todo)

Así que para evitar incompatibilidades y problemas al portar nuestro código a otros sistemas, lo mejor es limitarse a usar caracteres ingleses.

Esto a veces conlleva situaciones comprometedoras... :P

Una variable llamada "numeroAños", habría que escribirla como "numeroAnos"...pero suena horrible jaja.
En ese caso podemos usar alternativas: "numeroAnios", "numeroAnhos",...

Un saludo.

173
Aprender a programar desde cero / Re: Problemilla con Python y Anaconda prompt
« en: 03 de Julio 2022, 12:02 »
Siento no poder ayudarte mucho, pero yo de Python ni idea.

Veo por StackOverflow alguien con un problema similar al tuyo y dice haberlo solucionado actualizando el módulo scipy con este comando desde la consola Anaconda:
Código: [Seleccionar]
conda update spyder
Prueba a ver si te sirve de algo.

174
C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Duda con los # en Python
« en: 02 de Julio 2022, 23:42 »
Esas línea son comentarios que el compilador va a ignorar, así que el programa va a funcionar igual con o sin ellos.

Solo has de poner los comentarios que tú creas que puedan ser útiles para explicar el código.
Puede que pasado un tiempo revisites ese programa escrito por ti, y te encuentres con instrucciones o líneas de código que ya no recuerdas cuál era su propósito, por qué se escribieron de esa manera concreta, etc...

Si junto a esas líneas dejas ahora un comentario explicándolas, en el futuro te será útil para interpretar ese código y entenderlo fácilmente.

175
Aprender a programar desde cero / Re: Ejercicio resuelto Java Paciente Historial Clinico menú JOptionPane #codigoJava
« en: 24 de Junio 2022, 12:34 »
A ver, recapitulemos desde el principio.
Teníamos 3 entidades a gestionar.

Clase Paciente
Código: [Seleccionar]
import javax.swing.JOptionPane;

public final class Paciente {

private String id;
private String nombre;
private String apellidos;
private int edad;
private String genero;

public Paciente(String id, String nombre, String apellidos, int edad, String genero) {
this.id = id;
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.genero = genero;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getNombre() {
return nombre;
}

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

public String getApellidos() {
return apellidos;
}

public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}

public int getEdad() {
return edad;
}

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

public String getGenero() {
return genero;
}

public void setGenero(String genero) {
this.genero = genero;
}

/**
* Muestra en un panel todos los datos del Paciente
*/
public void mostrar() {
String mensaje = "ID Paciente: " + id + "\nNombre: " + nombre
+ "\nApellidos: " + apellidos + "\nEdad: " + edad
+ "\nGenero: " + genero;
JOptionPane.showMessageDialog(null, mensaje, "Mostrar Paciente", JOptionPane.INFORMATION_MESSAGE);
}

@Override
public boolean equals(Object objeto) {
if (objeto instanceof Paciente) {
Paciente otroPaciente = (Paciente) objeto;
return id.equals(otroPaciente.id);
}
else
return false;
}

}
Clase Medico
Código: [Seleccionar]
import javax.swing.JOptionPane;

public final class Medico {

private String id;
private String nombre;
private String apellidos;
private String especialidad;

public Medico(String id, String nombre, String apellidos, String especialidad) {
this.id = id;
this.nombre = nombre;
this.apellidos = apellidos;
this.especialidad = especialidad;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getNombre() {
return nombre;
}

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

public String getApellidos() {
return apellidos;
}

public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}

public String getEspecialidad() {
return especialidad;
}

public void setEspecialidad(String especialidad) {
this.especialidad = especialidad;
}

/**
* Muestra por panel todos los datos del Medico
*/
public void mostrar() {
String mensaje = "ID Medico: " + id + "\nNombre: " + nombre
+ "\nApellidos: " + apellidos + "\nEspecialidad: " + especialidad;
JOptionPane.showMessageDialog(null, mensaje, "Mostrar Medico", JOptionPane.INFORMATION_MESSAGE);
}

@Override
public boolean equals(Object objeto) {
if (objeto instanceof Medico) {
Medico otroMedico = (Medico) objeto;
return id.equals(otroMedico.id);
}
else
return false;
}

}
Y clase HistorialClinico
Código: [Seleccionar]
import javax.swing.JOptionPane;

public final class HistorialClinico {

private String codigo;
private String fecha;
private String idPaciente;
private String idMedico;
private String observaciones;

public HistorialClinico(String codigo, String fecha, String idPaciente,
String idMedico, String observaciones) {
this.codigo = codigo;
this.fecha = fecha;
this.idPaciente = idPaciente;
this.idMedico = idMedico;
this.observaciones = observaciones;
}

public String getCodigo() {
return codigo;
}

public void setCodigo(String codigo) {
this.codigo = codigo;
}

public String getFecha() {
return fecha;
}

public void setFecha(String fecha) {
this.fecha = fecha;
}

public String getIdPaciente() {
return idPaciente;
}

public void setIdPaciente(String idPaciente) {
this.idPaciente = idPaciente;
}

public String getIdMedico() {
return idMedico;
}

public void setIdMedico(String idMedico) {
this.idMedico = idMedico;
}

public String getObservaciones() {
return observaciones;
}

public void setObservaciones(String observaciones) {
this.observaciones = observaciones;
}

/**
* Muestra por panel todos los datos del Historial Clinico
*/
public void mostrar() {
String mensaje = "Codigo Historial: " + codigo + "\nFecha: " + fecha
+ "\nID Paciente: " + idPaciente + "\nID Medico: " + idMedico
+ "\nObservaciones:\n" + observaciones;
JOptionPane.showMessageDialog(null, mensaje, "Mostrar Medico", JOptionPane.INFORMATION_MESSAGE);
}

@Override
public boolean equals(Object objeto) {
if (objeto instanceof HistorialClinico) {
HistorialClinico otroHistorial = (HistorialClinico) objeto;
return codigo.equals(otroHistorial.codigo);
}
else
return false;
}

}
Para gestionar esas 3 entidades, hicimos 3 clase "gestoras", en las que cada una disponía de un ArrayList para albergar objetos de esas entidades y unos métodos para operar con ellos.

Esas tres clases son muy similares, solo cambia el tipo de dato del que se están ocupando cada una.
Así pues, podemos crear una interfaz declarando los métodos que toda clase "gestora" de nuestro proyecto debería tener y usar un genérico para así no "obligar" a que se ocupen de un tipo de dato (una clase) en concreto, si no que cuando las clases "gestoras" que vayan a implementar esta interfaz podrán escoger el tipo de dato del que se van a ocupar.

Así pues, la interfaz genérica es tan sencilla como esto:
Código: [Seleccionar]
public interface Gestion<T> {

//Métodos de gestión comunes
boolean agregar(T valor);
void modificar(T valor);
boolean eliminar(T valor);
T obtener();
void listar();

}
Ahí usamos el genérico T (de Type, o sea, Tipo) para indicar que se va a trabajar con algún tipo de dato. El que sea, uno cualquiera, y con ese tipo de dato haremos las mismas operaciones.
Podremos agregar un objeto de ese tipo de dato, podremos modificarlo, podremos eliminarlo, podremos obtener un objeto de ese tipo y además podremos hacer un listado.
En este último método no es necesario indicarle ningún genérico, ya que lo que hará será mostrar el contenido de un ArrayList que será declarado en la clase "gestora".


Bien, vamos a ver una clase gestora. Comencemos con GestionPacientes.
Al empezar a escribir esta clase, vamos a implementar la interfaz Gestion indicándole que ha de ocuparse del tipo de dato Paciente.

Al implementar esta interfaz, veremos que nos sale un aviso (ya depende del IDE que use cada uno) indicando que estamos OBLIGADOS a sobrescribir los métodos que estamos heredando la interfaz implementada.

Código: [Seleccionar]
public class GestorPacientes implements Gestion<Paciente> {

@Override
public boolean agregar(Paciente valor) {

return false;
}

@Override
public void modificar(Paciente valor) {

}

@Override
public boolean eliminar(Paciente valor) {

return false;
}

@Override
public Paciente obtener() {

return null;
}

@Override
public void listar() {


}

}
Bien, a esta clase habrá que añadirle ahora un ArrayList y escribir el código necesario para que cada método implementado cumpla con su función.
Además, añadiremos un método que permita crear un Paciente pidiendo datos al usuario.
Código: [Seleccionar]
import java.util.ArrayList;

import javax.swing.JOptionPane;

public class GestorPacientes implements Gestion<Paciente> {

private ArrayList<Paciente> pacientes = new ArrayList<Paciente>();

//Métodos implementados por interfaz
@Override
public boolean agregar(Paciente valor) {
if (pacientes.contains(valor)) {
JOptionPane.showMessageDialog(null,
"Ya existe un Paciente con este ID", "Agregar Paciente", JOptionPane.WARNING_MESSAGE);
return false;
}
else
return pacientes.add(valor);
}

@Override
public void modificar(Paciente valor) {

valor.setId(JOptionPane.showInputDialog(null, "ID actual: " + valor.getId()
+ "\nIntroduzca nuevo identificador:", "Modificar Paciente", JOptionPane.QUESTION_MESSAGE));

valor.setNombre(JOptionPane.showInputDialog(null, "Nombre actual: " + valor.getNombre()
+ "\nIntroduzca nuevo nombre:", "Modificar Paciente", JOptionPane.QUESTION_MESSAGE));

valor.setApellidos(JOptionPane.showInputDialog(null, "Apellidos actuales: " + valor.getApellidos()
+ "\nIntroduzca nuevos apellidos:", "Modificar Paciente", JOptionPane.QUESTION_MESSAGE));

valor.setGenero(JOptionPane.showInputDialog(null, "Genero actual: " + valor.getGenero()
+ "\nIntroduzca nuevo genero:", "Modificar Paciente", JOptionPane.QUESTION_MESSAGE));

try {
valor.setEdad(Integer.parseInt(JOptionPane.showInputDialog(null, "Edad actual: " + valor.getEdad()
+ "\nIntroduzca nueva edad:", "Modificar Paciente", JOptionPane.QUESTION_MESSAGE)));
}
catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Solo se admite introducir numeros para la edad\nNo se ha registrado el valor introducido",
"Error", JOptionPane.WARNING_MESSAGE);
}
}

@Override
public boolean eliminar(Paciente valor) {
if (pacientes.contains(valor))
return pacientes.remove(valor);
else {
JOptionPane.showMessageDialog(null,
"No existe Paciente con este ID", "Eliminar Paciente", JOptionPane.WARNING_MESSAGE);
return false;
}
}

@Override
public Paciente obtener() {
if (pacientes.isEmpty()) {
JOptionPane.showMessageDialog(null, "No hay Pacientes registrados", "Obtener Paciente",
JOptionPane.WARNING_MESSAGE);
return null;
}
else {
String id = JOptionPane.showInputDialog(null, "Introduzca Identificador del paciente:",
"Obtener Paciente", JOptionPane.QUESTION_MESSAGE);
//Buscamos paciente
for (Paciente paci: pacientes)
if (paci.getId().equals(id))
return paci; //Encontrado, lo retornamos y aquí termina el método

//Bucle FOR ha finalizado sin retornar nada, significa que no hay paciente con ese id
JOptionPane.showMessageDialog(null, "No existe Paciente con este ID", "Obtener Paciente",
JOptionPane.WARNING_MESSAGE);
return null;
}
}

@Override
public void listar() {
if (pacientes.isEmpty())
JOptionPane.showMessageDialog(null, "No hay Pacientes registrados", "Listar Pacientes",
JOptionPane.WARNING_MESSAGE);
else
for (Paciente paci: pacientes)
paci.mostrar();

}

//Método propio de esta clase

public Paciente crearPaciente() {
String id = JOptionPane.showInputDialog(null, "Introduzca Identificador:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE);
String nombre = JOptionPane.showInputDialog(null, "Nombre:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE);
String apellidos = JOptionPane.showInputDialog(null, "Apellidos:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE);
String genero = JOptionPane.showInputDialog(null, "Genero:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE);
int edad = 0;
try {
edad = Integer.parseInt(JOptionPane.showInputDialog(null, "Edad:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE));
}
catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Solo se admite introducir numeros para la edad\nNo se ha registrado el valor introducido",
"Error", JOptionPane.WARNING_MESSAGE);
}
return new Paciente(id, nombre, apellidos, edad, genero);
}

}
Y ahora podemos ponerlo a prueba creando la clase con el programa principal.
En esta clase es donde declararemos las tres clases gestoras y mostraremos menús para que el usuario pueda elegir las gestiones que quiere realizar.
Ahora mismo, solo funcionará la gestión de pacientes:
Código: [Seleccionar]
import javax.swing.JOptionPane;

public final class TestClinica {

//Clases "gestoras"
static GestorPacientes pacientes = new GestorPacientes();
//static GestorMedicos medicos = new GestorMedicos();
//static GestorHistorial historiales = new GestorHistorial();


//Textos para los menus JOptionPane
static final String TEXTO_MENU_PR = "[1] - Gestionar Pacientes\n[2] - Gestionar Medicos"
+ "\n[3] - Gestionar Historiales\n[4] - Salir";
static final String TEXTO_MENU_GP = "[1] - Registrar Pacientes\n[2] - Mostrar Pacientes"
+ "\n[3] - Modificar Pacientes\n[4] - Eliminar Pacientes\n[5] - Volver";

//Programa principal
public static void main(String[] args) {

String opcion = "";

while (!opcion.equals("4")) {
opcion = JOptionPane.showInputDialog(null, TEXTO_MENU_PR,
"Menu Clinica", JOptionPane.QUESTION_MESSAGE);
switch(opcion) {
case "1":
gestionarPacientes();
break;
case "2":
//gestionarMedicos();
break;
case "3":
//gestionarHistoriales();
break;
case "4":
JOptionPane.showMessageDialog(null, "FIN DE PROGRAMA", "Menu Clinica",
JOptionPane.INFORMATION_MESSAGE);
break;
default:
JOptionPane.showMessageDialog(null, "Opción equivocada", "Menu Clinica",
JOptionPane.ERROR_MESSAGE);
}
}

}

//Métodos para mostrar los submenús
private static void gestionarPacientes() {
String opcion = "";

while (!opcion.equals("5")) {
opcion = JOptionPane.showInputDialog(null, TEXTO_MENU_GP,
"Gestion Pacientes", JOptionPane.QUESTION_MESSAGE);
switch(opcion) {
case "1":
Paciente nuevo = pacientes.crearPaciente();
if (pacientes.agregar(nuevo))
JOptionPane.showMessageDialog(null, "Nuevo Paciente agregado", "Agregar Paciente",
JOptionPane.INFORMATION_MESSAGE);
else
JOptionPane.showMessageDialog(null, "No se pudo registrar Paciente", "Agregar Paciente",
JOptionPane.ERROR_MESSAGE);
break;
case "2":
pacientes.listar();
break;
case "3":
Paciente modificar = pacientes.obtener();
if (modificar != null)
pacientes.modificar(modificar);
break;
case "4":
Paciente borrar = pacientes.obtener();
if (borrar != null) {
if (pacientes.eliminar(borrar))
JOptionPane.showMessageDialog(null, "Paciente eliminado", "Eliminar Paciente",
JOptionPane.INFORMATION_MESSAGE);
else
JOptionPane.showMessageDialog(null, "No se pudo eliminar Paciente", "Eliminar Paciente",
JOptionPane.ERROR_MESSAGE);
}
break;
case "5":
JOptionPane.showMessageDialog(null, "Volviendo al Menú Principal", "Gestion Pacientes",
JOptionPane.INFORMATION_MESSAGE);
break;
default:
JOptionPane.showMessageDialog(null, "Opción equivocada", "Menú Clínica",
JOptionPane.ERROR_MESSAGE);
}
}
}

}

Pues con esto, ya tienes un ejemplo de como usar una interfaz con datos genéricos.

Intenta escribir las clases gestoras para médicos e historiales siguiendo este ejemplo.
Si tienes dudas o te atascas, consulta por aquí.

Un saludo

176
Aprender a programar desde cero / Re: Ejercicio resuelto Java Paciente Historial Clinico menú JOptionPane #codigoJava
« en: 23 de Junio 2022, 20:31 »
Hola.
Supongo que las clases "gestoras" (GestorPacientes, GestorMedicos, GestorHistoriales) pueden reescribirse para que implementen una misma interfaz con genéricos..

Todas estas clases tenían un ArrayList (que puede sustituirse por un HashMap u otra estructura de colección de datos).
Y todas tenían unos método similares:
- crearNuevo()
- modificar()
- eliminar()
- mostrar()
-....
La diferencia era que una trataba Pacientes, otra Médicos y la otra Historiales...así que con genéricos se puede declarara un interfaz con una colección de datos y esos métodos.

Luego las clases gestoras tendrían que implementar esa interfaz, y ya entonces escribir el código de esos métodos implementados para adaptarlos a las clases que corresponda.

177
C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Ejercicio en C++
« en: 20 de Junio 2022, 21:34 »
¿En qué te falla?
A mi si me cuenta bien hombres y mujeres. Solo faltaría añadir más funciones para completar lo que pide el enunciado.

Citar
Consola de depuraci6n de Microsoft Visual Studio

Escriba el Nombre 5:luis

Escriba la Edad de 5:32

Escriba el Sexo 5:hombre

Escriba el Sueldo de 5:4400

El registro de personas que se introdujeron es:

Pedro 23 hombre 4500
sara 25 mujer 4700
david 30 hombre 4300
laura 28 mujer 4500
luis 32 hombre 4400

Cantidad hombres: 3
Cantidad mujeres: 2

Por cierto, ya que estamos con C++, para las cadenas mejor usar "string" en lugar de arrays de caracteres.
Así luego es más fácil hacer comparaciones, sin tener que usar strcmp()

Código: [Seleccionar]
#include <iostream>
#include <string>
using namespace std;
struct persona {
    string nombre;
    int edad;
    string sexo;
    int sueldo;

};

//Declaración de procedimientos/funciones
void contarPorSexo(persona *personas);

int main() {
    persona amigo[5];
    for (int i = 0; i < 5; i++) {
        cout << "Escriba el Nombre " << i + 1 << ":";
        cin >> amigo[i].nombre;
        cout << "\nEscriba la Edad de " << i + 1 << ":";
        cin >> amigo[i].edad;
        cout << "\nEscriba el Sexo " << i + 1 << ":";
        cin >> amigo[i].sexo;
        cout << "\nEscriba el Sueldo de " << i + 1 << ":";
        cin >> amigo[i].sueldo;

        cout << endl;
    }
    cout << "El registro de personas que se introdujeron es: \n\n";
    for (int i = 0; i < 5; i++) {
        cout << "\t" << amigo[i].nombre;
        cout << "\t" << amigo[i].edad;
        cout << "\t" << amigo[i].sexo;
        cout << "\t" << amigo[i].sueldo << "\n\n";
    }
    //Pasamos el array a los procedimientos/funciones para que hagan sus tareas
    contarPorSexo(amigo);

    return 0;
}

//Definición de procedimientos/funciones
void contarPorSexo(persona *personas) {
    int hombres = 0, mujeres = 0;

    for (int i = 0; i < 5; i++) {
        if (personas[i].sexo == "mujer")
            mujeres++;
        else
            hombres++;
    }

    cout << "Cantidad hombres: " << hombres << endl;
    cout << "Cantidad mujeres: " << mujeres << endl;
}

178
De todo un poco... / Re: Interés Compuesto
« en: 19 de Junio 2022, 18:18 »
La s de Scanner debe ir en mayúscula, ya que es el nombre de una clase

Citar
import java.util.Scanner;

179
De todo un poco... / Re: Interés Compuesto
« en: 19 de Junio 2022, 11:38 »
Ahí ocurren dos cosas.

Una, que lo estás poniendo en el editor de Python. Tienes que cambiarlo a Java.
Arriba a la derecha, hay un desplegable para elegir lenguaje




Dos, que no se por qué...., te ha traducido el texto del código al español  :o
Te ha puesto "clase pública Principal", cuando el código original es "public class Main"

No se por qué te ha hecho una traducción al español, quizás ha sido tu navegador que ha pensado que estabas copiando un texto en inglés y te ha hecho una traducción automática.

180
Aprender a programar desde cero / Re: Editor de codigo fuente
« en: 19 de Junio 2022, 11:06 »
Lo que comentas de los puntos de colores, seguramente será por el sistema operativo Mac OS de Apple.
Todas sus aplicaciones se muestran con esos marcos y botones.

Hay formas de cambiar el aspecto de Windows 10 para que se vea similar a Mac.
Por ejemplo:
https://www.youtube.com/watch?v=T1u-HL55Fnk

Pero no es sencillo y conlleva ciertos riesgos.
Investiga un poco más sobre como personalizar los temas de Windows. Quizás exista alguna aplicación, aunque sea de pago, que lo haga de forma fácil y segura.

Páginas: 1 ... 4 5 6 7 8 [9] 10 11 12 13 14 ... 50

Sobre la educación, sólo puedo decir que es el tema más importante en el que nosotros, como pueblo, debemos involucrarnos.

Abraham Lincoln (1808-1865) Presidente estadounidense.

aprenderaprogramar.com: Desde 2006 comprometidos con la didáctica y divulgación de la programación

Preguntas y respuestas

¿Cómo establecer o cambiar la imagen asociada (avatar) de usuario?
  1. Inicia sesión con tu nombre de usuario y contraseña.
  2. Pulsa en perfil --> perfil del foro
  3. Elige la imagen personalizada que quieras usar. Puedes escogerla de una galería de imágenes o subirla desde tu ordenador.
  4. En la parte final de la página pulsa el botón "cambiar perfil".