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 ... 25 26 27 28 29 [30] 31 32 33 34 35 ... 50
581
Vamos a ir desarrollándolo paso a paso.

Tenemos las clases principales, pero esto por si solo no funciona, no es un programa ejecutable.

Necesitamos otra clase, la clase "main" principal que hace que el programa se ejecute y será quien se encargue de mostrar un menú al usuario para que elija las tareas que quiere realizar.

Podemos comenzar creando el "esqueleto" de este menú. Vamos a mostrar en pantalla las opciones disponibles y dejar que el usuario elija la que quiera, pero las opciones aún no tendrán funcionalidad, estas las iremos añadiendo poco a poco.
De momento solo mostraremos el mensaje "En construcción..."

Pero ya sí tenemos un programa que podemos ejecutar, no hace gran cosa, pero se puede poner en marcha.

Sí vamos a poner ya como atributo global, un ArrayList donde se irán almacenando los Eventos que el usuario quiera crear.
Y un objeto Scanner para poder leer por teclado lo que el usuario quiera introducir.

Y también un método muy simple llamado pausa() que su función será detener la ejecución del programa hasta que se pulse la tecla ENTER.
De este modo, podemos "pausar" el programa para que el usuario lea los mensaje en pantalla y avanzar cuando él así lo decida.


De nuevo insisto en la importancia de que entiendas cada línea de código antes de seguir con los pasos siguientes.
Que no te queden dudas sobre cómo se comporta el bucle do..while() que estamos usando, o que hace el switch..., o por qué estamos usando un ArrayList para guardar Eventos y no estamos usando un arreglo primitivo "normal y corriente".

Pregunta lo que sea.

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

public class MenuEventos {

//Aquí se almacenarán los Eventos
private static ArrayList<Evento> eventos = new ArrayList<Evento>();
//Objeto Scanner para leer datos por teclado
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

String opcion = "";//Variable para recoger opcion del usuario

do {
System.out.println("\n\t\tMENU EVENTOS");
System.out.println("\t\t---- -------\n");
System.out.println("[1] - Crear nuevo EVENTO");
System.out.println("[2] - Crear nueva ACTIVIDAD");
System.out.println("[3] - Mostrar ACTIVIDAD con mayor número de participantes");
System.out.println("[4] - Mostrar ACTIVIDAD con menor número de participantes");
System.out.println("[5] - Mostrar total participantes de un EVENTO");
System.out.println("[6] - Mostrar ACTIVIDADES ordenadas de mayor a menos número de participantes");
System.out.println("[7] - Consultar ACTIVIDADES de un expositor");
System.out.println("[8] - Mostrar programación de un EVENTO");
System.out.println("\n[0] - SALIR del programa");
System.out.print("\nEscoja opción: ");
opcion = teclado.nextLine();
//Evaluamos opcion escogida
switch(opcion) {
case "0":
System.out.println("\n\t\t--FIN DE PROGRAMA--");
break;
case "1":
System.out.println("\nEn construccion...");
break;
case "2":
System.out.println("\nEn construccion...");
break;
case "3":
System.out.println("\nEn construccion...");
break;
case "4":
System.out.println("\nEn construccion...");
break;
case "5":
System.out.println("\nEn construccion...");
break;
case "6":
System.out.println("\nEn construccion...");
break;
case "7":
System.out.println("\nEn construccion...");
break;
case "8":
System.out.println("\nEn construccion...");
break;
default:
System.out.println("\nOpción no válida...");
}
pausa();
} while(!opcion.equals("0"));
}

/*
* Sencillo método que pausa la ejecución del programa
* hasta que el usuario pulse ENTER/INTRO
*/
private static void pausa() {
System.out.println("\nPulse ENTER para seguir...\n");
teclado.nextLine();
}

}

582
Pero se supone que si te han pedido que resuelvas este ejercicio, es que previamente te han dado explicaciones, material de estudio y lo necesario para resolverlo, o al menos intentarlo.

A ver, el escenario que nos plantean es que hay una institución que organiza eventos
Para cada evento, se dispone de varios salones, en los que se llevan a cabo distintas actividades relacionadas con dicho evento.

Las palabras marcadas en negrita, son las principales "entidades" que participan en este escenario.
Estas entidades son las que tenemos que representar mediante código Java, normalmente creando una clase que las modele. Aunque no siempre va a ser necesario crear una clase, eso ya depende de cada caso y/o incluso decisión del programador.

Veamos la "entidad" Actividad, que nos dice el enunciado.
Citar
En el evento se compone de actividades. Toda actividad tiene nombre de la actividad, un expositor (que es la persona que la dicta), hora y número de participantes.
Nos enumera varias características, lo que normalmente llamamos atributos

Si queremos codificar todo esto, Sí vamos a necesitar crear una clase, que podría ser esta:
Código: [Seleccionar]
public class Actividad {

private String nombre;
private String expositor;//Persona que expone
private String hora;
private int participantes;

/*
* Constructor sin parámetros.
* Con esto nos aseguramos de que al construir
* un objeto Actividad, no tendremos atributos
* con valor null
*/
public Actividad() {
nombre = "";
expositor = "";
hora = "";
participantes = 0;
}

/*
* Constructor con parámetros.
* El objeto se construye recibiendo los valores
* que vamos a asignar a los atributos.
*/
public Actividad(String nombreActiv, String nombreExpos, String horaActiv, int numParticipan) {
nombre = nombreActiv;
expositor = nombreExpos;
hora = horaActiv;
participantes = numParticipan;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombreActiv) {
nombre = nombreActiv;
}

public String getExpositor() {
return expositor;
}

public void setExpositor(String nombreExpos) {
expositor = nombreExpos;
}

public String getHora() {
return hora;
}

public void setHora(String horaActiv) {
hora = horaActiv;
}

public int getParticipantes() {
return participantes;
}

public void setParticipantes(int numParticipan) {
participantes = numParticipan;
}

}

Ahí tenemos una clase con los atributos indicados en el enunciado, constructores necesarios para crear objetos de esta clase y métodos para obtener y modificar los valores de los atributos.

Puede que luego mientras se desarrolla el programa, decidamos añadir algún método más, o tal vez no..., de momento tiene lo mínimo necesario.


Sigamos, a ver que nos dicen de las otras entidades:

Citar
Se requiere un programa para el manejo de los eventos que se realizan en la institución. Un evento tiene nombre del evento, fecha de realización, organizador, facultad organizadora, tema del evento.

En el evento se compone de actividades. Toda actividad tiene nombre de la actividad, un expositor (que es la persona que la dicta), hora y número de participantes.

Los salones donde se lleva a cabo la actividad se corresponden con la posición en el arreglo de donde se guarda la información de la respectiva actividad.

De los eventos nos dan una serie de atributos que hay que modelar con código.
También nos dice que los eventos contienen actividades, así que estas entidades tienen una relación de inclusión.
Es decir, un objeto Evento dentro va a contener uno o varios objetos Actividad.

Estas Actividades que va a contener, son también atributos de la clase Evento, y para contenerlas usaremos un arreglo.
Con todo esto, está más que claro que para Evento también habrá que escribir una clase.

De la entidad Salón no nos dan atributos, solo nos dice que cada salón se corresponde con una de las posiciones del arreglo perteneciente a un Evento.

Por lo tanto, no parece necesario escribir una clase para la entidad Salón. Se podría, pero no aportaría ninguna ventaja. Nos basta con entender que cada posición de los arreglos que contienen Actividades, equivalen a un Salón.

Vamos a ver como podría quedar la clase Evento.

Código: [Seleccionar]
public class Evento {

private String nombre;
private String fecha;
private String organizador;
private String facultad;
private String tema;

//Salones de Actividades
private Actividad[] salones;

public Evento() {
nombre = "";
fecha = "";
organizador = "";
facultad = "";
tema = "";
salones = new Actividad[0]; //Contructor por defecto implica tener 0 salones.
}

public Evento(String nombreEven, String fechaEven, String organizaEven,
String facultadEven, String temaEven, int numSalones) {
nombre = nombreEven;
fecha = fechaEven;
organizador = organizaEven;
facultad = facultadEven;
tema = temaEven;
salones = new Actividad[numSalones]; //Al construir un evento, nos dirán cuantos salones tendrá
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombreEven) {
nombre = nombreEven;
}

public String getFecha() {
return fecha;
}

public void setFecha(String fechaEven) {
fecha = fechaEven;
}

public String getOrganizador() {
return organizador;
}

public void setOrganizador(String organizaEven) {
organizador = organizaEven;
}

public String getFacultad() {
return facultad;
}

public void setFacultad(String facultadEven) {
facultad = facultadEven;
}

public String getTema() {
return tema;
}

public void setTema(String temaEven) {
tema = temaEven;
}

public void setNumSalones(int numSalones) {
salones = new Actividad[numSalones];
}

}

