Java programa registro de estudiantes nombre carnet (ID) y notas promediadas

[luis171999]

No soy muy ágil programando y me he quedado estancado en esta parte.
El programa trata de un registro de estudiantes los cuales tiene un nombre, un carnet (ID) y cuatro notas las cuales tienen que ser promediadas.
El problema está en la parte de modificar, solo me modifica la primera linea de los arreglos, no sé cómo definir qué línea modificar

Código de la clase Arreglo:

Código: [Seleccionar]

package arreglo;

import java.util.Scanner;
import javax.swing.JOptionPane;
public class Arreglo {
   
   //Crear y establecer tamaño de los Arreglos de manera global para que
   //funcione en los demas metodos:
   
    public static int tamaño;
     private static String carnet[];
     private static String nombres[];
     private static int calific[];
     private static int calific2[];
     private static int calific3[];
     private static int calific4[];
            public static int suma = 0;
            public static int promedio = 0;
public static void main(String[] args) {             
            menu();
    }

        public static void menu(){       
        Scanner texto = new Scanner(System.in);
            String opcion;
            do {               
            opcion =JOptionPane.showInputDialog("------------REGISTRO DE ESTUDIANTES------------"
+ " \n1. INGRESAR ESTUDIANTES\n2. MODIFICAR NOTA\n3. ELIMINAR ESTUDIANTE\n4. LISTAR ESTUDIANTES\ns. Salir"
+ "\n------------------------------------------------\nINGRESE LA OPCION [1 - 4]: ");
           
            switch (opcion) {                case "1":
agregar();

break;
 case "2":
modificar();
break;

 case "3":
                 
buscar();
break;

 case "4":
listar();

break;
                case "s":

System.exit(0);

break;
                default:
break;
            }
        } while (true);
        }
       
        public static void agregar(){
            //Pedir tamaño del Arreglo al usuario:
     tamaño=Integer.parseInt(JOptionPane.showInputDialog
                ("¿De que tamaño desea su Arreglo?"));
       //recibe los arreglos globalizados arriba
      nombres = new String[tamaño];
      carnet = new String[tamaño];
      calific = new int[tamaño];
      calific2 = new int[tamaño];
      calific3 = new int[tamaño];
      calific4 = new int[tamaño];
     
       //Insertar carnet de alumnos al Arreglo String
      for(int contador=0; contador < carnet.length; contador++)
            carnet[contador]=JOptionPane.showInputDialog
("Carnet del alumno");
      //Insertar nombres de alumnos al Arreglo String:
      for(int contador=0; contador < nombres.length; contador++)
            nombres[contador]=JOptionPane.showInputDialog
("Nombre?");
       
      //Insertar calificaciones de cada alumno al Arreglo int:
      for(int contador=0; contador < calific.length; contador++)
            calific[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 1 de "
+nombres[contador]+"?"));
     
