Calculadora de notas

Fecha de publicación: 25/05/20

Antes de empezar

Propósito del proyecto

Mostraros un antiguo proyecto que hice en clase programado con java para calcular las notas de los alumnos. Podéis ver el archivo completo en mi github.

Objetivo

El proyecto tenía unos objetivos obligatorios y otras opcionales. Los cuales son:

  • Calcular la nota media de 10 alumnos.
  • Cada alumno se examina de 3 exámenes clásicos y 2 tipo test.
  • El peso de los exámenes cásicos serán de 10%, 20% y 20% para la nota final.
  • El peso de los exámenes tipo test será de 25% cada uno para la nota final.
  • Cada examen tipo test tiene 30 preguntas en las que 3 mal quitan una bien.
  • Se deben de entregar tres trabajos. Si no se entrega alguno la nota final será 3.
  • Si el trabajo se ha entregado tarde se le quitará 0.1 puntos de la nota final por cada día de retraso hasta 5 días por trabajo.
  • Si un trabajo ha tardado más de 5 días en entregarse se contará como no entregado.
  • Debe tener una interfaz gráfica (opcional).

Explicación

Registro de los valores

En este primer bloque del programa veremos las clases que guardan los datos del alumno como son todo lo necesario para calcular las notas como su nombre y apellidos. Todas las clases que vamos a ver en este bloque contienen la siguiente estructura:

  • 3 constructores, uno sin datos de entrada, otro con entrada de todos los valores y el último es un constructor copia.
  • Getter y Setter de todas las variables de clase.
  • Getter de todas las constantes de clase.
  • Métodos necesarios para desarrollar su desempeño.

La primera clase a ver es ExamenClasico.java el cual simplemente tiene dos variables: nota y porcNotaGlobal, las cuales no están iniciadas.

La siguiente clase es ExamenTest.java el cual simplemente tiene dos variables: correctas, falladas, sinContestar, preguntasTotales, nota, porcNotaGlobal, las cuales no están iniciadas. Las tres primeras variables corresponden con las respuestas dadas por el alumno y sumando las tres nos debe de dar el mismo número que preguntasTotales.

Trabajo.java tiene también dos variables únicamente: boolean entregado y diasDeRetraso. En los cuales solo almacenamos si se ha entregado el trabajo y en caso de sea verdadero almacena los días de retraso de la entrega.

La clase NotaTotal.java engloba a las anteriores dos clases. Esta clase es la más compleja de este bloque ya que recoge todos los parámetros de cada alumno y hace los cálculos para la nota final. El programa está pensado para ser rescatable por lo que utilizamos varias constantes para así poder cambiar la cantidad de exámenes que hacemos, la cantidad de preguntas que tienen o el número de trabajos. Las constantes son: NUM_EXAMENES_CLASICOS, NUM_EXAMENES_TEST, NUM_TRABAJOS, NUM_PREGUNTAS_TEST, PORCENTAJE25, PORCENTAJE20, PORCENTAJE10 y MAL_POR_BIEN siendo esta última constante la cantidad de respuestas fallas que quitan una respuesta buena. También dispone de variables las cuales son: ExamenClasico examenClasicoArray[], el cual será tan largo como indique NUM_EXAMENES_CLASICOS, ExamenTest examenTestArray[] el cual será tan laco como indique NUM_EXAMENES_TEST, Trabajo trabajoArray[] el cual será tan laco como indique NUM_TRABAJOS y por último y el más importante notaGlobal el cual almacenará la nota final del alumno. La clase dispone de todos los métodos necesarios para calcular la nota.

					           
//Muestra ejemplo de uno de los métodos que calcula la tona total del alumno.
/**
* Calcula la nota global
* 
* @return  devolverá la nota global
*/
public void calcularNotaGlobal() {
    double notaExamenes;
		
    if(getTrabajosEntregadosATiempo()) {
        notaGlobal = 3;
    } else {
        notaExamenes = calcularNotaTotalExText() + calcularNotaTotalExClasico();
        notaGlobal = notaExamenes - getTotalDiasRetraso() * 0.1;
    }
}
					           
				            