Ahí tenemos los atributos básicos y los métodos getter/setter para gestionarlos.
También tenemos el arreglo de Actividades, que representa los salones.

Fíjate que al ser un arreglo, se necesita proporcionarle un tamaño determinado para poder iniciarse.
Este tamaño se le puede dar mediante el constructor. Así cuando se crea un objeto Evento, ya se decide cuántos salones va a tener, y por tanto, cuántas Actividades va a poder contener.

Al final hay un método llamado setNumSalones() que permite reiniciar el arreglo de salones con un nuevo tamaño.
Hay que tener en cuenta que usarlo supone eliminar Actividades que se hubieran añadido previamente.
Para este programa, no parece que vayamos a tener que usar este método así que no importa demasiado, pero en el caso de que quisiéramos dar opción de usarlo, habría que advertir al usuario de lo que supone y pedirle confirmación.

Bueno, la clase Evento no está terminada. Falta por ejemplo un método para poder añadir Actividades. Y según se vaya avanzando en el desarrollo del programa, seguramente querremos añadirle más métodos que nos faciliten las tareas que nos piden.

Pero antes de seguir adelante, lee bien lo que llevamos escrito y asegúrate de que entiendes cada línea de código.
Lo que no entiendas, te parezca raro, o no estés de acuerdo... pregúntalo y lo aclaramos.

583
Citar
Se requiere un programa para el manejo de los eventos que se realizan en la institución. Un evento tiene nombre del evento, fecha de realización, organizador, facultad organizadora, tema del evento.

En el evento se compone de actividades. Toda actividad tiene nombre de la actividad, un expositor (que es la persona que la dicta), hora y número de participantes.

De ese texto ya podemos deducir que habrán al menos dos clases: evento y actividades.
Y que entre ellas hay una relación de inclusión, es decir, un evento puede incluir n actividades

Comienza por escribir el código de esas clases, con sus atributos y métodos.

584
En el atributo src, has de poner la ruta donde se encuentre esa imagen.

Por ejemplo:

Citar
echo "<img src='c:/imagenes/imagen.jpg' width='600px' />";

Esa sería una ruta "absoluta", también puedes usar rutas "relativas".
Ya depende de cómo tengas organizado tu proyecto.

Por cierto, la etiqueta <img> es HTML básico. Si no estás familiarizado con estas etiquetas básicas, antes de meterte con PHP deberías realizar algún curso de HTML

585
Hola.

Dijiste que la codificación es en C++, pero lo que has puesto es código C.

Esta podría ser una solución escrita en C++, comprueba que entiendes cada línea del código y pregunta cualquier duda que tengas.
Un saludo.

Código: [Seleccionar]
#include<iostream>

using namespace std;

int main() {

string dni[40];
float notas[40];
float notaMayor = 0;

for (int i = 0; i < 40; i++) {
cout << "\nIngrese DNI: ";
cin >> dni[i];
cout << "Ingrese nota promedio: ";
cin >> notas[i];

//Comprobamos si la nota ingresada es, de momento, la mayor de todas
if (notas[i] > notaMayor)
notaMayor = notas[i];
}

/*
* Ya tenemos 40 DNI y 40 notas.
* Y también sabemos cuál es la nota mayor.
* Ahora recorremos el array de notas y aquellas que coincidan
* con la nota mayor, mostraremos su DNI
*/
cout << "\nLa mayor nota promedio es: " << notaMayor;
cout << "\nAlumnos que tienen esta nota:\n";

for (int i = 0; i < 40; i++)
if (notas[i] == notaMayor)
cout << "- " << dni[i] << endl;

system("pause");


return 0;
}

586
Puedes hacerlo usando dos arrays, en uno guardas los dni, en el otro la nota promedio.
Así vas pidiendo las 40 notas con un bucle for, que vaya de 0 a 39, que son las posiciones válidas de los arrays, y en cada uno vas guardando el dato correspondiente.

Para facilitar la tarea, además de pedir y guardar esos datos, puedes guardar en otra variable la nota promedio mayor de las que se van introduciendo.
La inicias con valor 0, y cada nota promedio que te den, preguntas con un IF si esta nota es MAYOR que la que tengas guardada en esa variables.
Si no es mayor, no haces nada.
Y si es mayor, entonces a esa variable le asignas la nota que te acaban de dar.

De este modo, cuando hayas recibido las 40 notas, ya sabrás cuál es la nota mayor.

Solo quedaría recorrer el array de notas y por cada posición que encuentres que coincide con esa nota mayor, muestras en pantalla el dni que se encuentre en la misma posición en el otro array.

Inténtalo, no importa si te sale mal o te atascas (es como mejor se aprende), haz lo que puedas y lo muestras por aquí.
Y entonces te ayudamos a corregirlo, completarlo y lo que haga falta.

Pero haz un intento, si otros lo hacen por ti, no aprenderás.

587
Comunidad / Re: Presentación
« en: 26 de Noviembre 2020, 02:04 »
Bienvenido Pablo.
Espero que aprendas mucho y participes habitualmente en el foro.

Me he permitido editar tu mensaje y borrar el número de teléfono.
No recomiendo publicar ese dato en un foro abierto por motivos de seguridad y privacidad.

Si alguna vez decides querer contactar con alguien por esa vía, hazle llegar tu número de forma privada, ya sea por e-mail o por la mensajería privada que ofrece el foro.
Pero nunca lo publiques en un foro abierto, donde CUALQUIER persona del mundo puede verlo y nunca se sabe que puede ocurrir si tienen malas intenciones.

Un saludo.

588
Me faltaba el quinto ejercicio.
Se me ha ocurrido hacer que cada posible respuesta, sea un panel que reciba el botón que ha de mostrar y un booleano para establecer un atributo que indique si esa respuesta es correcta o no lo es, cuando el usuario la marque.

De este modo, cada botón/opción es capaz de informar por si solo si es válido o no.

Como hay dos tipos de botones en el cuestionario, JRadioButton y JCheckBox, y necesito que este panel pueda construirse con ambos tipos, en el constructor pido recibir un JToggleButton, que es la clase "madre" de estos botones, que son "hermanos".
Así gracias al polimorfismo (aplicar POO es crucial en todo) no tengo que escribir esta clase dos veces, una para cada tipo de botón. Me basta con una.

Código: [Seleccionar]
private class PanelRespuesta extends JPanel {

private boolean esCorrecta;
private JToggleButton boton;
/*
* JToggleButton es un "ancestro" de JcheckBox
*  y de JRadioButton.
*  Así este panel se puede construir con ambos elementos
*/

public PanelRespuesta(JToggleButton comp, boolean correcta) {
boton = comp;
esCorrecta = correcta; //En el constructor establecemos si es respuesta correcta o no
setLayout(new FlowLayout(FlowLayout.LEFT));
add(boton);
setBorder(BorderFactory.createLoweredBevelBorder());
}

}

Cada pregunta tiene una serie de respuestas a elegir, por tanto, voy a crear otra clase que agrupe los paneles respuesta asociados a una pregunta en concreto.
Así las respuestas de una misma pregunta están relacionadas. Además les asocio el JLabel que mostrará si se ha acertado o no la respuesta correcta.

Esta clase tendrá un método muy importante. Será el método que compruebe si se ha escogido la respuesta correcta.
La comprobación será distinta dependiendo de si se trata un botón radio o un checkbox, ya que en este último se permite la selección multiple. Así que no habrá solo una respuesta correcta, pueden haber varias y hay que comprobar que estén todas marcadas para indicar que la respuesta es correcta.