      for(int contador=0; contador < calific2.length; contador++)
            calific2[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 2 de "
+nombres[contador]+"?"));
     
      for(int contador=0; contador < calific3.length; contador++)
            calific3[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 3 de "
+nombres[contador]+"?"));
     
      for(int contador=0; contador < calific4.length; contador++)
            calific4[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 4 de "
+nombres[contador]+"?"));
     
      //Sumar notas
      for (int i = 0; i<calific.length; i++){
          for (int j = 0; j<calific2.length; j++){
              for (int k = 0; k<calific3.length; k++){
                  for (int f = 0; f<calific4.length; f++){
 
  suma = calific[i] + calific2[j] + calific3[k] + calific4[f];
  promedio = suma/4;
                 
              }
          }
     
      }
         
    }
       
      //Mostrar alumno y su calificacion en pantalla:
      System.out.println("Numero\tCarnet\tNombre\tpromedio");
      for(int contador=0; contador < nombres.length; contador++)
            System.out.println(contador+1+"\t" + carnet[contador]+"\t"+nombres[contador]+"\t"
+promedio);
     
      menu();
     
        }
        public static void buscar(){           
         menu();   
           
 }
       
         public static void modificar(){
             boolean elCarnetEsta = false;
             
             String car;
            car=JOptionPane.showInputDialog("INGRESA EL CARNET DEL ALUMNO");
             
             for(int contador=0; contador < carnet.length; contador++)
                 if (car.equals(carnet[contador])){
 elCarnetEsta = true;
          int seleccion;
          int nueva = 0;
            seleccion =Integer.parseInt(JOptionPane.showInputDialog("QUE NOTA DESEAS CAMBIAR: \n1.\n2.\n3.\n4."));
       
          if(seleccion==1){           
            calific[nueva] =Integer.parseInt(JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
           
        }
       
        else if(seleccion==2){           
            calific2[nueva] =Integer.parseInt(JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
           
        }
       
        else if(seleccion==3){           
            calific3[nueva] =Integer.parseInt(JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
           
        }
       
        else if(seleccion==4){           
            calific4[nueva] =Integer.parseInt(JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
               
        }
       
                 }
             
              if(elCarnetEsta ==false) {
            JOptionPane.showMessageDialog(null, "EL CARNET NO EXISTE");
        }
             
              menu();
        }
        public static void listar(){           
            //Mostrar alumno y su calificacion en pantalla:
      System.out.println("Numero\tCarnet\tNombre\tnota1\tnota2\tnota3\tnota4");
      for(int contador=0; contador < nombres.length; contador++)
            System.out.println(contador+1+"\t" + carnet[contador]+"\t"+nombres[contador]+"\t"
+calific[contador]+"\t"+calific2[contador]+"\t"+calific3[contador]+"\t"+calific4[contador]);
     
      menu();
        }
   
    public static void eliminar(){             
              menu();
    }

}

[Kabuto]

¿Puedes publicar el enunciado original del ejercicio?
Tengo dudas de si la primera opción, la de "agregar estudiantes", se ha de hacer como lo has hecho tú, donde se registran TODOS los estudiantes...
o en cambio, dicha opción debería permitir ingresar estudiantes de uno en uno, con lo cuál el tamaño de los arrays debería decidirse previamente y no alterarse durante el transcurso del programa.

También sería interesante saber si para las calificaciones se puede usar una matriz (un array de dos dimensiones) o hay que usar cuatro arrays separados.

De momento, vamos a suponer que hay que hacerlo como tú lo has hecho.

Todos los estudiantes se registran al mismo tiempo.
Bien, esta parte del registro, se puede mejorar.
Por ejemplo, no necesitas crear un bucle para rellenar cada array.

Código: [Seleccionar]

//Insertar carnet de alumnos al Arreglo String
for(int contador=0; contador < carnet.length; contador++)
carnet[contador]=JOptionPane.showInputDialog
("Carnet del alumno");

//Insertar nombres de alumnos al Arreglo String:
for(int contador=0; contador < nombres.length; contador++)
nombres[contador]=JOptionPane.showInputDialog
("Nombre?");

//Insertar calificaciones de cada alumno al Arreglo int:
for(int contador=0; contador < calific.length; contador++)
calific[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 1 de "
+nombres[contador]+"?"));
for(int contador=0; contador < calific2.length; contador++)
calific2[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 2 de "
+nombres[contador]+"?"));

for(int contador=0; contador < calific3.length; contador++)
calific3[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 3 de "
+nombres[contador]+"?"));

for(int contador=0; contador < calific4.length; contador++)
calific4[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 4 de "
+nombres[contador]+"?"));
Se puede crear uno solo y que vaya pidiendo los datos correspondientes a cada array:

Código: [Seleccionar]

