Problema en Java usando swing INTERFAZ GRAFICA AYUDA

[MarianoTW]

Hola buenas con todos.
Tengo que hacer un programa en Java con interfaz grafica usando swing, que permita calcular el promedio final de los N alumnos que contiene un salon si se sabe que el promedio de cada alumno se obtiene de la siguiente forma:

• 30% de Examen Parcial
• 55% del Examen Final
• 15% del Trabajo final

Por último hallar el promedio de los N alumnos ingresados.

Ejemplo:

Ingrese el número de alumnos: 3
Ingrese el EF del Alumno 1: 15
Ingrese el EP del Alumno 1: 10
Ingrese el TF del Alumno 1: 13

Su promedio final es: 13.20
Ingrese el EF del Alumno 2: 12
Ingrese el EP del Alumno 2: 15
Ingrese el TF del Alumno 2: 8

Su promedio final es: 12.30
Ingrese el EF del Alumno 3: 18
Ingrese el EP del Alumno 3: 15
Ingrese el TF del Alumno 3: 16
Su promedio final es: 16.8
El promedio de los 3 alumnos es: 14.1

[Kabuto]

Vale, ¿y cuál es la duda? ¿Dónde te atascas?
¿En hacer los cálculos de porcentajes? ¿En pedir datos con interfaz gráfica?

Por cierto, sobre la interfaz gráfica. Por el planteamiento del ejercicio, supongo que lo que se espera es que se pidan datos usando JOptionPane, ¿no?

No parece que quieran que se construya un marco completo desde cero, con paneles, campos de texto, botones,...

Por el planteamiento, eso de preguntar primero cuántos alumnos se van a introducir y luego pedir datos..., suena a programación lineal estructurada, solo que en lugar de pedir datos por consola se piden con JOptionPane.

Confírmanos si es usando JOptionPane, e intenta comenzar tú un código.

Si lo que se te complica es hacer los cálculos de porcentajes, pues de momento no los hagas. Haz un programa que solo pida los datos con JOptionPane pero que de momento no se computen.

Si lo que no tienes claro es lo del JOptionPane, pues de momento pide los datos por consola e intentar hacer los cálculos de porcentajes.

La cuestión es que hagas tú un intento de solucionarlo, aunque sea parcialmente. Y lo compartas por aquí para que podamos corregir, completar, aclarar dudas concretas..., lo que sea.

[MarianoTW]

Hola, gracias por responder. He hecho esto, pero no me llega a salir el promedio de las notas finales de todos los alumnos y no se como hacerle una interfaz grafica a ello. Justo en eso queria ayuda o que me puedan indicar como llegar a hacerlo.

Código: [Seleccionar]

package promedio;
import java.util.Scanner;

public class Promedio {

    public static void main(String[] args) {
       
        Scanner teclado=new Scanner(System.in);
        double nota1, nota2, nota3, promedio = 0, na, promediofinal;
       
        System.out.println("Ingrese el numero de alumnos: ");
        na=teclado.nextInt();
       
        for (int i=0; i<na;i++)
        {
            System.out.println("Ingrese la nota del Examen Final del Alumno " + (i+1) +":");
            nota1=teclado.nextInt();
            System.out.println("Ingrese la nota del Examen Parcial del Alumno " + (i+1) +":");
            nota2=teclado.nextInt();
            System.out.println("Ingrese la nota del Trabajo Final del Alumno " + (i+1) +":");
            nota3=teclado.nextInt();
           
            promedio= (((nota1*0.55)+(nota2*0.3)+(nota3*0.15)));
           
            System.out.println("Su promedio final es : "+promedio);
        }
        promediofinal= (promedio/na);
        System.out.println("El promedio de los: "+na+" alumnos es: "+promediofinal);
    }
   
}


[Kabuto]