Este método lo he hecho boolean para que, a parte de comprobar si es correcta y actualizar el JLabel de "valor, quiero que informe de si el usuario ha elegido algo en esa serie de respuestas o no.
Si no ha seleccionado nada, quiero saberlo para lanzar un mensaje de advertencia en pantalla.
Código: [Seleccionar]
private class SerieRespuestas{

private PanelRespuesta[] respuestas;
private JLabel valor;

public SerieRespuestas(PanelRespuesta[] resp) {

respuestas = resp;
valor = new JLabel("Valor");
valor.setFont(new Font("Verdana", Font.BOLD, 14));

//Si son botones radio, los agrupamos
if (respuestas[0].boton instanceof JRadioButton) {
ButtonGroup grupo = new ButtonGroup();
for (int i = 0; i < respuestas.length; i++)
grupo.add(respuestas[i].boton);
}
}

/**
* Comprueba si ha habido respuesta seleccionada, y si es correcta.
* La etiqueta valor indicará el resultado, si es que se ha seleccionado algo.
* El metodo informa con  true/false si ha habido alguna seleccion o no,
* para saberlo y poder mostrar un mensaje al usuario.
*
* @return True si ha habido selección (da igual si correcta o no),
* False si no se ha marcado ninguna respuesta.
*/
public boolean comprobarRespuesta() {

boolean haySeleccion = false; //Controlar si se ha seleccionado algo
boolean acertada = false; //Controla si la selección es correcta

/*
* Comprobar las respuestas es distinto si las respuestas son
* JRadioButton (solo una posible seleccion)
* o si son JCheckBox (varias selecciones posibles)
*/
if (respuestas[0].boton instanceof JRadioButton) {
for (PanelRespuesta respuesta: respuestas) {
if (respuesta.boton.isSelected()) {
haySeleccion = true;
acertada = respuesta.esCorrecta;
}
}
}
else { //Son JCheckBox
/*
* Empezamos considerandola como acertada.
* Se considerará erronea si:
* - Encontramos una respuesta correcta que NO esta seleccionada
* - Encontramos una respuesta seleccionadao que NO es correcta.
*/
acertada = true;
for (PanelRespuesta respuesta: respuestas) {

if (respuesta.esCorrecta && !respuesta.boton.isSelected())
acertada = false;

if (respuesta.boton.isSelected()) {
haySeleccion = true;
if (!respuesta.esCorrecta)
acertada = false;
}
}
}

//Actualizamos etiqueta valor, si es que ha habido seleccion
if (haySeleccion) {
if (acertada) {
valor.setText("Cierto");
valor.setForeground(Color.BLUE);
}
else {
valor.setText("Error");
valor.setForeground(Color.RED);
}
}

return haySeleccion; //Acertada o no, informamos si el usuario ha seleccionado algo
}
}

Una vez tenemos una clase que agrupa las respuestas de una misma pregunta, necesito otra clase que maquete un panel con las series de respuestas.
Esta clase va a hacer el trabajo "pesado" al iniciar el programa.
Va a crear todos los "paneles-respuesta", los agrupará en distintas "series" y ya entonces los maquetará en el panel.
Para que quede todo más o menos alineado, usaré un GridLayout.

Además tiene un método que al invocarlo, se recorren todas las "series de respuestas" para que estas comprueben si se ha seleccionado alguna respuesta, y si además son correctas.
Si alguna "serie" informa de que el usuario no ha elegido ninguna respuesta, será cuando se muestre el mensaje de advertencia

Código: [Seleccionar]
private class PanelRespuestas extends JPanel {

private SerieRespuestas[] series;

public PanelRespuestas() {
//construiremos todas las series respuestas
series = new SerieRespuestas[4];
//1era serie de respuestas
PanelRespuesta[] serie1 = new PanelRespuesta[4];
serie1[0] = new PanelRespuesta(new JRadioButton("58"), false);
serie1[1] = new PanelRespuesta(new JRadioButton("34"), false);
serie1[2] = new PanelRespuesta(new JRadioButton("31"), true);
serie1[3] = new PanelRespuesta(new JRadioButton("40"), false);
//2da serie
PanelRespuesta[] serie2 = new PanelRespuesta[4];
serie2[0] = new PanelRespuesta(new JRadioButton("Marte"), false);
serie2[1] = new PanelRespuesta(new JRadioButton("Jupiter"), true);
serie2[2] = new PanelRespuesta(new JRadioButton("Tierra"), false);
serie2[3] = new PanelRespuesta(new JRadioButton("Saturno"), false);
//3ra serie
PanelRespuesta[] serie3 = new PanelRespuesta[4];
serie3[0] = new PanelRespuesta(new JRadioButton("ola"), false);
serie3[1] = new PanelRespuesta(new JRadioButton("desición"), true);
serie3[2] = new PanelRespuesta(new JRadioButton("hay"), false);
serie3[3] = new PanelRespuesta(new JRadioButton("ahí"), false);
//4ta serie
PanelRespuesta[] serie4 = new PanelRespuesta[4];
serie4[0] = new PanelRespuesta(new JCheckBox("Sagaz"), true);
serie4[1] = new PanelRespuesta(new JCheckBox("Listo"), true);
serie4[2] = new PanelRespuesta(new JCheckBox("Lerdo"), false);
serie4[3] = new PanelRespuesta(new JCheckBox("Astuto"), true);

//Agrupamos las series en el array
series[0] = new SerieRespuestas(serie1);
series[1] = new SerieRespuestas(serie2);
series[2] = new SerieRespuestas(serie3);
series[3] = new SerieRespuestas(serie4);
//Listo, maquetamos el panel
setLayout(new GridLayout(4, 5));
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++)
add(series[i].respuestas[j]);
JPanel pnValor = new JPanel();
pnValor.add(series[i].valor);
//pnValor.setBorder(BorderFactory.createLoweredBevelBorder());
pnValor.setBorder(BorderFactory.createEtchedBorder());
add(pnValor);
}
}

public void comprobarValores() {
boolean todasSeleccionadas = true;
for (SerieRespuestas serie: series)
if (!serie.comprobarRespuesta())
todasSeleccionadas = false;

if (!todasSeleccionadas)
JOptionPane.showMessageDialog(null, "Hay preguntas sin contestar",
"Comprobar respuestas", JOptionPane.WARNING_MESSAGE);
}

}

Ya tenemos un panel con todas las respuestas agrupadas y maquetadas. Y con el código necesario para comprobar por ellas mismas si se ha elegido la correcta.

Falta otro panel con las preguntas. Este será muy sencillo:
Código: [Seleccionar]
private class PanelPreguntas extends JPanel {

public PanelPreguntas() {
setLayout(new GridLayout(4,1,5,10));
FlowLayout fluyeIzq = new FlowLayout(FlowLayout.RIGHT);
JPanel preg1 = new JPanel(fluyeIzq);
preg1.add(new JLabel("4 * 6 + 3 + 2 * 2 = "));
JPanel preg2 = new JPanel(fluyeIzq);
preg2.add(new JLabel("Nombre del quinto planeta:"));
JPanel preg3 = new JPanel(fluyeIzq);
preg3.add(new JLabel("Palabra con error ortográfico:"));
JPanel preg4 = new JPanel(fluyeIzq);
preg4.add(new JLabel("Sinómimos de inteligente:"));
add(preg1);
add(preg2);
add(preg3);
add(preg4);
}
}

Y ya está. En el JFrame principal juntaremos ambos paneles y añadiremos otro en la parte inferior con el botón "mostrar".
La acción de este botón es muy sencilla y se la he declarado "en línea" en el constructor, pues todo lo que tiene que hacer es pedirle al panel de respuestas que invoque el método que revisa las series de respuestas.
Así que para una sola línea no he creado un clase ActionListener a parte como sí hice en los ejercicios anteriores.

Dejo a continuación el código completo.


Código: [Seleccionar]
public class Preguntas extends JFrame{

private PanelPreguntas pnPreguntas;
private PanelRespuestas pnRespuestas;
private JButton btMostrar;

public Preguntas() {

pnPreguntas = new PanelPreguntas();
pnRespuestas = new PanelRespuestas();
btMostrar = new JButton("Mostrar");
btMostrar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
pnRespuestas.comprobarValores();
}
});

setLayout(new BorderLayout());
JPanel pnCentro = new JPanel();
pnCentro.add(pnPreguntas);
pnCentro.add(pnRespuestas);
add(pnCentro, BorderLayout.CENTER);
JPanel pnSur = new JPanel();
pnSur.add(btMostrar);
add(pnSur, BorderLayout.SOUTH);

setTitle("Cuestionario");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}


/**
* Modela un pequeño panel que simplemente contendrá
* un JCheckBox o un JRadioButton, siendo una respuesta escogible
* por el usuario.
* Un atributo boolean indicará si es una respuesta correcta o incorrecta.
*/
private class PanelRespuesta extends JPanel {

private boolean esCorrecta;
private JToggleButton boton;
/*
* JToggleButton es un "ancestro" de JcheckBox
*  y de JRadioButton.
*  Así este panel se puede construir con ambos elementos
*/

public PanelRespuesta(JToggleButton comp, boolean correcta) {
boton = comp;
esCorrecta = correcta; //En el constructor establecemos si es respuesta correcta o no
setLayout(new FlowLayout(FlowLayout.LEFT));
add(boton);
setBorder(BorderFactory.createLoweredBevelBorder());
}

}