//Pedimos datos
for (int contador = 0; contador < tamaño; contador++) {
//Carnet
carnet[contador]=JOptionPane.showInputDialog
("Carnet del alumno");
//Nombre
nombres[contador]=JOptionPane.showInputDialog
("Nombre?");
//Calificaciones
calific[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 1 de "
+nombres[contador]+"?"));
calific2[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 2 de "
+nombres[contador]+"?"));
calific3[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 3 de "
+nombres[contador]+"?"));
calific4[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 4 de "
+nombres[contador]+"?"));
}
Respecto a calcular el promedio, de nuevo sería interesante disponer del enunciador original, pero seguramente lo que se ha de promediar son las 4 notas de cada alumno.
Es decir, por cada alumno, calcular el promedio de sus 4 notas.

Pero no sumar TODAS las notas y de ahí sacar un promedio.
De hecho, lo que tú has programado con esos bucles anidados, supone una barbaridad de iteraciones innecesarias:

Código: [Seleccionar]

//Sumar notas
for (int i = 0; i<calific.length; i++){
for (int j = 0; j<calific2.length; j++){
for (int k = 0; k<calific3.length; k++){
for (int f = 0; f<calific4.length; f++){

suma = calific[i] + calific2[j] + calific3[k] + calific4[f];
promedio = suma/4;

}


}

}

}Supón que los arrays tienen 10 elementos, porque se ha elegido introducir a 10 alumnos.
Si anidas los bucles, lo que haces es que el primer bucle va a repetir 10 veces, las 10 iteraciones del segundo bucle, quien a su vez repite 10 veces las del tercer bucle, quien a su vez repite las 10 del cuarto bucle...
10x10x10x10 = 10.000 iteraciones
Es decir, estás haciendo que estos cálculos se repitan diez mil veces:

Código: [Seleccionar]

suma = calific[i] + calific2[j] + calific3[k] + calific4[f];
promedio = suma/4;Y en cada repetición se están mezclando distintas notas, de distintos alumnos... así que ninguna de esas diez mil repeticiones nos va a dar el resultado que realmente necesitamos.

Si por cada alumno, vamos a necesitar un promedio de sus 4 notas, entonces va a ser conveniente tener otro array más destinado a guardar esos promedios.

Los promedios habrá que mostrarlos cuando se elija la opción de Listar Estudiantes, así que en realidad no sería estrictamente necesario tener los promedios guardados en un arreglo. Se podría hacer el cálculo "al vuelo" al mismo tiempo que se va listando cada Estudiante y mostrarlo directamente en pantalla.

Pero usar un arreglo específico para los promedios puede servir para organizar mejor las ideas, para que quede más clara la información que se está manejando en el programa.
Y además añade una dificultad extra: cuando se modifique la nota de un estudiante, entonces habrá que recalcular de nuevo el promedio.

Así que propongo añadir un nuevo arreglo para los promedios:

public class Arreglo {

   //Crear y establecer tamaño de los Arreglos de manera global para que
   //funcione en los demas metodos:

   public static int tamaño;

   private static String carnet[];
   private static String nombres[];
   private static int calific[];
   private static int calific2[];
   private static int calific3[];
   private static int calific4[];
   private static int promedios[];

   public static void agregar(){

      //Pedir tamaño del Arreglo al usuario:
      tamaño=Integer.parseInt(JOptionPane.showInputDialog
            ("¿De que tamaño desea su Arreglo?"));

      //recibe los arreglos globalizados arriba
      nombres = new String[tamaño];
      carnet = new String[tamaño];
      calific = new int[tamaño];
      calific2 = new int[tamaño];
      calific3 = new int[tamaño];
      calific4 = new int[tamaño];
      promedios = new int[tamaño];

Y cuando el usuario ha dado las 4 notas del Estudiante que está introduciendo, calculamos el promedio:

      //Pedimos datos
      for (int contador = 0; contador < tamaño; contador++) {
         //Carnet
         carnet[contador]=JOptionPane.showInputDialog
               ("Carnet del alumno");
         //Nombre
         nombres[contador]=JOptionPane.showInputDialog
               ("Nombre?");
         //Calificaciones
         calific[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 1 de "
                           +nombres[contador]+"?"));
         calific2[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 2 de "
                           +nombres[contador]+"?"));
         calific3[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 3 de "
                           +nombres[contador]+"?"));
         calific4[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 4 de "
                           +nombres[contador]+"?"));
         //Calculamos promedio
         promedios[contador] = (calific[contador] + calific2[contador] +
               calific3[contador] + calific4[contador]) / 4;
      }