Vale, para poder calcular el promedio final de TODOS los alumnos, has de ir acumulando el promedio de cada alumno en la variable promediofinal.
Para ya luego al final, dividir por el total de alumnos y obtener el promedio.

Y la variable na donde preguntamos el "número de alumnos", es más correcta declararla como int y no como double.

   public static void main(String[] args) {
       
      Scanner teclado=new Scanner(System.in);
      int na;
        double nota1, nota2, nota3, promedio = 0, promediofinal = 0;
       
        System.out.println("Ingrese el numero de alumnos: ");
        na=teclado.nextInt();
       
        for (int i=0; i<na;i++)
        {
            System.out.println("Ingrese la nota del Examen Final del Alumno " + (i+1) +":");
            nota1=teclado.nextInt();
            System.out.println("Ingrese la nota del Examen Parcial del Alumno " + (i+1) +":");
            nota2=teclado.nextInt();
            System.out.println("Ingrese la nota del Trabajo Final del Alumno " + (i+1) +":");
            nota3=teclado.nextInt();
           
            promedio= (((nota1*0.55)+(nota2*0.3)+(nota3*0.15)));
           
            System.out.println("Su promedio final es : "+promedio);
            //Acumulamos promedios
            promediofinal += promedio;
        }
     
        System.out.println("El promedio de los: "+na+" alumnos es: "+ promediofinal/na);

   }

Bien, con esto queda solucionada la lógica del programa.
Sobre la interfaz gráfica, sigo sin saber si es usando JOptionPane o bien usando una interfaz gráfica completa

JOptionPane parece más adecuado por el planteamiento que nos piden, por lo de preguntar primero cuántos alumnos se van a introducir, ya que la duración del programa dependerá de esa cantidad de alumnos.

Una interfaz gráfica "completa" requiere bastante más código y no suele usarse para ese tipo de planteamientos. Normalmente el programa dura hasta que el usuario decida cerrar la ventana de aplicación y la entrada de datos no depende de un bucle, los campos de texto están disponibles para que el usuario vaya introduciendo cuando quiera, y cuanto quiera...

Con JOptionPane la estructura del programa sigue siendo igual a cuando se hace un programa para consola, solo que ya no se usa Scanner para leer datos ni System.out.print para mostrarlos.

Se usa la clase JOptionPane, que se encarga de abrir distintas ventanas de dialogo "pop-up" según necesitemos.
Unas son para mostrar datos, como los MessageDialog.
Otras son para solicitar datos, como los InputDialog. Los datos que solicitamos, SIEMPRE los recibimos como String, aunque pidamos números.
Así que tendremos que parsearlos a Integer o a Double, según necesitemos.

import javax.swing.JOptionPane;

public class Promedios {

   public static void main(String[] args) {
       
      int na;
        double nota1, nota2, nota3, promedio = 0, promediofinal = 0;
       
        na = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de alumnos:"));
       
        for (int i=0; i<na;i++)
        {

            nota1=Double.parseDouble(JOptionPane.showInputDialog("Ingrese la nota del Examen Final del Alumno " + (i+1) +":"));
            nota2=Double.parseDouble(JOptionPane.showInputDialog("Ingrese la nota del Examen Parcial del Alumno " + (i+1) +":"));
            nota3=Double.parseDouble(JOptionPane.showInputDialog("Ingrese la nota del Trabajo Final del Alumno " + (i+1) +":"));
           
            promedio= (((nota1*0.55)+(nota2*0.3)+(nota3*0.15)));
           
            JOptionPane.showMessageDialog(null, "Su promedio final es : "+promedio);
            //Acumulamos promedios
            promediofinal += promedio;
        }
     
        JOptionPane.showMessageDialog(null, "El promedio de los: "+na+" alumnos es: "+ promediofinal/na);
   }
}

Creo que eso es lo que están pidiendo.

