Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Si ejecutas tu código, verás que no salen agrupados por ubicación.

La idea sería que primero se mostrasen por ejemplo los eventos Gold y el precio de cada evento. El precio se podría mostrar completo, con el impuesto y el descuento, que puede variar según si es temporada alta o baja.

Luego, lo mismo con los Platinum y por último los VIP.

Esto lo podríamos hacer con tres bucles, o tres métodos, donde cada uno se ocupe de mostrar los eventos de una ubicación concreta.

Pero si previamente ordenamos los eventos por ubicación, podremos hacerlo con un único bucle.

Para ordenarlos así, a la clase MisComparadores podemos añadir un nuevo Comparator, el cuál simplemente tiene que retornar el resultado de comparar el carácter que representa el código de ubicación de los eventos.

public class MisComparadores {
   
   public static final Comparator<Evento> TITULO_EVENTO_DESCENDENTE = new Comparator<Evento>() {
      @Override
      public int compare(Evento evento1, Evento evento2) {
         /*
          * Los titulos son cadenas String.
          * La clase String ya sabe como ha de compararse ella misma,
          * así que podemos retornar directamente el resultado de
          * comparar los títulos de los eventos.
          * Sin embargo, por defecto, la comparación de la clase String
          * nos daría un orden ASCENDENTE (de A a Z) y nosotros queremos
          * un orden DESCENDENTE (de Z a A).
          * Podemos revertir ese orden simplemente multiplicando por -1
          * el resultado que da la comparación de la clase String
          */
         return (evento1.getTitulo().compareTo(evento2.getTitulo())) * -1;
      }
   };
   
   public static final Comparator<Evento> UBICACION_ASCENDENTE = new Comparator<Evento>() {
      @Override
      public int compare(Evento evento1, Evento evento2) {
         return Character.compare(evento1.getCodigoUbicacion(), evento2.getCodigoUbicacion());
      }
   };

}

Con este comparador, y sin necesidad de cambiar nada en la clase Evento ya podemos desarrollar la clase Prueba02 para que haga el listado.
Primero ordenaremos según ubicación.
Y luego al listar, haremos que el sistema detecte cuándo ha terminado con los eventos de una ubicación y va a comenzar con otros, para que lo muestre en pantalla.
package pruebas;

import java.util.ArrayList;

import entidades.Evento;
import util.MisComparadores;

public class Prueba02 {

private static ArrayList<Evento> eventos = new ArrayList<Evento>();

public static void main(String[] args) {
//Agregamos eventos para pruebas
        Evento.cargarDatosPruebas(eventos);

        //Listar los Eventos
        eventos.sort(MisComparadores.UBICACION_ASCENDENTE); //Ordenamos por ubicacion
        System.out.println("\n\t\tLISTADO DE EVENTOS AGRUPADOS POR UBICACION");
       
        char ubicacion = ' ';
        for (Evento even: eventos) {
        //Comprobamos si el evento actual es de distinta ubicacion, y por tanto comienza nuevo grupo
        if (even.getCodigoUbicacion() != ubicacion) { //Ubicacion distinta
        System.out.println(textoUbicacion(even.getCodigoUbicacion())); //Iniciamos nuevo grupo
        ubicacion = even.getCodigoUbicacion(); //Actualizamos la ubicacion actual
        }
        //Mostramos datos del evento
        System.out.printf("--> Titulo: %-35s --> Precio: %.2f\n",
        even.getTitulo(), even.getMontoTotal() - even.getDescuento());
     
        }

}

/*
* Devuelve un texto descriptivo para el codigo de ubicacion.
* Lo usaremos como cabecera para cada grupo de eventos.
*/
private static String textoUbicacion(char codigo) {
switch(codigo) {
case 'G':
return "\n\t---EVENTOS Gold---";
case 'P':
return "\n\t---EVENTOS Platinum---";
default:
return "\n\t---EVENTOS VIP---";
}
}

}

Al ejecutarlo, en pantalla vemos como los eventos quedan visiblemente agrupados.

      LISTADO DE EVENTOS AGRUPADOS POR UBICACION

   ---EVENTOS Gold---
--> Titulo: Recuperacion Fauna Iberica          --> Precio: 159,83
--> Titulo: Descifrando Codigo Ensamblador      --> Precio: 168,71

   ---EVENTOS Platinum---