Bien, con esto lo de Agregar Estudiantes, podría quedar terminado de este modo.
Lo de listar los alumnos al terminar no lo he puesto, ya que para eso hay una opción específica en el menú, pero bueno, se puede dejar si quieres:

Código: [Seleccionar]

public static void agregar(){

//Pedir tamaño del Arreglo al usuario:
tamaño=Integer.parseInt(JOptionPane.showInputDialog
("¿De que tamaño desea su Arreglo?"));

//recibe los arreglos globalizados arriba
nombres = new String[tamaño];
carnet = new String[tamaño];
calific = new int[tamaño];
calific2 = new int[tamaño];
calific3 = new int[tamaño];
calific4 = new int[tamaño];
promedios = new int[tamaño];

//Pedimos datos
for (int contador = 0; contador < tamaño; contador++) {
//Carnet
carnet[contador]=JOptionPane.showInputDialog
("Carnet del alumno");
//Nombre
nombres[contador]=JOptionPane.showInputDialog
("Nombre?");
//Calificaciones
calific[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 1 de "
+nombres[contador]+"?"));
calific2[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 2 de "
+nombres[contador]+"?"));
calific3[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 3 de "
+nombres[contador]+"?"));
calific4[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 4 de "
+nombres[contador]+"?"));
//Calculamos promedio
promedios[contador] = (calific[contador] + calific2[contador] +
calific3[contador] + calific4[contador]) / 4;
}
}
En el siguiente post vamos a ver lo de Modificar Nota

[Kabuto]

Lo de modificar nota te falla porque, a pesar de que buscas el carnet de alumno, no estás recuperando en que posición se encuentra ese carnet.
Usas una variable llamada "nueva" inicializada a 0 para elegir las calificaciones que vas a alterar, por eso siempre te va a modificar la primera línea de los arreglos.
Te señalo en rojo donde está el problema:

   public static void modificar(){
      boolean elCarnetEsta = false;

      String car = JOptionPane.showInputDialog("INGRESA EL CARNET DEL ALUMNO");

      for(int contador=0; contador < tamaño; contador++)
         if (car.equals(carnet[contador])){
            elCarnetEsta = true;

            int seleccion;
            int nueva = 0;
            seleccion =Integer.parseInt(JOptionPane.showInputDialog("QUE NOTA DESEAS CAMBIAR: \n1.\n2.\n3.\n4."));

            if(seleccion==1){

               calific[nueva] =Integer.parseInt(JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));

            }

            else if(seleccion==2){

               calific2[nueva] =Integer.parseInt(JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));

            }

            else if(seleccion==3){

               calific3[nueva] =Integer.parseInt(JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));

            }

            else if(seleccion==4){

               calific4[nueva] =Integer.parseInt(JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));

            }

         }

      if(elCarnetEsta == false) {
         JOptionPane.showMessageDialog(null, "EL CARNET NO EXISTE");
      }

   }