/**
* Esta clase agrupa toda una serie de respuestas asociada
* a una pregunta, y añade la etiqueta de "valor" que informa
* cuando la respuesta ha sido correcta o no.
* Incorpora un método para comprobar si se ha seleccionado
* respuesta correcta
*/
private class SerieRespuestas{

private PanelRespuesta[] respuestas;
private JLabel valor;

public SerieRespuestas(PanelRespuesta[] resp) {

respuestas = resp;
valor = new JLabel("Valor");
valor.setFont(new Font("Verdana", Font.BOLD, 14));

//Si son botones radio, los agrupamos
if (respuestas[0].boton instanceof JRadioButton) {
ButtonGroup grupo = new ButtonGroup();
for (int i = 0; i < respuestas.length; i++)
grupo.add(respuestas[i].boton);
}
}

/**
* Comprueba si ha habido respuesta seleccionada, y si es correcta.
* La etiqueta valor indicará el resultado, si es que se ha seleccionado algo.
* El metodo informa con  true/false si ha habido alguna seleccion o no,
* para saberlo y poder mostrar un mensaje al usuario.
*
* @return True si ha habido selección (da igual si correcta o no),
* False si no se ha marcado ninguna respuesta.
*/
public boolean comprobarRespuesta() {

boolean haySeleccion = false; //Controlar si se ha seleccionado algo
boolean acertada = false; //Controla si la selección es correcta

/*
* Comprobar las respuestas es distinto si las respuestas son
* JRadioButton (solo una posible seleccion)
* o si son JCheckBox (varias selecciones posibles)
*/
if (respuestas[0].boton instanceof JRadioButton) {
for (PanelRespuesta respuesta: respuestas) {
if (respuesta.boton.isSelected()) {
haySeleccion = true;
acertada = respuesta.esCorrecta;
}
}
}
else { //Son JCheckBox
/*
* Empezamos considerandola como acertada.
* Se considerará erronea si:
* - Encontramos una respuesta correcta que NO esta seleccionada
* - Encontramos una respuesta seleccionadao que NO es correcta.
*/
acertada = true;
for (PanelRespuesta respuesta: respuestas) {

if (respuesta.esCorrecta && !respuesta.boton.isSelected())
acertada = false;

if (respuesta.boton.isSelected()) {
haySeleccion = true;
if (!respuesta.esCorrecta)
acertada = false;
}
}
}

//Actualizamos etiqueta valor, si es que ha habido seleccion
if (haySeleccion) {
if (acertada) {
valor.setText("Cierto");
valor.setForeground(Color.BLUE);
}
else {
valor.setText("Error");
valor.setForeground(Color.RED);
}
}

return haySeleccion; //Acertada o no, informamos si el usuario ha seleccionado algo
}
}

/**
* Este panel contendrá todas las series de respuestas
*/
private class PanelRespuestas extends JPanel {

private SerieRespuestas[] series;

public PanelRespuestas() {
//construiremos todas las series respuestas
series = new SerieRespuestas[4];
//1era serie de respuestas
PanelRespuesta[] serie1 = new PanelRespuesta[4];
serie1[0] = new PanelRespuesta(new JRadioButton("58"), false);
serie1[1] = new PanelRespuesta(new JRadioButton("34"), false);
serie1[2] = new PanelRespuesta(new JRadioButton("31"), true);
serie1[3] = new PanelRespuesta(new JRadioButton("40"), false);
//2da serie
PanelRespuesta[] serie2 = new PanelRespuesta[4];
serie2[0] = new PanelRespuesta(new JRadioButton("Marte"), false);
serie2[1] = new PanelRespuesta(new JRadioButton("Jupiter"), true);
serie2[2] = new PanelRespuesta(new JRadioButton("Tierra"), false);
serie2[3] = new PanelRespuesta(new JRadioButton("Saturno"), false);
//3ra serie
PanelRespuesta[] serie3 = new PanelRespuesta[4];
serie3[0] = new PanelRespuesta(new JRadioButton("ola"), false);
serie3[1] = new PanelRespuesta(new JRadioButton("desición"), true);
serie3[2] = new PanelRespuesta(new JRadioButton("hay"), false);
serie3[3] = new PanelRespuesta(new JRadioButton("ahí"), false);
//4ta serie
PanelRespuesta[] serie4 = new PanelRespuesta[4];
serie4[0] = new PanelRespuesta(new JCheckBox("Sagaz"), true);
serie4[1] = new PanelRespuesta(new JCheckBox("Listo"), true);
serie4[2] = new PanelRespuesta(new JCheckBox("Lerdo"), false);
serie4[3] = new PanelRespuesta(new JCheckBox("Astuto"), true);

//Agrupamos las series en el array
series[0] = new SerieRespuestas(serie1);
series[1] = new SerieRespuestas(serie2);
series[2] = new SerieRespuestas(serie3);
series[3] = new SerieRespuestas(serie4);
//Listo, maquetamos el panel
setLayout(new GridLayout(4, 5));
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++)
add(series[i].respuestas[j]);
JPanel pnValor = new JPanel();
pnValor.add(series[i].valor);
//pnValor.setBorder(BorderFactory.createLoweredBevelBorder());
pnValor.setBorder(BorderFactory.createEtchedBorder());
add(pnValor);
}
}

public void comprobarValores() {
boolean todasSeleccionadas = true;
for (SerieRespuestas serie: series)
if (!serie.comprobarRespuesta())
todasSeleccionadas = false;

if (!todasSeleccionadas)
JOptionPane.showMessageDialog(null, "Hay preguntas sin contestar",
"Comprobar respuestas", JOptionPane.WARNING_MESSAGE);
}

}

private class PanelPreguntas extends JPanel {

public PanelPreguntas() {
setLayout(new GridLayout(4,1,5,10));
FlowLayout fluyeIzq = new FlowLayout(FlowLayout.RIGHT);
JPanel preg1 = new JPanel(fluyeIzq);
preg1.add(new JLabel("4 * 6 + 3 + 2 * 2 = "));
JPanel preg2 = new JPanel(fluyeIzq);
preg2.add(new JLabel("Nombre del quinto planeta:"));
JPanel preg3 = new JPanel(fluyeIzq);
preg3.add(new JLabel("Palabra con error ortográfico:"));
JPanel preg4 = new JPanel(fluyeIzq);
preg4.add(new JLabel("Sinómimos de inteligente:"));
add(preg1);
add(preg2);
add(preg3);
add(preg4);
}
}

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new Preguntas();
}
});
}
}


589
Comunidad / Re: Presentación
« en: 21 de Noviembre 2020, 23:40 »
Bienvenido.
Aprendiendo por uno mismo, lleva más tiempo ..., pero es más satisfactorio y como no dependemos de una única fuente de conocimiento, si no que vamos cogiendo información y experiencias de aquí y de allá, al final el conocimiento adquirido es más enriquecido.

Aquí podrás compartir tus dudas y lo que aprendas con los demás.
Un saludo.

590
Por la red he encontrado este código, mira a ver si te sirve:

Código: [Seleccionar]
public class multiMatrizRecursivo {
 
   public void multiplicacionMatriz(int [][] A,int [][] B)
   {
       if (A[0].length==B.length)
 
       {
           int[][] C = new int[A.length][B[0].length];
           multiplicacionMatriz(A, B, C, 0);
           imprimir(C);
       }else
       {
           System.out.println("Matrices ingresadas no son compatibles");
       }
   }
 
   private void multiplicacionMatriz(int [][] A,int [][] B,int [][]C,int i)
   {
 
       if (i<A.length)
       {
           multiplicacionMatriz(A,B,C,i,0);
           multiplicacionMatriz(A,B,C,i+1);
       }
   }
 
   private void multiplicacionMatriz(int [][]A,int [][]B,int [][]C,int i,int j)
   {
       if (j<B[0].length)
       {
           multiplicacionMatriz(A,B,C,i,j,0);
           multiplicacionMatriz(A,B,C,i,j+1);
       }
   }
 
   private void multiplicacionMatriz(int [][]A,int [][]B,int [][]C,int i,int j,int k)
   {
       if (k<A[0].length)
       {
           C[i][j] += A[i][k] * B[k][j];
           multiplicacionMatriz(A,B,C,i,j,k+1);
       }
   }
 
   public void imprimir(int [][] C)
   {
 
       for (int i=0;i<C.length;i++)
       {
           for(int j=0;j<C.length;j++)
           {
               System.out.print("["+C[i][j]+"]");
           }
           System.out.println();
       }
   }
 
}





591
Pues no pidas cuantas calificaciones quiere ingresar.

Simplemente pide tres calificaciones, con un bucle for es más sencillo:

Código: [Seleccionar]
public class TP5Evaluativo {
    public static void main(String[]args){
       
        Scanner neme=new Scanner(System.in);
        String nom;
       
        System.out.println("ingrese el nombre del alumno");
        nom=neme.next();
       
        double prom=0.0,suma=0.0;
       
        for(int i=1; i<=3; i++){
            double cal;
            System.out.println(i + "# calificacion: ");
            cal=neme.nextDouble();
            suma=suma+cal;
        }
      prom=suma/3.0;
      System.out.println("el promedio del alumno"+nom+" es "+prom);
     
     
    }

Aclarado esto, me surge una duda al leer tu primer mensaje:
Citar
que permita administrar objetos que contengan el nombre y las 3 calificaciones

¿Al decir objetos te refieres a crear una clase Alumno, cuyos atributos sean nombre y 3 calificaciones?
Porque si te refieres a eso, no es lo que estamos haciendo en este código.

592
Cuarto ejercicio.

Muy parecido al anterior.

Yo también crearía una tabla personalizada, con un modelo personalizado.

EL modelo tendría un ArrayList como atributo, que por el constructor recibiría uan referencia al ArrayList principal de palabras.
Así cuando pulsemos el boton "mostrar", llamamos a un método que actualice la tabla, y lo hará con las palabras que se hayan ingresado.

Código: [Seleccionar]
private class ModeloTabla extends AbstractTableModel {

ArrayList<String> palabras;
String[] nombreColumna = new String[]{"Palabras"};

public ModeloTabla(ArrayList<String> palabras) {
this.palabras = palabras;
}

public void actualizarTabla() {
fireTableDataChanged();
}

@Override
public String getColumnName(int col) {
return nombreColumna[col];
}

@Override
public int getRowCount() {
if (palabras == null)
return 0;
else
return palabras.size();
}

@Override
public int getColumnCount() {
return nombreColumna.length;
}

@Override
public Object getValueAt(int rowIndex, int columnIndex) {
return palabras.get(rowIndex);
}

}

Este modelo, se lo aplicamos a un JTable, o a una clase que herede de JTable, si queremos personalizar un poco el aspecto de la tabla.

Código: [Seleccionar]
private class MiTabla extends JTable {

public MiTabla() {
//Aplicamos nuestro modelo de tabla
super(modeloTabla);
//Pedimos al render que centre los textos en sus celdas.
DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
setDefaultRenderer(Object.class, centerRenderer);
//Cambiamos alguna fuente y color para los datos de la tabla
setFont(new Font("Verdana", Font.PLAIN , 14));
setForeground(Color.BLUE);
//También cambiamos estilo de fuente a la cabecera
JTableHeader cabecera = getTableHeader();
cabecera.setFont(new Font("Verdana", Font.BOLD , 14));
}
}

Tendremos dos acciones para los correspondientes botones.
La accion "ingresar" recoge la palabra, comprueba que no supere 10 caracteres, y la inserta en el ArrayList principal.
No afecta para nada a la tabla, solo al ArrayList

Código: [Seleccionar]
private class AccionIngresar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {

String palabra = jtPalabra.getText();
jtPalabra.setText(null);
jtPalabra.requestFocus();
if (!palabra.isEmpty() && !palabra.isBlank()) {
if (palabra.length() > 10)
JOptionPane.showMessageDialog(null, "La palabra no puede superar 10 caracteres",
"Ingresar Palabra", JOptionPane.WARNING_MESSAGE);
else
palabras.add(palabra);
}
else
JOptionPane.showMessageDialog(null, "¡Ha de ingresar una palabra!",
"Ingresar Palabra", JOptionPane.WARNING_MESSAGE);
}
}

La otra acción, la de "mostrar", simplemente le pide al modelo de la tabla que se actualice y esta lo que hará será mostrar las palabras que se encuentran insertada en el ArrayList.

Código: [Seleccionar]
private class AccionMostrar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
modeloTabla.actualizarTabla();

}
}

Y eso es todo.



Código: [Seleccionar]
public class TablaPalabras extends JFrame{

private ArrayList<String> palabras;
private JTextField jtPalabra;
private JButton btIngresar;
private JButton btMostrar;
private ModeloTabla modeloTabla;
private MiTabla tabla;


public TablaPalabras() {

iniciarComponentes();

JPanel pnNorte = new JPanel();
pnNorte.add(new JLabel("Ingrese Palabra"));
pnNorte.add(jtPalabra);
pnNorte.setBorder(BorderFactory.createEmptyBorder(20, 0, 20, 0));

JPanel pnCentro = new JPanel();
pnCentro.setLayout(new BoxLayout(pnCentro, BoxLayout.Y_AXIS));
pnCentro.setBorder(new EmptyBorder(0, 40, 20, 40));

JPanel pnBotones = new JPanel();
JPanel pnIngresar = new JPanel();
pnIngresar.add(btIngresar);
JPanel pnMostrar = new JPanel();
pnMostrar.add(btMostrar);
pnBotones.add(pnIngresar);
pnBotones.add(pnMostrar);

JPanel pnTabla = new JPanel();
JScrollPane scrollTabla = new JScrollPane(tabla);
scrollTabla.setPreferredSize(new Dimension(200, 250));
pnTabla.add(scrollTabla);

pnCentro.add(pnBotones);
pnCentro.add(pnTabla);

setLayout(new BorderLayout());
add(pnNorte, BorderLayout.NORTH);
add(pnCentro, BorderLayout.CENTER);


setTitle("Tabla Palabras");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}

private void iniciarComponentes() {
palabras = new ArrayList<String>();
modeloTabla = new ModeloTabla(palabras);
tabla = new MiTabla();
jtPalabra = new JTextField(12);
btIngresar = new JButton("Ingresar");
btIngresar.addActionListener(new AccionIngresar());
btMostrar = new JButton("Mostrar");
btMostrar.addActionListener(new AccionMostrar());
}

private class ModeloTabla extends AbstractTableModel {

ArrayList<String> palabras;
String[] nombreColumna = new String[]{"Palabras"};

public ModeloTabla(ArrayList<String> palabras) {
this.palabras = palabras;
}

public void actualizarTabla() {
fireTableDataChanged();
}

@Override
public String getColumnName(int col) {
return nombreColumna[col];
}

@Override
public int getRowCount() {
if (palabras == null)
return 0;
else
return palabras.size();
}

@Override
public int getColumnCount() {
return nombreColumna.length;
}

@Override
public Object getValueAt(int rowIndex, int columnIndex) {
return palabras.get(rowIndex);
}

}

private class MiTabla extends JTable {

public MiTabla() {
//Aplicamos nuestro modelo de tabla
super(modeloTabla);
//Pedimos al render que centre los textos en sus celdas.
DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
setDefaultRenderer(Object.class, centerRenderer);
//Cambiamos alguna fuente y color para los datos de la tabla
setFont(new Font("Verdana", Font.PLAIN , 14));
setForeground(Color.BLUE);
//También cambiamos estilo de fuente a la cabecera
JTableHeader cabecera = getTableHeader();
cabecera.setFont(new Font("Verdana", Font.BOLD , 14));
}
}

private class AccionIngresar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {

String palabra = jtPalabra.getText();
jtPalabra.setText(null);
jtPalabra.requestFocus();
if (!palabra.isEmpty() && !palabra.isBlank()) {
if (palabra.length() > 10)
JOptionPane.showMessageDialog(null, "La palabra no puede superar 10 caracteres",
"Ingresar Palabra", JOptionPane.WARNING_MESSAGE);
else
palabras.add(palabra);
}
else
JOptionPane.showMessageDialog(null, "¡Ha de ingresar una palabra!",
"Ingresar Palabra", JOptionPane.WARNING_MESSAGE);
}
}

private class AccionMostrar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
modeloTabla.actualizarTabla();

}
}

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
try {
new TablaPalabras();
}
catch(Exception e) {
e.printStackTrace();
}
}
});
}
}

593
Tercer Ejercicio.

En este caso yo lo que haría crear un "modelo" personalizado para los JList.
Que este modelo sea capaz por sí solo de comprobar si la palabra ya existe en la lista, y si no existe, añadirla.
Para esto creamos una clase que herede de AbstractListModel y le añadimos un ArrayList como atributo y un método boolean para añadir palabras.
Así el método comprueba si la palabra existe, en cuyo caso retorna FALSE indicando que se ha rechazado.
Y si no existe, la añade al ArrayList y notifica al modelo que la lista ha cambiado para que se actualice lo que se ve en pantalla.
Después retorna TRUE informando que la palabra ha sido aceptada.

Código: [Seleccionar]
private class ModeloLista extends AbstractListModel<String> {

private ArrayList<String> lista;

public ModeloLista() {
lista = new ArrayList<String>();
}
//Método para añadir palabras a la lista
public boolean addPalabra(String palabra) {

if (lista.contains(palabra))
return false; //Ya existe esta palabra. La rechazamos
else {
lista.add(palabra); //Añadimos palabra al ArrayList
fireIntervalAdded(this, getSize(), getSize() + 1); //Notificamos al modelo
return true; //Palabra aceptada
}
}
//Los siguientes dos métodos es obligatorio implementarlos al heredar de AbstractListModel
@Override
public int getSize() {
return lista.size();
}

@Override
public String getElementAt(int index) {
return lista.get(index);
}

}

Teniendo este modelo, creamos una clase que herede de JPanel a la que además del texto de cabecera le añadimos un JList que implemente el modelo que hemos creado.
Este panel tendrá un método que recibe la palabra ha insertar y se la pasa al método del modelo que acepta o rechaza la palabra.
Si la rechaza, lanza un JOptionPane informando.