--> Titulo: Impacto Guerra Ucrania              --> Precio: 265,77
--> Titulo: Presentacion Novela Historica       --> Precio: 265,77

   ---EVENTOS VIP---
--> Titulo: Arte Textil Africano                --> Precio: 106,49
--> Titulo: Nuevas Tecnicas Marketing           --> Precio: 106,49

En los precios vemos que solo hay variedad en los Gold, porque uno es "temporada alta" y el otro no.
En los otros no hay variación porque resulta que los hemos creado bajo la misma temporada.

Opcionalmente, podemos modificar el código de creación de estos eventos para que no coincidan sus temporadas, y así reflejar más variedad en los precios.

      LISTADO DE EVENTOS AGRUPADOS POR UBICACION

   ---EVENTOS Gold---
--> Titulo: Recuperacion Fauna Iberica          --> Precio: 159,83
--> Titulo: Descifrando Codigo Ensamblador      --> Precio: 168,71

   ---EVENTOS Platinum---
--> Titulo: Impacto Guerra Ucrania              --> Precio: 265,77
--> Titulo: Presentacion Novela Historica       --> Precio: 280,53

   ---EVENTOS VIP---
--> Titulo: Arte Textil Africano                --> Precio: 106,49
--> Titulo: Nuevas Tecnicas Marketing           --> Precio: 100,89

Venga, que ya queda menos.
Sigue adelante con la siguiente prueba:

clase Prueba03 que muestre la lista de eventos y el total recaudado por cada evento.

Para esta prueba, no será necesario ordenar los eventos de ninguna manera.
Solamente hacer una lista con los títulos de los eventos y el total recaudado.

El total recaudado sería el resultado de multiplicar el precio (monto - descuento) por la cantidad de asistentes a dicho evento. La cantidad de asistentes la sabemos por el tamaño que tenga el ArrayList, y esto nos lo dice su método size()

En este caso, si podrías hacer un nuevo método para la clase Evento que se ocupe de hacer el cálculo de la recaudación.

Un saludo.

A ver, lo primero es identificar las principales entidades que intervienen.

Aquí se organizan Eventos.
En un Evento interviene un Expositor y van a acudir una cantidad indefinida de Asistentes

Evento, Expositor y Asistente serían las principales entidades.

Esta podría ser la clase Asistente
package entidades;

public class Asistente {

private String codigo;
private String nombre;
private String apellidos;
private String correo;
private String telefono;
private String direccion;

public Asistente(String codigo, String nombre, String apellidos, String correo,
String telefono, String direccion) {
this.codigo = codigo;
this.nombre = nombre;
this.apellidos = apellidos;
this.correo = correo;
this.telefono = telefono;
this.direccion = direccion;
}

public String getCodigo() {
return codigo;
}

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

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 getCorreo() {
return correo;
}

public void setCorreo(String correo) {
this.correo = correo;
}

public String getTelefono() {
return telefono;
}

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

public String getDireccion() {
return direccion;
}

public void setDireccion(String direccion) {
this.direccion = direccion;
}

}

Esta la clase Expositor
package entidades;

public class Expositor {

private String codigo;
private String nombre;
private String apellidos;
private double sueldo;
private String correo;

public Expositor(String codigo, String nombre, String apellidos, double sueldo, String correo) {
this.codigo = codigo;
this.nombre = nombre;
this.apellidos = apellidos;
this.sueldo = sueldo;
this.correo = correo;
}

public String getCodigo() {
return codigo;
}

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

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 double getSueldo() {
return sueldo;
}

public void setSueldo(double sueldo) {
this.sueldo = sueldo;
}

public String getCorreo() {
return correo;
}

public void setCorreo(String correo) {
this.correo = correo;
}

}

Y esta la clase Evento.
Además de los atributos que indica el enunciado, yo le he añadido un ArrayList para contener a los asistentes que acudirán a este evento.

Además incluye los métodos que pide el enunciado. Aunque no me queda claro si el descuento según la temporada, debería ir aplicado en el resultado que calcula el "monto total".

package entidades;

import java.util.ArrayList;
import util.MisConstantes;