La última clase de este bloque es Persona.java la cual simplemente guarda el nombre y los apellidos del alumno mediante las siguientes variables: nombre, primerApellido y segundoApellido.

Interfaz gráfica

Este bloque se divide en 4 clases las cuales cada una son una ventana independiente del programa. Contiene una ventana de navegación, dos de relleno de datos y una última de visualización de datos.

La ventana de navegación es la clase Menu.java la cual nos servirá para movernos por los diferentes apartados del programa. La cual nos deja crear los datos de un alumno o ver la tabla con todos los alumnos y su nota final. Esta clase tiene una funcionalidad especial y es que el botón de añadir alumno se bloqueará en el caso de que la base de dato le diga que ya hay 10 alumnos creados.

Menú del programa

En el caso de haberle dado al botón añadir alumno de la clase menú accederemos a la clase VentanaNombre.java el cual nos dejará ingresar el nombre completo del alumno y lo enviará a la clase Persona.java para almacenarlos de forma temporal. Antes de continuar hay que decir que todos los campos tienen diversos sistemas de verificación de datos como son: evitar la escritura de caracteres extraños, escritura de números, que el campo esté rellenado con algo que no sea espacios, que no supere los 50 caracteres y que solo haya un espacio entre palabras en caso de ser un nombre compuesto. En esta venta encontramos dos botones de navegación, el primero es volver atrás el cual nos regresará al menú inicial pero antes nos preguntará si queremos descartar los cambios y el segundo botón es siguiente que nos pasará a la siguiente clase y pasandole el nombre completo para después enviarlo.

Ingresar datos del nombre

Esa siguiente clase es VentanaNotas.java el cual contiene todos los campos para rellenar los datos de las notas. La ventana incorpora un orden de tabulación para que siga una estructura lógica. Los sistemas de verificación que tienen estos campos son: que tenga valor, bloqueo de entrada de caracteres que no sean números, que no haya notas negativas, que la suma de correctas, falladas y sin contestar sean igual a la cantidad total de preguntas, que los exámenes clásicos no superen la nota 10 y que los campos de exámenes tipo test y los días de retraso de los trabajos no acepten números decimales. En esta ventana también tenemos dos botones de navegación, el botón atrás nos devolverá a la ventana de ingresar el nombre de la persona en el que observaremos que los campos ya tienen sus respectivos valores por lo que solo modificaremos lo que necesitemos y que si volvemos a la ventana nota también estarán los valores rellenados para no perder los datos que ya hubiésemos escrito. El segundo botón es el de finalizar con el que calcularemos la nota final y enviaremos una sentencia sql a la base de datos del alumno.

ingresar todos los datos para las notas

La clase VentanaTabla.java nos mostrará el listado de alumnos con su nota final. Si queremos borrar algún alumno solo tenemos que presionar sobre él y darle al motón borrar el cual nos preguntará si de verdad queremos borrarlo. En el caso de borrarlo la venta se reinicia para mostrar los nuevos valores.

ver todos los alumnos con su nota final

Assets

En este bloque veremos clases bastante variadas que sirven para cumplimentar las funciones de nuestro programa. Vamos a verlos.