Código: [Seleccionar]
private class PanelLista extends JPanel {

private ModeloLista modeloLista;

public PanelLista(String titulo) {

modeloLista = new ModeloLista();

JPanel pnTitulo = new JPanel();
pnTitulo.add(new JLabel(titulo));
pnTitulo.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(10, 35, 10, 35),
BorderFactory.createBevelBorder(BevelBorder.RAISED)));

JPanel pnLista = new JPanel();
JList<String> lista = new JList<String>();
lista.setModel(modeloLista);

JScrollPane scrollLista = new JScrollPane(lista);
scrollLista.setPreferredSize(new Dimension(150, 200));
scrollLista.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
pnLista.add(scrollLista);

setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
add(pnTitulo);
add(pnLista);
setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(0, 25, 25, 25),
BorderFactory.createSoftBevelBorder(BevelBorder.RAISED)));
}

public void addPalabra(String palabra) {

if (!modeloLista.addPalabra(palabra))
JOptionPane.showMessageDialog(null, "Ya existe esta palabra.",
"Añadir Palabra", JOptionPane.WARNING_MESSAGE);
}

}


Teniendo esta clase PanelLista, crearemos dos paneles de este tipo, uno para que reciba las que empiezan por vocal y otro para que reciba consonantes.

¿Cómo y dónde decidimos a que panel hay que enviar un tipo de palabra u otro?

Podemos hacer que de eso se encargue el botón de ingreso.
En su ActionListener, haremos que recoja la palabra ingresada.
Si no se ha ingresado ninguna palabra, se lanza mensaje de advertencia

Si tenemos palabra, pues analiza el primer caracter para ver si es una vocal o una consonante. De este modo, se decide a que PanelLista hay que enviar esta palabra.

Código: [Seleccionar]
private class AccionIngresar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
String palabra = jtPalabra.getText();
jtPalabra.setText(null);
jtPalabra.requestFocus();
if (!palabra.isEmpty() && !palabra.isBlank()) {
//Comprobamos primer caracter para ver si es vocal o consonante
switch(palabra.toLowerCase().charAt(0)) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
listaVocales.addPalabra(palabra);
break;
default:
listaConsonantes.addPalabra(palabra);
}
}
else
JOptionPane.showMessageDialog(null, "¡Ha de ingresar una palabra!",
"Ingresar Palabra", JOptionPane.WARNING_MESSAGE);
}
}

Y nada más.
Ahora pongo el código completo



Código: [Seleccionar]
public class Listar extends JFrame{

private PanelLista listaVocales;
private PanelLista listaConsonantes;
private JTextField jtPalabra;
private JButton btIngresar;

public Listar() {

iniciarComponentes();

JPanel pnNorte = new JPanel();
JPanel pnPalabra = new JPanel();
pnPalabra.add(new JLabel("Ingrese Palabra"));
pnPalabra.add(jtPalabra);
JPanel pnBoton = new JPanel();
pnBoton.add(btIngresar);
pnNorte.add(pnPalabra);
pnNorte.add(pnBoton);
pnNorte.setBorder(BorderFactory.createEmptyBorder(20, 0, 20, 0));

JPanel pnCentro = new JPanel();
pnCentro.add(listaVocales);
pnCentro.add(listaConsonantes);

setLayout(new BorderLayout());
add(pnNorte, BorderLayout.NORTH);
add(pnCentro, BorderLayout.CENTER);

setTitle("Listas de palabras");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}

private void iniciarComponentes() {
listaVocales = new PanelLista("Comienza con Vocal");
listaConsonantes = new PanelLista("Comienza con Consonante");
jtPalabra = new JTextField(12);
btIngresar = new JButton("Ingresar");
btIngresar.addActionListener(new AccionIngresar());
}

private class ModeloLista extends AbstractListModel<String> {

private ArrayList<String> lista;

public ModeloLista() {
lista = new ArrayList<String>();
}
//Método para añadir palabras a la lista
public boolean addPalabra(String palabra) {

if (lista.contains(palabra))
return false; //Ya existe esta palabra. La rechazamos
else {
lista.add(palabra); //Añadimos palabra al ArrayList
fireIntervalAdded(this, getSize(), getSize() + 1); //Notificamos al modelo
return true; //Palabra aceptada
}
}
//Los siguientes dos métodos es obligatorio implementarlos al heredar de AbstractListModel
@Override
public int getSize() {
return lista.size();
}

@Override
public String getElementAt(int index) {
return lista.get(index);
}

}

private class PanelLista extends JPanel {

private ModeloLista modeloLista;

public PanelLista(String titulo) {

modeloLista = new ModeloLista();

JPanel pnTitulo = new JPanel();
pnTitulo.add(new JLabel(titulo));
pnTitulo.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(10, 35, 10, 35),
BorderFactory.createBevelBorder(BevelBorder.RAISED)));

JPanel pnLista = new JPanel();
JList<String> lista = new JList<String>();
lista.setModel(modeloLista);

JScrollPane scrollLista = new JScrollPane(lista);
scrollLista.setPreferredSize(new Dimension(150, 200));
scrollLista.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
pnLista.add(scrollLista);

setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
add(pnTitulo);
add(pnLista);
setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(0, 25, 25, 25),
BorderFactory.createSoftBevelBorder(BevelBorder.RAISED)));
}

public void addPalabra(String palabra) {

if (!modeloLista.addPalabra(palabra))
JOptionPane.showMessageDialog(null, "Ya existe esta palabra.",
"Añadir Palabra", JOptionPane.WARNING_MESSAGE);
}

}

private class AccionIngresar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
String palabra = jtPalabra.getText();
jtPalabra.setText(null);
jtPalabra.requestFocus();
if (!palabra.isEmpty() && !palabra.isBlank()) {
//Comprobamos primer caracter para ver si es vocal o consonante
switch(palabra.toLowerCase().charAt(0)) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
listaVocales.addPalabra(palabra);
break;
default:
listaConsonantes.addPalabra(palabra);
}
}
else
JOptionPane.showMessageDialog(null, "¡Ha de ingresar una palabra!",
"Ingresar Palabra", JOptionPane.WARNING_MESSAGE);
}
}

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new Listar();
}
});
}
}

594
Segundo ejercicio.

Se puede seguir una lógica similar. De nuevo crear una clase hija de JRadioButton con un atributo String que contenga la ruta hacia la imagen asociada.
Así cada JRadioButton es capaz de proporcionar la ruta para crear e ImageIcon que le seteamos al JLabel
Código: [Seleccionar]
private class RadioImagen extends JRadioButton {
String rutaImagen;

public RadioImagen(String ruta, String texto) {
rutaImagen = ruta;
setText(texto);
}
}

Para ir cambiando la imagen, creamos una clase que implemente la interfaz ActionListener, para agregarsela a estos JRadioButton.

Esta acción se encarga de recuperar la ruta que propociona el radiobotón que ha sido pulsado y con ella, cambia la imagen del JLabel.

Código: [Seleccionar]
private class AccionFoto implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
//Recuperamos JRadioButon que recibe accion
RadioImagen radio = (RadioImagen) e.getSource();
//Le pedimos su ruta a la imagen asociada
jlFoto.setIcon(new ImageIcon(this.getClass().getClassLoader().getResource(radio.rutaImagen)));

}
}

Sobre las imágenes, no se si ya has trabajado con ellas.
Lo más cómodo es crear un package dentro del proyecto y colocarlas ahí. Luego usando ruta relativa se accede a ellas sin problema.



Y ya está. Dejo código completo a continuación