No hay que usar esa variable, basta con usar la variable "contador" del mismo bucle donde estamos buscando el carnet.
Además esa misma variable nos sirve para recalcular el promedio:

   public static void modificar(){
      boolean elCarnetEsta = false;

      String car = JOptionPane.showInputDialog("INGRESA EL CARNET DEL ALUMNO");

      for(int contador=0; contador < tamaño; contador++)
         if (car.equals(carnet[contador])){
            elCarnetEsta = true;
            
            int seleccion = Integer.parseInt(
                  JOptionPane.showInputDialog("QUE NOTA DESEAS CAMBIAR: \n1.\n2.\n3.\n4."));

            if(seleccion==1)
               calific[contador] = Integer.parseInt(
                     JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
            else if(seleccion==2)
               calific2[contador] = Integer.parseInt(
                     JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
            else if(seleccion==3)
               calific3[contador] = Integer.parseInt(
                     JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
            else if(seleccion==4)
               calific4[contador] = Integer.parseInt(
                     JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
            
            //Nota cambiada, hay que recalcular el promedio
            promedios[contador] = (calific[contador] + calific2[contador] +
                  calific3[contador] + calific4[contador]) / 4;

            //Ya hemos encontrado alumno y cambiado su nota, podemos interrumpir este bucle
            break;
         }

      if(elCarnetEsta == false) {
         JOptionPane.showMessageDialog(null, "EL CARNET NO EXISTE");
      }

   }

Con esto ya se puede Agregar Estudiante y Modificar Nota.
Lo de Listar Estudiante habría que hacer un pequeño cambio para mostrar el promedio:

   public static void listar(){

      //Mostrar alumno y su calificacion en pantalla:
      System.out.println("Numero\tCarnet\tNombre\tnota1\tnota2\tnota3\tnota4\tPromedio");
      for(int contador=0; contador < nombres.length; contador++)
         System.out.println(contador+1+"\t" + carnet[contador]+"\t"+nombres[contador]+"\t"
               +calific[contador]+"\t"+calific2[contador]+"\t"+calific3[contador]+
               "\t"+calific4[contador]+"\t"+promedios[contador]);
   }

Bien, ya solo te queda hacer lo de Eliminar Estudiante, inténtalo y lo consigas o no, compártelo por aquí y te ayudamos a corregirlo.

Antes de terminar, quiero comentar un par de cosas.

En cada método, al terminar, haces una llamada al método menu(), que es el menu principal que muestra las opciones.
Esto no es necesario, es más, es peligroso...y ahora verás por qué..

Cuando el programa se inicia, comienza el método main() que llama a menu() y lo pone en marcha.
main() no hace nada, ahora mismo es menu() quien se encarga de todo
main() > menu()

Si dentro de menu(), llamamos por ejemplo a agregar(), esto no significa que el método menu() termine. Sigue ejecutándose, lo que ocurre es que queda a espera de que agregar() haga sus cosas y termine.
Ahora, es agregar() quien está al cargo de la ejecución del programa:
main() > menu() > agregar()

El método agregar() lo que hace es iniciar un bucle y pedir datos al usuario.
Si nos fijamos en cómo he escrito yo su código:

   public static void agregar(){

      //Pedir tamaño del Arreglo al usuario:
      tamaño=Integer.parseInt(JOptionPane.showInputDialog
            ("¿De que tamaño desea su Arreglo?"));

      //recibe los arreglos globalizados arriba
      nombres = new String[tamaño];
      carnet = new String[tamaño];
      calific = new int[tamaño];
      calific2 = new int[tamaño];
      calific3 = new int[tamaño];
      calific4 = new int[tamaño];
      promedios = new int[tamaño];
      
      //Pedimos datos
      for (int contador = 0; contador < tamaño; contador++) {
         //Carnet
         carnet[contador]=JOptionPane.showInputDialog
               ("Carnet del alumno");
         //Nombre
         nombres[contador]=JOptionPane.showInputDialog
               ("Nombre?");
         //Calificaciones
         calific[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 1 de "
                           +nombres[contador]+"?"));
         calific2[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 2 de "
                           +nombres[contador]+"?"));
         calific3[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 3 de "
                           +nombres[contador]+"?"));
         calific4[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 4 de "
                           +nombres[contador]+"?"));
         //Calculamos promedio
         promedios[contador] = (calific[contador] + calific2[contador] +
               calific3[contador] + calific4[contador]) / 4;
      }
      //Fin del bucle que pide datos
   }