public class Evento {

private String titulo;
private int duracion;
private Expositor expositor;
private String horaIngreso;
private String horaSalida;
private boolean esTemporadaAlta;
private char codigoUbicacion;
private ArrayList<Asistente> asistentes;

public Evento(String titulo, int duracion, Expositor expositor, String horaIngreso, String horaSalida,
boolean esTemporadaAlta, char codigoUbicacion) {
this.titulo = titulo;
this.duracion = duracion;
this.expositor = expositor;
this.horaIngreso = horaIngreso;
this.horaSalida = horaSalida;
this.esTemporadaAlta = esTemporadaAlta;
this.codigoUbicacion = codigoUbicacion;
asistentes = new ArrayList<Asistente>();
}

public String getTitulo() {
return titulo;
}

public void setTitulo(String titulo) {
this.titulo = titulo;
}

public int getDuracion() {
return duracion;
}

public void setDuracion(int duracion) {
this.duracion = duracion;
}

public Expositor getExpositor() {
return expositor;
}

public void setExpositor(Expositor expositor) {
this.expositor = expositor;
}

public String getHoraIngreso() {
return horaIngreso;
}

public void setHoraIngreso(String horaIngreso) {
this.horaIngreso = horaIngreso;
}

public String getHoraSalida() {
return horaSalida;
}

public void setHoraSalida(String horaSalida) {
this.horaSalida = horaSalida;
}

public boolean isEsTemporadaAlta() {
return esTemporadaAlta;
}

public void setEsTemporadaAlta(boolean esTemporadaAlta) {
this.esTemporadaAlta = esTemporadaAlta;
}

public char getCodigoUbicacion() {
return codigoUbicacion;
}

public void setCodigoUbicacion(char codigoUbicacion) {
this.codigoUbicacion = codigoUbicacion;
}

public void addAsistente(Asistente asis) {
asistentes.add(asis);
}

public double getCostoIngreso() {
switch(codigoUbicacion) {
case 'P':
return MisConstantes.COSTO_P;
case 'G':
return MisConstantes.COSTO_G;
default:
return MisConstantes.COSTO_V;
}
}

public double getMontoTotal() {
double ingreso = getCostoIngreso();
return ingreso + (ingreso*MisConstantes.IGV/100);
}

public double getDescuento() {
return esTemporadaAlta?getMontoTotal()*10/100:getMontoTotal()*5/100;
}

}

Para dichos cálculos, se usan una constantes que el enunciado pide declarar en un package separado:
package util;

public class MisConstantes {
//Costos de ubicacion
public final static double COSTO_P = 250.25;
public final static double COSTO_G = 150.5;
public final static double COSTO_V = 95;
//Impuesto general de ventas
public final static int IGV = 18; //% sobre precio base
}

Bien, esas podrían ser las clases. Luego puede que queramos añadir algún método más o modificar algo.

Pero en principio, con esto ya se podría comenzar a hacer las distintas clases de "prueba" que pide el enunciado.

Intenta comenzar tú la primera.
Se necesitará un ArrayList para almacenar los distintos Eventos que se vayan creando.
Estos eventos se tendrán que crear dentro de un bucle, pidiendo datos al usuario.
Y por cada Evento, habrá que crear también un Expositor y varios Asistentes (en un segundo bucle anidado)

Inténtalo y comparte por aquí lo que consigas.
Un saludo.

¡Estupenda noticia!

Me alegra que hayas logrado trabajar de lo que te apasiona.
No dejes de visitarnos de vez en cuando, quizás puedas ayudar a otros que están empezando. Y los comienzos en esto pueden ser durillos sin el apoyo de otros, como tú mismo habrás comprobado.

Un saludo.

Haz tú primero un intento y compartelo por aquí.
Si no consigues al solución, te ayudamos a corregir/completar lo que sea.

Tienes que pedir un dato de tipo char al usuario.
Con un objeto Scanner, puedes pedirlo con el método nextLine(), el cuál te devuelve un String, pero si además le encadenas el método charAt(0) obtendrás un char.
nextLine().charAt(0);

Sin embargo, como hay que contemplar la posibilidad de que el caracter recibido sea mayúscula o minúscula, en estos casos lo ideal es transformar directamente a uno o a otro.
Como nos dice que al final hay que mostrar la ficha elegida y ha de mostrarse en mayúscula, pues así lo vamos a convertir.
Podemos hacerlo con el método toUpperCase(), aplicándolo al String que nos devuelve nextLine(), antes de pedir que lo convierta a char
nextLine().toUpperCase().charAt(0);