Código: [Seleccionar]
public class ElegirFoto extends JFrame{

private RadioImagen[] radioImagenes;
private JButton btSalir;
private JLabel jlFoto;

public ElegirFoto() {

iniciarComponentes();

setLayout(new BorderLayout());
JPanel pnNorte = new JPanel();
pnNorte.setLayout(new BoxLayout(pnNorte, BoxLayout.X_AXIS));
JPanel pnLabel = new JPanel();
pnLabel.add(new JLabel("Elija una opción para ver la imagen"));
JPanel pnBoton = new JPanel();
pnBoton.add(btSalir);
pnNorte.add(pnLabel);
pnNorte.add(pnBoton);

JPanel pnCentro = new JPanel();
pnCentro.setLayout(new BoxLayout(pnCentro, BoxLayout.X_AXIS));
JPanel pnRadios = new JPanel();
pnRadios.setLayout(new BoxLayout(pnRadios, BoxLayout.Y_AXIS));
for(RadioImagen radio: radioImagenes)
pnRadios.add(radio);
pnRadios.setBorder(BorderFactory.createEmptyBorder(20, 40, 60, 20));
JPanel pnFoto = new JPanel();
pnFoto.add(jlFoto);
pnFoto.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
pnCentro.add(pnRadios);
pnCentro.add(pnFoto);

add(pnNorte, BorderLayout.NORTH);
add(pnCentro, BorderLayout.CENTER);

setTitle("Selector Fotos");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}

private void iniciarComponentes() {
radioImagenes = new RadioImagen[4];
radioImagenes[0] = new RadioImagen("img/perro300.jpeg", "Perro");
radioImagenes[1] = new RadioImagen("img/gato300.jpg", "Gato");
radioImagenes[2] = new RadioImagen("img/tigre300.jpg", "Tigre");
radioImagenes[3] = new RadioImagen("img/leon300.png", "Leon");
ButtonGroup grupo = new ButtonGroup();
radioImagenes[0].setSelected(true);

//Agrupamos los JRadioButton y de paso les añadimos su ActionListener
for (RadioImagen radio: radioImagenes) {
grupo.add(radio);
radio.addActionListener(new AccionFoto());
}

btSalir = new JButton("SALIR");
btSalir.addActionListener(new AccionSalir());

jlFoto = new JLabel(new ImageIcon(this.getClass().getClassLoader().getResource("img/perro300.jpeg")));
jlFoto.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
}

private class RadioImagen extends JRadioButton {
String rutaImagen;

public RadioImagen(String ruta, String texto) {
rutaImagen = ruta;
setText(texto);
}
}

private class AccionSalir implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
Object[] opciones = {"Claro, que SI", "Claro, que NO"};
int respuesta = JOptionPane.showOptionDialog(rootPane,
"¿Desea salir?", "Cerrar Programa", JOptionPane.DEFAULT_OPTION,
JOptionPane.QUESTION_MESSAGE, null, opciones, opciones[1]);

if (respuesta == 0)
System.exit(0);
}
}

private class AccionFoto implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
//Recuperamos JRadioButon que recibe accion
RadioImagen radio = (RadioImagen) e.getSource();
//Le pedimos su ruta a la imagen asociada
jlFoto.setIcon(new ImageIcon(this.getClass().getClassLoader().getResource(radio.rutaImagen)));

}
}

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new ElegirFoto();
}
});
}
}

595
Hola.
Para el primer ejercicio, se me ocurre que aplicando POO se puede simplificar la lógica.

En lugar de usar JRadioButton directamente, se podría crear una clase que herede de JRadioButton.. y añadirle más funcionalidad.
Se le puede pedir que el mismo genere el número random.

Le añadimos dos atributos de tipo int: mínimo y máximo. Y por el constructor le indicamos el valor de esos atributos, así como el texto que ha de mostrar.
Y le implementamos un método que genere un numero random, entre el mínimo y máximo que se le ha establecido.
Código: [Seleccionar]
private class RadioGenerador extends JRadioButton {
private int minimo;
private int maximo;

public RadioGenerador(int min, int max, String texto) {
minimo = min;
maximo = max;
setText(texto);
setFocusPainted(false);
}

public int generaRandom() {
Random rnd = new Random();
return minimo + rnd.nextInt(maximo-minimo);
}
}
De esta manera, cada JRadioButton es capaz de generar un número al azar entre los límites correspondientes.

Cuando se pulse el botón generar, lo que haremos será recorrer los JRadioButton (interesa tenerlos en un array) para ver cuál es el que está seleccionado. Y cuando se encuentre el seleccionado, se le pide que nos de un random y ya se lo pasamos al JLabel para mostrarlo en pantalla.
Código: [Seleccionar]
private class AccionGenerar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
int numAzar = 0;
//Buscamos en el array que Generador está seleccionado y le pedimos un random
for (RadioGenerador generador: generadores)
if (generador.isSelected())
numAzar = generador.generaRandom();
//Lo pasamos al JLabel
jlNumero.setText(String.format("%03d", numAzar));
}
}

Dejo a continuación el código completo.
Como ya dije en otro hilo, no uso NetBeans y la interfaz Swing la construyo de otra forma.
Pero bueno, si entiendes la lógica que he aplicado, supongo que lo podrás adaptar.



Código: [Seleccionar]
public class Generador extends JFrame{

private RadioGenerador[] generadores;
private JButton btGenerar;
private JLabel jlNumero;

public Generador() {

iniciarComponentes();

setLayout(new BorderLayout());
JPanel pnNorte = new JPanel();
pnNorte.add(new JLabel("Generador Números"));

JPanel pnCentro = new JPanel();
JPanel pnRadio = new JPanel();
pnRadio.setLayout(new BoxLayout(pnRadio, BoxLayout.Y_AXIS));
pnRadio.add(generadores[0]);
pnRadio.add(generadores[1]);
pnRadio.add(generadores[2]);
pnRadio.setBorder(BorderFactory.createEmptyBorder(20, 40, 20, 80));
JPanel pnBoton = new JPanel();
pnBoton.add(btGenerar);
pnCentro.setLayout(new BoxLayout(pnCentro, BoxLayout.Y_AXIS));
pnCentro.add(pnRadio);
pnCentro.add(pnBoton);

JPanel pnSur = new JPanel();
pnSur.setBorder(BorderFactory.createEmptyBorder(25, 25, 25, 25));
pnSur.add(jlNumero);

add(pnNorte, BorderLayout.NORTH);
add(pnCentro, BorderLayout.CENTER);
add(pnSur, BorderLayout.SOUTH);

setTitle("Generador Random");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}

private void iniciarComponentes() {
generadores = new RadioGenerador[3];
generadores[0] = new RadioGenerador(0,100, "Entre 0 y 100");
generadores[1] = new RadioGenerador(100,200, "Entre 100 y 200");
generadores[2] = new RadioGenerador(200,500, "Entre 200 y 500");
ButtonGroup grupo = new ButtonGroup();
grupo.add(generadores[0]);
grupo.add(generadores[1]);
grupo.add(generadores[2]);
btGenerar = new JButton("GENERAR");
btGenerar.addActionListener(new AccionGenerar());
jlNumero = new JLabel(String.format("%03d", 0));
jlNumero.setFont(new Font("Verdana", Font.BOLD, 34));
jlNumero.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createLineBorder(Color.BLACK, 5),
BorderFactory.createEmptyBorder(10, 10, 10, 10)));
}


private class RadioGenerador extends JRadioButton {
private int minimo;
private int maximo;

public RadioGenerador(int min, int max, String texto) {
minimo = min;
maximo = max;
setText(texto);
setFocusPainted(false);
}

public int generaRandom() {
Random rnd = new Random();
return minimo + rnd.nextInt(maximo-minimo);
}
}

private class AccionGenerar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
int numAzar = 0;
//Buscamos en el array que Generador está seleccionado y le pedimos un random
for (RadioGenerador generador: generadores)
if (generador.isSelected())
numAzar = generador.generaRandom();
//Lo pasamos al JLabel
jlNumero.setText(String.format("%03d", numAzar));
}
}

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new Generador();
}
});
}
}

596
Muestra lo que tengas hecho y a partir de eso te ayudamos a completarlo.

597
Hola.

El segundo ejercicio, el de alterar el color de un panel, se me ha ocurrido una versión más interesante.
Ofrecer tres deslizadores, cada uno con valores entre 0 y 255 que representen los canales de color Rojo, Verde y Azul (RGB)
Cada canal ofrece valores de 8 bit (256 posibles valores), entre los tres, tenemos color 24 bit, es decir, 16.7 millones de colores distintos.




A continuación dejo el código para quien quiera verlo.
Es muy sencillo. No uso NetBeans así que es todo código escrito "a mano", que por lo general se entiende mucho mejor.

Código: [Seleccionar]
import java.awt.BorderLayout;
import java.awt.Color;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.SwingUtilities;
import javax.swing.border.BevelBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

/**
 *
 * Programa que ofrece tres deslizadores JSlider con valores
 * entre 0 y 255.
 * Cada valor sirve para establecer uno de los tres canales de colores RGB
 * con los cuales modificaremos el color de un panel.
 *
 * @author Kabuto
 */
public class SelectorColor extends JFrame {

private PanelSelectores panelSelectores;
private PanelColor panelColor;

public SelectorColor() {

panelSelectores = new PanelSelectores();
panelColor = new PanelColor();

setLayout(new BorderLayout());
JPanel pnNorte = new JPanel();
pnNorte.add(new JLabel("Use los deslizadores para seleccionar color RGB"));

JPanel pnCentro = new JPanel();
pnCentro.add(panelColor);
pnCentro.add(panelSelectores);

add(pnNorte, BorderLayout.NORTH);
add(pnCentro, BorderLayout.CENTER);


setTitle("Selector RGB");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}

/**
* Este es el panel que cambiará de color.
* Incluye un método para recibir el Color
* que ha de establecerse.
*/
private class PanelColor extends JPanel{

public PanelColor() {
setOpaque(true);
setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createBevelBorder(BevelBorder.RAISED, Color.WHITE, Color.BLACK),
BorderFactory.createEmptyBorder(150, 150, 150, 150)));
setColor(panelSelectores.getColor());
}