Cuando este bucle termina, ahí donde he puesto el comentario azul, agregar() ya no tiene nada más que hacer, así que este método termina y devuelve el hilo de ejecución al método menu()
main() > menu()
Esto es lo ideal, ahora menu() puede volver llamar a agregar(), o a listar().., o terminar si el usuario lo ordena y fin del progama.

Pero, ¿y si hacemos lo que tú has hecho, llamar a menu() al terminar el método:

   public static void agregar(){

      //Pedir tamaño del Arreglo al usuario:
      tamaño=Integer.parseInt(JOptionPane.showInputDialog
            ("¿De que tamaño desea su Arreglo?"));

      //recibe los arreglos globalizados arriba
      nombres = new String[tamaño];
      carnet = new String[tamaño];
      calific = new int[tamaño];
      calific2 = new int[tamaño];
      calific3 = new int[tamaño];
      calific4 = new int[tamaño];
      promedios = new int[tamaño];
      
      //Pedimos datos
      for (int contador = 0; contador < tamaño; contador++) {
         //Carnet
         carnet[contador]=JOptionPane.showInputDialog
               ("Carnet del alumno");
         //Nombre
         nombres[contador]=JOptionPane.showInputDialog
               ("Nombre?");
         //Calificaciones
         calific[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 1 de "
                           +nombres[contador]+"?"));
         calific2[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 2 de "
                           +nombres[contador]+"?"));
         calific3[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 3 de "
                           +nombres[contador]+"?"));
         calific4[contador]=Integer.parseInt
               (JOptionPane.showInputDialog
                     ("Cual es la nota 4 de "
                           +nombres[contador]+"?"));
         //Calculamos promedio
         promedios[contador] = (calific[contador] + calific2[contador] +
               calific3[contador] + calific4[contador]) / 4;
      }
      //Fin del bucle que pide datos
      menu(); //Llamamos a menu()
   }

Esta llamada, implica que el método agregar() NO TERMINA.
Lo que hace es generar una nueva instancia de menu(), pero no el mismo menu() que le había llamado a él, este es "otro" menu() distinto:

main() > menu() > agregar() > menu()

Y si este nuevo menu(), llama ahora a listar()...

main() > menu() > agregar() > menu() > listar()

Y como listar(), en tu código, cuando termina también llama a menu(), pues...
main() > menu() > agregar() > menu() > listar() > menu()

¿Ves lo que ocurre?
Los métodos no finalizan, porque se están produciendo unas llamadas "recursivas" que hacen que el hilo de ejecución se vaya pasando de un método a otro, pero sin que ninguno termine...los métodos se van anidando unos dentro de otros.

¿Esto es un problema?
Pues sí. Es cierto que en este caso, al ser un ejercicio sencillo, no notamos nada raro a nivel usuario.
Pero en un programa más complejo, podríamos encontrarnos con que unos datos que yo he introducido, luego se viesen alterados por un método que había quedado anidado anteriormente.
Y además, cada método anidado se almacena en una "pila", y esta pila tiene un límite. El límite es bastante amplio, pero si esto ocurre en un programa profesional de una empresa que tiene el ordenador funcionando 24 horas al día, tarde o temprano la pila se desbordaría y el programa caería.


Por eso los métodos de este programa, no deben terminar llamando de nuevo a menu().
No es necesario, cuando los métodos terminen sus tareas, menu() recuperará automáticamente el hilo de ejecución.

Por último te dejo mi código al completo tal y como lo tengo ahora.
He quitado algunas cosas como el objeto Scanner que no va a ser necesario, o un método llamado buscar() que habías puesto vacío, que tampoco parece que vaya a tener función alguna.
Un saludo.

Código: [Seleccionar]

import javax.swing.JOptionPane;