Esta petición de dato al usuario, se hace dentro de un bucle while que se ha de repetir mientras la ficha introducida sea distinto de 'X' y de 'O'

Inténtalo.
Un saludo.

Hola.

Pues de momento parece que vas bien.
El siguiente paso sería comprobar si la posición que ha indicado el usuario, está libre u ocupada antes de asignársela.
Y después de eso, otro paso será comprobar si el lote A está ya al 50%, para ver si hay que derivarlo a los otros lotes.

Sí, pero ponerlo como atributo de Main tiene una ventaja.

Por ejemplo, la clase ActionListener para el botón de "Borrar", necesita tener acceso al campo de texto:

   private class AccionBorrar implements ActionListener {
      @Override
      public void actionPerformed(ActionEvent e) {
         etMensajes.setText(null);
         campoTexto.setText(null);
      }
   }

Al ponerlo como atributo de Main, entonces es visible en todos los ámbitos del programa y este ActionListener puede acceder directamente a ese campo.

Si lo hubiéramos puesto como atributo de la clase PanelCampoTexto, entonces su ámbito se queda limitado al interior de esta clase.
El resto de clases ya no pueden acceder a él, porque no pueden "verlo" al ser un atributo privado de otra clase.
Aunque eso tendría otras soluciones:
- Declararlo como atributo public en lugar de private.
- Proporcionar a la clase PanelCampoTexto un gettter y un setter que de acceso a su atributo privado.
- O proporcionar a PanelCampoTexto un método que se encargue de borrar el campo, ya que en realidad es la única interacción que necesitamos hacer con él.
Este método sería publico y por tanto visible para otras clases.

Aunque para aplicar estas soluciones, tendremos que declarar a la propia clase PanelCampoTexto como atributo del Main.

Siempre hay distintas formas de hacer una misma cosa, ya cada programador decide cuál emplear.

Yo, cuando se trata de programas así sencillos como este, suelo declarar los campos de texto, etiquetas, botones, etc.. como atributos del Main. Al menos los que sé que otras clases van a necesitar poder acceder a ellos.

En un programa más complejo, donde fácilmente pueden haber 30 campos de texto, 12 botones, 40 etiquetas,.... hacerlo así puede resultar caótico y poco elegante tener medio centenar de atributos declarados en el Main.
En estos casos, ya sí prefiero que cada clase JPanel tenga sus propios atributos, con los setters/getters y métodos que hagan falta para que sus elementos puedan comunicarse con otras clases.
Y además, prefiero que cada una de estas clases estén escritas en su propio archivo .java.

Es curioso, pero cuánto más complejo es el programa, menos código acabo poniendo en el Main
Porque prefiero "modularlo" en distintos archivos  .java.

Así es más fácil de desarrollar, comprobar y mantener el programa.
Si detecto un fallo en un panel en concreto, me voy a su archivo correspondiente a ver que está ocurriendo.
Es más cómodo ir mirando archivos sueltos de apenas un centenar de líneas, que no tener que revisar un único archivo kilométrico con miles y miles de líneas de código.

Le he entendido bastante bien con tu explicación, muchas gracias!

Me he dado cuenta que estaba enfocando mal el problema ya que pensaba que el programa tenia que resolver la ecuación con solo introducir la estructura de esta, por así decirlo.

Muchas gracias de nuevo, un saludo!

Puff.. eso que dices se puede hacer claro, pero ya es algo bastante más avanzado.
Yo tampoco sabría bien como hacerlo...

Si tienes curiosidad, esta página web sí lo hace.

En su campo de texto escribes la ecuación, usando letras como a, b, c,... y no C2 (ya que pensará que es  c * 2), la analiza y te indica los pasos a seguir para solucionarla.

Bueno, no se si las analiza y resuelve...,  o que tiene pregrabadas las soluciones. En cualquier caso es interesante.

Un saludo.

En el primer codigo, donde creas el panel principal con la toolkit veo una clase Main con el constructor Main(), una clase privada PanelPrincipal y el método main()
Aquí cuando se crea el objeto con new Main() entiendo que se crea "el marco" que es el JFrame y que sería transparente y dentro de este "el lienzo" que seria el JPanel y que sería opaco.