No creo que sea una interfaz gráfica completa, porque insisto en que requiere de muchos más conocimientos: clases JFrame, JPanel, JTextField, JButton, ActionListeners...
Y por supuesto nociones de programación orientada a objetos, porque la estructura del programa cambia radicalmente.... no tendría nada que ver con lo que hemos escrito hasta ahora.

[MarianoTW]

Hola, gracias por tomarte la molestia de ayudarme y disculpa por no explicarme correctamente o de una forma mas clara, pero tienes razon cuando dices que piden una interfaz gráfica completa y eso era lo que me estaba faltando. Primero siempre empiezo haciendo que me funcione el codigo simple para ver como voy y luego intento hacer el interfaz como lo tengo hasta ahora :

Código: [Seleccionar]

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextArea;
import javax.swing.JTextField;


public class promedio implements ActionListener {
JLabel n_alumnos,nota1,nota2,nota3;
JTextField m_alunm,n1,n2,n3;
JButton boton;
JTextArea area;
JFrame panel;

String p1;

public promedio(){
panel = new JFrame("notas");

n_alumnos = new JLabel("Ingrese la cantidad de alumnos ");
n_alumnos.setBounds(10,20,80,20);

nota1 = new JLabel("Nota1");
nota1.setBounds(10,50,80,20);

nota2 = new JLabel("Nota2");
nota2.setBounds(10, 80, 80, 20);

nota3 = new JLabel("Nota3");
nota3.setBounds(10,100,80,20);

m_alunm = new JTextField();
m_alunm.setBounds(100,20,80,20);

n1 = new JTextField();
n1.setBounds(100,50,80,20);

n2= new JTextField();
n1.setBounds(100, 80, 80, 20);

n3 = new JTextField();
n3.setBounds(100, 100, 80, 20);

boton = new JButton("Procesar");
boton.setBounds(200, 20, 80, 20);
boton.addActionListener(this);

area = new JTextArea();
area.setBounds(10,110,300,250);

panel.add(n_alumnos);
panel.add(nota1);
panel.add(nota2);
panel.add(nota3);
panel.add(m_alunm);
panel.add(n1);
panel.add(n2);
panel.add(n3);
panel.add(boton);
panel.add(area);

panel.setLayout(null);
panel.setSize(400,400);
panel.setVisible(true);
panel.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

@Override
public void actionPerformed(ActionEvent e) {
    try{
        String p1 =n1.getText();
        int p = Integer.parseInt(p1);
        }
        if(e.getSource()==boton){
            for(int i=0,i<n,i++){
            System.out.println("Ingrese la nota del Examen Final del Alumno " + (i+1) +":");
            nota1=teclado.nextInt();
            System.out.println("Ingrese la nota del Examen Parcial del Alumno " + (i+1) +":");
            nota2=teclado.nextInt();
            System.out.println("Ingrese la nota del Trabajo Final del Alumno " + (i+1) +":");
            nota3=teclado.nextInt();
           
            promedio= (((nota1*0.55)+(nota2*0.3)+(nota3*0.15)));
           
            System.out.println("Su promedio final es : "+promedio);
            promediofinal += promedio;
        }
     
        System.out.println("El promedio de los: "+na+" alumnos es: "+ promediofinal/na);

   }
            }
        }
    }
Queria ayuda en esto, como podía llegar a hacerlo o una idea de como tenía que hacerlo correctamente. Solo llego hasta ahí y no se como avanzar o como hacer para que desde un inicio me pida el numero de alumnos y luego todos los datos como esta en en el ejemplo. Igual gracias por ayuda 

[Kabuto]

Ok, pues hagamos una interfaz completa.

Podemos comenzar preguntando con un JOptionPane cuántos alumnos se van a ingresar, igual que hemos hecho en el programa anterior.


Solo que esta vez no vamos a hacer ningún bucle, ya que con una interfaz gráfica no podemos usar un bucle como hicimos en las dos versiones anteriores.

Lo que haremos será mostrar tres campos de texto para las tres notas y un botón para aceptar y computar esas notas.