La más importante es MySQL.java la cual conecta el programa con nuestra base de datos. Tienes todos los datos para acceder a una base de datos que hemos creado para este programa. Puede hacer varias consultas las cuales están todas preparadas cada una en un método para que su uso sea bastante sencillo. En método más importante, después del que conecta a la base de datos, es el que inserta los valores del alumno a la DB el cual se ve así:

					           
/**
     * Inserta los valores pasados a la tabla Alumnos de la DB NotasEntornos
     * 
     * Comando ejemplo:  INSERT INTO Alumnos (nombre, primerApellido, segundoApellido, notaFinal)
     * 		VALUES ("Peter", "rock", "bless", 8.40);
     * 
     * @param  persona Objeto de tipo persona para pasarle los datos de esta clase
     * @param  notaTotal Objeto de tipo NotaTotal para obtener la nota
     */
    public void insertarDatos(Persona persona, NotaTotal notaTotal) {       
    	MySQLConnection();
    	
        try {
        	
            String Query = "INSERT INTO Alumnos (nombre, primerApellido, "
            		+ "segundoApellido, notaFinal) VALUES ("
                    + "\"" + persona.getNombre() + "\", "
                    + "\"" + persona.getPrimerApellido() + "\", "
                    + "\"" + persona.getSegundoApellido() + "\","
                    + notaTotal.getNotaGlobal() + ");";
            
            System.out.println(Query);
            //lanzamos el comando al servidor
            Statement st = conexion.createStatement();
            st.executeUpdate(Query);
            
            mensaje.envioCorrecto();
            
        } catch (SQLException ex) {
        	
        	mensaje.envioIncorrecto();
        }
        closeConnection();
    }
					           
				            

Tenemos en el programa el VerificacionDeDatos.java el cual verifica todos los datos de entrada del usuario para asegurarnos de no generar errores en el programa. Todos los métodos son boolean y creados por mí mismo, además de ser reutilizables en otros programas. Mostraré el ejemplo de una cadena de caracteres correcta en español. El método lo que hace es pasar a mayúsculas la cadena de caracteres que le pasamos para tener verificar solo la mitad y después mira carácter por carácter si coincide con alguno de los estipulado en caso de que no coincida devolverá true indicando que hay un error de lectura.

					           
/**
     * Evita que se le introduzcan carácteres extraños.
     * Sólo permite la entrada de caracteres anglosajones y acentos.
     * 
     * @param  cadena Entrada de un String.
     * @return  devolverá falso en el caso de que solo haya caracteres anglosajones y acentos.
     */
    public boolean correctoString(String cadena) {
        for (int i = 0; i < cadena.length(); i++){
            char caracter = cadena.toUpperCase().charAt(i);
            int valorASCII = (int)caracter;
            if (valorASCII != 32 //espacio en blanco
                    && valorASCII != 209 //caracter Ñ
                    && valorASCII != 193 //caracter Á
                    && valorASCII != 201 //caracter É
                    && valorASCII != 205 //caracter Í
                    && valorASCII != 211 //caracter Ó
                    && valorASCII != 218 //caracter Ú
                    && valorASCII != 220 //caracter Ü
                    &&(valorASCII < 65 || valorASCII > 90))	//mayusculas normales
            	return true; //Se ha encontrado un caracter que no es letra
        } 
        return false;	//Todo correcto
    }
					           
				            

Terminamos el bloque y el programa en sí con la clase menos importante de todas SeleccionadorCompleto.java el cual cuando clicas en un campo o tabulas se selecciona el campo entero para borrarlo.

Base de datos

La base de datos de este programa es la más sencilla que he creado, pero viento que para los objetivos del proyecto no era necesario crearla pues tampoco quería sumarle relevancia.

La tabla debe de cumplir con unas condiciones muy simples:

  • Todos los campos son obligatorios excepto Segundo apellido
  • La nota solo puede tener un decimal

Para esta más que sentencia lista nos queda este más que sencillo código sql para terminar con el programa al completo:

					           
CREATE TABLE `Alumnos` ( 
`id` INT NOT NULL AUTO_INCREMENT, 
`Nombre` VARCHAR(50) NULL, 
`Primer Apellido` VARCHAR(50) NULL, 
`Aegundo Apellido` VARCHAR(50) NOT NULL
) ENGINE = InnoDB;
					           
				            

Conclusión

Es un programa dentro de lo que cabe bastante sencillo que tiene como punto más débil la construcción de la interfaz gráfica debido a que tenemos que crear a mano cada campo en caso de que la cantidad de exámenes sea diferente a los estipulados en el ejercicio inicial. Pero que tiene como punto más fuerte la integridad del propio programa a la hora de resolveré errores.

En este caso no habrá próximas revisiones del proyecto. Puede que haga más programas como este, pero construido de cero.