Sí, más o menos esa sería la explicación.
Nuestra clase Main es un JFrame, un "marco". Ahora se requiere de un "contenedor" (clase Container) que será el relleno opaco para el marco.

En este caso (hay otras formas de inicializar la propiedad "contenedor" de un JFrame), establecemos como "contenedor" un objeto que hereda de la clase JPanel, que a su vez es hija (nieta más bien) de la clase Container.
setContentPane(new PanelPrincipal());

Una primera duda es con pack(); si comento esta instrucción la ventana no se despliega sino que aparece minimizada. ¿Por que si ya se ha establecido dimensiones con setPreferredSize?

pack() autocalcula el tamaño del marco para ajustarse a los elementos y/o dimensiones que tenga el "contenedor".
Si no lo invocamos, no se calcula ningún tamaño para el marco y por eso solo aparece la barra de botones de la ventana.
Supongo que al pulsar el botón "maximizar", equivale a llamar a pack() y ahora sí aparece la interfaz.

El preferredSize se lo hemos dado al JPanel que hace de contenedor. Esta dimensión que le damos al JPanel, solo sirve si le pedimos al JFrame que calcule su propio tamaño. Y para eso invocamos a pack().

setLocationRelativeTo(null); creo que posiciona en el centro de la pantalla pero si lo comento me sale igual porque ya estamos ocupando toda la pantalla entonces entiendo que ¿aqui podriamos quitarlo sin perjuicio para el resultado?

Sí, podemos quitarlo.
Lo puse por costumbre, la verdad. Normalmente casi nunca hago ventanas que se ajusten a todo el ancho de pantalla, así que siempre pongo el setLocationRelativeTo().
Esta vez no caí en la cuenta de que no iba a ser necesario.

Otra duda es el por que declarar la clase PanelPrincipal como privada de la clase Main en lugar de hacerlo como clase independiente ¿Cual seria la ventaja?

Bueno, cuando son clases pequeñas que apenas superan las 20 líneas (PanelPrincipal es una decena de líneas) prefiero escribirlas dentro de la clase principal. No vale la pena crear un archivo .java separado para ellas.
Si fueran clases más extensas, con más elementos y funcionalidades que pudieran requerir mucho código, entonces si prefiero escribirlas como clases separadas.

De todos modos, sí tenemos una pequeña ventaja al escribirlas dentro de la clase principal.
Y la ventaja es que de esta manera comparten el mismo ámbito, y además lo comparten con los atributos de la clase Main principal.
Así hay total visibilidad entre ellas y los atributos y pueden combinarse facilmente.

Por ejemplo, fíjate en la clase PanelCampoTexto
Esta clase utiliza el objeto "campoTexto"

   
   private class PanelCampoTexto extends JPanel {
      
      public PanelCampoTexto() {
         campoTexto = new JTextArea();
         campoTexto.setFont(new Font("Verdana", Font.PLAIN, 44));
         setLayout(new GridLayout(1,1));
         JScrollPane scroll = new JScrollPane(campoTexto);
         add(scroll);
      }
   }

Pero este objeto, en realidad es un atributo de la clase Main:

public class Main extends JFrame {
   
   private JTextArea campoTexto;
   private JLabel etMensajes;
   private JButton btProcesar;
   private JButton btBorrar;
   

Como la clase PanelCampoTexto está declarada DENTRO de la clase Main, y lo mismo pasa con el atributo campoTexto, estos dos elementos son visibles entre ellos y por eso la clase PanelCampoTexto puede usarlo sin problemas.

Si esta clase la hubiéramos escrito como una clase separada, entonces estaría FUERA de la clase Main.
Cada clase tendría su propio ámbito individual y entonces PanelCampoTexto no podría usar los atributos de Main, porque no podría verlos.

En ese caso, tendríamos que declarar el JTextArea llamado campoTexto dentro de la clase PanelCampoTexto.
Pero entonces el botón "Borrar" no podría ver ese campo de texto para borrarlo.
Así que además a la clase PanelCampoTexto habría que darle también un método public que se encargue de borrar, método que ya sí podría ver el botón "Borrar" e invocarlo.


O bien, hacer que el  JTextArea de la clase Main llegue hasta la clase individual PanelCampoTexto mediante el constructor, o con un método set, algo como:
public void setCampoTexto(JTextArea campoDelMain) {
    campoTexto = campoDelMain;
}
Como ves, si se escriben por separado ya no comparten ámbito y hay que usar un poco más de código para hacer que las clases y elementos se comuniquen entre ellas.

Así que si son clases pequeñas, no pasa nada por escribirlas juntas dentro de la clase principal, y además se facilitan las cosas al compartir el mismo ámbito.

Pero si fuera un programa más grande y complejo, donde cada panel es tan complicado o más que este programa completo, entonces mejor escribirlas por separado. Aunque luego haya que andar pasando referencias por constructores o por setters para establecer comunicaciones entre las distintas clases.


Sobre esto:
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new Main();
}
});En programas sencillos como este, el 99% de las veces va funcionar igual si simplemente hacemos un new Main()
public static void main(String[] args) {
new Main();
}
Pero en programas Swing que sean un poco más complejos, pueden surgir problemas si no lo hacemos de la otra forma.