public void setColor(Color color) {
setBackground(color);
}
}

/**
* Este será el panel que contiene los tres
* objetos Selector(JSlider).
* Incluye un método para retornar el Color
* configurado según los valores seleccionados
* en los JSlider
*/
private class PanelSelectores extends JPanel {

private Selector canalRojo;
private Selector canalVerde;
private Selector canalAzul;

public PanelSelectores() {

canalRojo = new Selector(0, 255);
canalVerde = new Selector(0, 255);
canalAzul = new Selector(0, 255);

setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
PanelSelector pnRojo = new PanelSelector("Canal Rojo", canalRojo);
PanelSelector pnVerde = new PanelSelector("Canal Verde", canalVerde);
PanelSelector pnAzul = new PanelSelector("Canal Azul", canalAzul);
add(pnRojo);
add(pnVerde);
add(pnAzul);

}

public Color getColor() {
int r = canalRojo.getValue();
int v = canalVerde.getValue();
int a = canalAzul.getValue();

return new Color(r,v,a);
}
}

/**
* Clase para personalizar un JSlider.
* Necesitamos 3 JSlider con cierta configuración.
* Para no repetir 3 veces este código, creamos esta clase
* y así escribimos 1 sola vez.
*/
private class Selector extends JSlider {

public Selector(int min, int max) {
super(min, max);
setPaintTicks(true);
setPaintTrack(true);
setPaintLabels(true);
setMajorTickSpacing(255);
        setMinorTickSpacing(5);
        addChangeListener(new CambioSelector());
}

}

/**
* Clase sencilla que hereda de JPanel.
* Recibe por constructor un texto para el borde titulado y +
* un objeto Selector(un JSlider) para colocarlo en el panel.
* Puesto que vamos a tener tres Selector con el mismo aspecto,
* creando esta clase solo hay que escribir este código 1 sola vez
* y lo podemos usar para los 3 Selector.
* De lo contrario, habría que escribir esto tres veces.
*
*/
private class PanelSelector extends JPanel {

public PanelSelector(String titulo, Selector selector) {
add(selector);
setBorder(BorderFactory.createCompoundBorder(BorderFactory.createTitledBorder(titulo),
BorderFactory.createEmptyBorder(10, 10, 10, 10)));
}
}

/**
* Listener que detecta cuando el deslizador asociado
* cambia su valor actual.
* Cuando se detecta cualquier cambio, lo que se hace
* es actualizar el color del panel con los nuevos valores
*/
private class CambioSelector implements ChangeListener {
@Override
public void stateChanged(ChangeEvent e) {
panelColor.setColor(panelSelectores.getColor());
}
}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new SelectorColor();
}
});
}

}

598
Aprender a programar desde cero / Re: C++ - Opinión de código
« en: 08 de Noviembre 2020, 11:59 »
Hola.

El boolean te lo puedes ahorrar.
En los IF para determinar cómo hacer la suma de vectores según quien es el más grande, puedes comparar directamente el valor de sus longitudes, sin tener que usar previamente un boolean.
Tampoco necesitas la variable largoVectorMayor.

Y también te puedes ahorrar la inicialización a 0 de los elementos del vector.
Puesto que en el programa antes de operar con ellos, vamos a pedir por teclado sus valores, tenemos garantizado que cuando operemos tendrán valores válidos y no "basura" suelta que hayan encontrado por la RAM.

Luego, para imprimir el vector menor haces una operación matemática arriesgada:
Citar
for(int i = 0; i < largoVector2+(largoVector1 - largoVector2); i++){
         cout<<vector2<<" | ";
      }


Digo arriesgada, porque amplias el rango de elementos del arreglo.
Tú ahí quieres que ampliar para que el bucle vaya hasta la longitud del vector grande y calculas la diferencia entre ambas longitudes para sumarsela a la longitud menor.
Es innecesario, porque podría poner directamente que vaya hasta la longitud mayor, sin necesidad de calcular diferencia y sumarsela a la menor.
Pero además es arriesgado porque haces que el indice vaya hasta posiciones que el vector no tiene.
Si el vector menor mide por ejemplo 4, no debemos pedirle que vaya por encima de este valor.

Parecido ocurre con el bucle que suma vectores.
El límite en este caso ha de ser el del tamaño menor, pues esos son los elementos que vamos a sumar.
Los elementos del vector mayor, que están más alla de la longitud del menor, no se van a sumar ni tocar ni nada..., así que no hay que recorrerlos.

Te dejo este código haciendo esos cambios.
Fíjate que en el IF, pregunto si el primer vector es MAYOR O IGUAL.
Esto es importante, porque si solo nos preocupamos de si uno es mayor, o de si el otro es menor...¿que pasaría si resulta que ambos vectores miden lo mismo?

Código: [Seleccionar]
#include<iostream>
#include<math.h>

using namespace std;

int main(){
int largoVector1 = 0, largoVector2 = 0;

cout<<"Largo del vector 1: "; cin>>largoVector1; //dar los valores de largo del vector
cout<<"Largo del vector 2: "; cin>>largoVector2;
int vector1[largoVector1]; //declaraciones de vectores
int vector2[largoVector2];

cout<<"\tVector 1:"<<endl;
for(int i = 0; i < largoVector1; i++){ //declarar valores de los vectores
cout<<"Vector: "; cin>>vector1[i];
}
cout<<"\tVector 2:"<<endl;
for(int i = 0; i < largoVector2; i++){
cout<<"Vector: "; cin>>vector2[i];
}
if(largoVector1 >= largoVector2){ //hacer operatoria e imprimer el primer vector
cout<<"V1: | ";
for(int i = 0; i < largoVector1; i++){
cout<<vector1[i]<<" | ";
}
cout<<"\nV2: | ";
for(int i = 0; i < largoVector2; i++){
cout<<vector2[i]<<" | ";
}
for(int i = 0; i < largoVector2; i++){ //sumar vectores
vector1[i] += vector2[i];
}
cout<<"\nR:  | ";
for(int i = 0; i < largoVector1; i++){ //imprimir vectores
cout<<vector1[i]<<" | ";
}
}else{ //en caso de que el segundo vector sea mayor
cout<<"V1: | ";
for(int i = 0; i < largoVector1; i++){
cout<<vector1[i]<<" | ";
}
cout<<"\nV2: | ";
for(int i = 0; i < largoVector2; i++){
cout<<vector2[i]<<" | ";
}
for(int i = 0; i < largoVector1; i++){ //sumar vectores
vector2[i] += vector1[i];
}
cout<<"\nR:  | ";
for(int i = 0; i < largoVector2; i++){ //imprimir vectores
cout<<vector2[i]<<" | ";
}
}

return 0;
}

599
Comunidad / Re: Presentación
« en: 07 de Noviembre 2020, 00:16 »
Bienvenido.
Espero que te encuentres a gusto aquí y participes siempre que quieras.

Un saludo.

600
Hola.
Tu programa funciona, pero creo que lo que te ocurre es que has escogido mal la clase con la que inicializas el ArrayList.

Tú has creado un ArrayList con la clase Double, que es una clase para trabajar con valores numéricos reales, pero el programa consiste en trabajar con "clientes".

Supongo que para los clientes introduces un nombre, que se debe guardar como String. Desde luego no se puede guardar como Double, por eso te sale la excepción InputMismatch.

Esta excepción indica que el programa está esperando que se le den datos numéricos por teclado, pero está recibiendo cadenas String y entonces no sabe que hacer con ellas.

Así que hay que cambiar la clase del ArrayList:
Citar
public class Mclientest {
   ArrayList<String> listaclientes;

Por cierto, también es recomendable indicar de nuevo la clase el constructor del ArrayList cuando lo inicializamos:

Citar
   public static void main(String[] args) {
      Mclientest miLista = new Mclientest();
      miLista.listaclientes = new ArrayList<String>();
      miLista.leerOpcion();
   }


Luego hay que corregir los métodos para que pida y trabaje con String, no Double.
Por ejemplo:
Citar
   public void ingresarCliente() {
      Scanner teclado = new Scanner(System.in);
      String cliente;
      System.out.print("Ingrese Cliente: ");
      cliente = teclado.nextLine();
      listaclientes.add(cliente);
   }


Tras hacer todas las correcciones en cada método, el programa funciona perfectamente.

Es decir, tu programa está bien. Solo has errado al escoger la clase del ArrayList. Si vamos a trabajar con nombres de clientes, hay que usar String, no Double.

Páginas: 1 ... 25 26 27 28 29 [30] 31 32 33 34 35 ... 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".