Al computar las notas, calcularemos y mostraremos el promedio de ese alumno en un área de texto que servirá como si fuera un listado, ya que para cada alumno se agregará una línea a esa lista.



Cada vez que computamos notas, aumentaremos un contador y cuando alcance el mismo valor que la cantidad de alumnos escogida, entonces desactivaremos los campos de texto para que el usuario sepa que ha terminado la inserción y mostraremos en otro campo de texto, el promedio total de todas los promedios calculados de los alumnos.



Y ahí terminaría el programa

Para construir esa interfaz, que es muy sencilla, lo que hago es usar un BorderLayout que nos permite dividir el marco JFrame en 5 zonas: norte, sur, este, oeste y centro.

De esas 5 zonas, solo voy a usar 4, donde colocaré distintos JPanel, cada uno escritos como una clase.
Así en lugar de dar forma a una interfaz completa de una sola vez, puedo hacerlo escribiendo códigos más pequeños para cada zona.
Así cada zona podrá tener sus propios layouts, según nos convenga.

Este sería el código. Parecen muchas líneas, pero es fácil de leer. Ya verás que cada una de las 4 zonas que componen toda la ventana, están escritas como clases individuales.
Así que para entender como se ha hecho el área de texto, o los campos de texto con el botón, no hay que leer el código entero. Solo la parte que corresponde a su clase.

La acción del botón también está escrito como una clase individual, que es donde ocurre lo interesante. Ahí se capturan los datos introducidos, se comprueba que son datos válidos, se computan, se actualizan contadores y acumuladores, etc...

Espero que te sirva. Pregunta lo que no entiendas o lo que creas que debería ser distinto.
Un saludo.

Código: [Seleccionar]

package promedioAlumnos;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

public class PromedioSwing extends JFrame {

private int na, contador;
private double sumaPromedios;
//Componentes
private JLabel etiqNorte;
private JTextField notaExFin, notaExPar, notaTrabFinal, promedFinal;
private JTextArea promedAlumnos;
private JButton btComputar;
//Paneles
private PanelNorte pnNorte;
private PanelCentral pnCentro;
private PanelSur pnSur;
private PanelEste pnEste;

public PromedioSwing() {

na = Integer.parseInt(
JOptionPane.showInputDialog(this, "¿Cuántos alumnos va a introducir?",
"Cantidad Alumnos", JOptionPane.QUESTION_MESSAGE));
sumaPromedios = 0;
contador = 0;

iniciarComponentes();

pnNorte = new PanelNorte();
pnCentro = new PanelCentral();
pnSur = new PanelSur();
pnEste = new PanelEste();
setLayout(new BorderLayout());
add(pnNorte, BorderLayout.NORTH);
add(pnCentro, BorderLayout.CENTER);
add(pnSur, BorderLayout.SOUTH);
add(pnEste, BorderLayout.EAST);

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

private void iniciarComponentes() {
etiqNorte = new JLabel();
notaExFin = new JTextField(5);
notaExPar = new JTextField(5);
notaTrabFinal = new JTextField(5);
promedFinal = new JTextField(5);
promedFinal.setHorizontalAlignment(JTextField.CENTER);
promedFinal.setEditable(false);
promedAlumnos = new JTextArea(8,5);
promedAlumnos.setEditable(false);
btComputar = new JButton("Computar");
btComputar.addActionListener(new AccionComputar());
}

//Clases para modelar paneles
private class PanelNorte extends JPanel {

public PanelNorte() {

etiqNorte.setForeground(Color.BLUE);
etiqNorte.setFont(new Font("Arial", Font.BOLD, 30));
add(etiqNorte);
actualizaContador();
setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(15, 25, 10, 25),
BorderFactory.createLoweredSoftBevelBorder()));

}
public void actualizaContador() {
contador++;
etiqNorte.setText("NOTAS DE ALUMNO #" + contador + "/" + na);
}
}