Todos los eventos Swing: eventos de ratón, de teclado, repintado de ventanas, etc... son gestionados por un hilo de ejecución (thread) separado que se llama EDT o Event dispatch Thread, o sea, el "despachador de eventos".

El problema es que el "hilo de ejecución principal" digamos que tiene preferencia sobre el EDT, el hilo de Swing.
Entonces, si en un momento dado ejecutamos una tarea que requiere de unos segundos, por ejemplo hacer una consulta a una base de datos que es muy grande, el hilo principal se mantendrá ocupado realizando esta tarea y el EDT no podrá hacer nada. Así que veremos cómo la interfaz se queda congelada durante unos segundos, sin responder ni el teclado, ni el ratón ni cualquier animación en la ventana.

Para evitar esto, con invokeLater() le estamos pidiendo que todos los procesos de la aplicación se ejecuten en el EDT. Así este hilo no se ve supeditado al principal y él solito ya se encarga de repartir los recursos para que los procesos de computación no afecten a los eventos de la interfaz.

Como digo, para programas sencillos nos va a dar igual ponerlo de una forma o de otra.
Pero aún así no está de más acostumbrarnos a ponerlo siempre

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.

Hola Damián, bienvenido al foro.

Sobre este asunto, nada puedo aportar desde el punto de vista profesional porque no soy programador ni nada que se le parezca.
Algo he aprendido de programación por gusto y afición, e intento compartirlo con otros de la forma más sencilla posible.

Pero como no ejerzo profesionalmente, desconozco costes de licencias ni tampoco se cómo enfocan este asunto los profesionales del sector: si pagan religiosamente la licencia, si buscan alternativas "open source", si deciden seguir programando con JDK's antiguos que no están sujetos a ninguna licencia...

Sería interesante que pase por aquí alguien que si ejerza y nos pueda comentar cómo es la situación a este respecto.

He leído este artículo y me ha parecido muy interesante y clarificador.

Oracle impone licencia de pago ha partir de Java 11, pero no a las versiones anteriores, que posiblemente puedan seguir siendo igual de productivas en la mayoría de los casos.

Así mismo, la propia Oracle impulsó la versión libre OpenJDK para ponerla a la altura de la versión de pago, así ningún tipo de programador se verá impedido o perjudicado por este cambio.
El programador freelance, o grupos de pequeña escala y con pocos recursos, pueden recurrir al OpenJDK, siendo gratuito pero sin dispone del soporte de Oracle, aunque podrán apoyarse en la comunidad "open source" y otros medios.

Empresas o programadores de más alto nivel, pueden permitirse pagar los costes de licencia y obtener ventajas como soporte directo por parte de Oracle.


Por otra parte, si aún estás en proceso de aprendizaje, el tema de las licencias de Oracle debería ser la menor de tus preocupaciones.
Tu preocupación ahora debería ser aprender programación y el lenguaje Java. Este aprendizaje no te va a limitar a solo Java, y por tanto, un futuro laboral sujeto a pagar licencias.

Como tú mismo decías, ya vendrán otros lenguajes. Sabiendo Java y programación, ya luego es muy fácil ponerse a dominar otros lenguajes, pues aunque cambie la sintaxis y las instrucciones, la lógica de la programación es común en todos ellos.
Así que llegado el momento, podrás elegir otros lenguajes si realmente las licencias de Oracle resultan un obstáculo (que no lo son, pues ya hemos comentado que hay alternativas)

Un saludo.