public class Arreglo {

//Crear y establecer tamaño de los Arreglos de manera global para que
//funcione en los demas metodos:

public static int tamaño;

private static String carnet[];
private static String nombres[];
private static int calific[];
private static int calific2[];
private static int calific3[];
private static int calific4[];
private static int promedios[];


public static void main(String[] args) {
menu();
}

public static void menu(){
String opcion;

do {

opcion =JOptionPane.showInputDialog("------------REGISTRO DE ESTUDIANTES------------"
+ " \n1. INGRESAR ESTUDIANTES\n2. MODIFICAR NOTA\n3. ELIMINAR ESTUDIANTE\n4. LISTAR ESTUDIANTES\ns. Salir"
+ "\n------------------------------------------------\nINGRESE LA OPCION [1 - 4]: ");

switch (opcion) {
case "1":
agregar();
break;
case "2":
modificar();
break;
case "3":
eliminar();
break;
case "4":
listar();
break;
case "s":
System.exit(0);
break;
default:
break;
}
} while (true);

}

public static void agregar(){

//Pedir tamaño del Arreglo al usuario:
tamaño=Integer.parseInt(JOptionPane.showInputDialog
("¿De que tamaño desea su Arreglo?"));

//recibe los arreglos globalizados arriba
nombres = new String[tamaño];
carnet = new String[tamaño];
calific = new int[tamaño];
calific2 = new int[tamaño];
calific3 = new int[tamaño];
calific4 = new int[tamaño];
promedios = new int[tamaño];

//Pedimos datos
for (int contador = 0; contador < tamaño; contador++) {
//Carnet
carnet[contador]=JOptionPane.showInputDialog
("Carnet del alumno");
//Nombre
nombres[contador]=JOptionPane.showInputDialog
("Nombre?");
//Calificaciones
calific[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 1 de "
+nombres[contador]+"?"));
calific2[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 2 de "
+nombres[contador]+"?"));
calific3[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 3 de "
+nombres[contador]+"?"));
calific4[contador]=Integer.parseInt
(JOptionPane.showInputDialog
("Cual es la nota 4 de "
+nombres[contador]+"?"));
//Calculamos promedio
promedios[contador] = (calific[contador] + calific2[contador] +
calific3[contador] + calific4[contador]) / 4;
}
//Fin del bucle que pide datos
}

public static void modificar(){
boolean elCarnetEsta = false;

String car = JOptionPane.showInputDialog("INGRESA EL CARNET DEL ALUMNO");

for(int contador=0; contador < tamaño; contador++)
if (car.equals(carnet[contador])){
elCarnetEsta = true;

int seleccion = Integer.parseInt(
JOptionPane.showInputDialog("QUE NOTA DESEAS CAMBIAR: \n1.\n2.\n3.\n4."));

if(seleccion==1)
calific[contador] = Integer.parseInt(
JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
else if(seleccion==2)
calific2[contador] = Integer.parseInt(
JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
else if(seleccion==3)
calific3[contador] = Integer.parseInt(
JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));
else if(seleccion==4)
calific4[contador] = Integer.parseInt(
JOptionPane.showInputDialog("NUEVA NOTA ["+seleccion+"]"));

//Nota cambiada, hay que recalcular el promedio
promedios[contador] = (calific[contador] + calific2[contador] +
calific3[contador] + calific4[contador]) / 4;

//Alumno encontrado y cambiado su nota y promedio, podemos interrumpir este bucle
break;
}

if(elCarnetEsta == false) {
JOptionPane.showMessageDialog(null, "EL CARNET NO EXISTE");
}

}

public static void listar(){

//Mostrar alumno y su calificacion en pantalla:
System.out.println("Numero\tCarnet\tNombre\tnota1\tnota2\tnota3\tnota4\tPromedio");
for(int contador=0; contador < nombres.length; contador++)
System.out.println(contador+1+"\t" + carnet[contador]+"\t"+nombres[contador]+"\t"
+calific[contador]+"\t"+calific2[contador]+"\t"+calific3[contador]+
"\t"+calific4[contador]+"\t"+promedios[contador]);
}

public static void eliminar(){

}

}