private class PanelCentral extends JPanel {
public PanelCentral() {

JPanel panelesNotas = new JPanel();
panelesNotas.setLayout(new GridLayout(1,3,10,0));
panelesNotas.add(new PanelNota(new JLabel("Nota Examen Final:"), notaExFin));
panelesNotas.add(new PanelNota(new JLabel("Nota Examen Parcial:"), notaExPar));
panelesNotas.add(new PanelNota(new JLabel("Nota Trabajo Final:"), notaTrabFinal));

JPanel pnBoton = new JPanel();
btComputar.setFont(new Font("Arial", Font.BOLD, 25));
pnBoton.add(btComputar);

setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
add(panelesNotas);
add(pnBoton);
setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(25, 25, 25, 25),
BorderFactory.createRaisedSoftBevelBorder()));
}

public void limpiarCampos() {
notaExFin.setText(null);
notaExPar.setText(null);
notaTrabFinal.setText(null);
}
}

private class PanelSur extends JPanel {
public PanelSur() {
JLabel etiq = new JLabel("Promedio Total Alumnos:");
etiq.setFont(new Font("Arial", Font.PLAIN, 25));
add(etiq);

promedFinal.setFont(new Font("Arial", Font.BOLD, 25));
promedFinal.setForeground(Color.BLUE);
add(promedFinal);

setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(10,25,15,25),
BorderFactory.createRaisedSoftBevelBorder()));
}
}

private class PanelEste extends JPanel {
public PanelEste() {

setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
add(new JLabel("Promedios Alumnos"));
JScrollPane scroll = new JScrollPane(promedAlumnos);
add(scroll);
setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(10, 10, 25, 25),
BorderFactory.createLoweredSoftBevelBorder()),
BorderFactory.createEmptyBorder(10, 10, 10, 10)
));
}
}

private class PanelNota extends JPanel {
public PanelNota(JLabel texto, JTextField campo) {
add(texto);
add(campo);
}
}


//Clase Listener
private class AccionComputar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
String nota1 = notaExFin.getText();
String nota2 = notaExPar.getText();
String nota3 = notaTrabFinal.getText();

if (nota1.isBlank() || nota2.isBlank() || nota3.isBlank())
JOptionPane.showMessageDialog(null, "Ha de completar los tres campos",
"Computar notas", JOptionPane.WARNING_MESSAGE);
else {
try {
//Parseamos notas
double valor1 = Double.parseDouble(nota1);
double valor2 = Double.parseDouble(nota2);
double valor3 = Double.parseDouble(nota3);
//Calculamos promedio
double promedio = (((valor1*0.55)+(valor2*0.3)+(valor3*0.15)));
//Acumulamos para luego scar promedio final
sumaPromedios += promedio;
//Actualizamos lista de promedios
promedAlumnos.append(String.format("Alumno #%d: %.2f\n", contador, promedio));
//Limpiamos campos
pnCentro.limpiarCampos();
//Comprobamos si hemos terminado
if (contador == na) { //Hemos terminado
//Desactivamos interfaz
btComputar.setEnabled(false);
notaExFin.setEnabled(false);
notaExPar.setEnabled(false);
notaTrabFinal.setEnabled(false);
//Calculamos promedio final y mostramos
double promFin = sumaPromedios / na;
promedFinal.setText(String.format("%.2f", promFin));
//Anunciamos fin de proceso
JOptionPane.showMessageDialog(null, "Fin de inserción de datos",
"Fin", JOptionPane.INFORMATION_MESSAGE);
}
else //No hemos terminado
pnNorte.actualizaContador(); //Pasamos al siguiente alumno
}
catch(NumberFormatException ex) {
JOptionPane.showMessageDialog(null, "Introduzca solo valores numéricos",
"Computar notas", JOptionPane.WARNING_MESSAGE);
}
}

}
}

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