¡Buen día, coders! En esta oportunidad vamos a resolver una evaluación continua que nos envió un seguidor de la página. Consta de 2 partes, una parte teórica y otra práctica. Les dejaré la solución a este examen y cualquier duda que tengan en la sección de comentarios.
PRIMERA EVALUACIÓN CONTINUA
Parte 1: Teoría
1. Indicar el motivo por el cual la siguiente clase no compilará:
import java.io.*;
public class Pregunta1 {
public void limitador (String s) {
if (s.length() > 10) {
throw new
IOException();
}
}
}
Respuesta:
No compilará porque el tipo de excepción IOException no está controlada.
public void limitador (String s) throws IOException {
if (s.length() > 10) {
throw new
IOException();
}
}
2. Una de las siguientes afirmaciones sobre la utilización de finally es incorrecta. Indicar ¿cuál y por qué?
· Si se produce una excepción en try y ningún bloque catch la captura, las instrucciones definidas en finally no se ejecutarán (F)
· Si no se ha definido ningún catch para el try, la
utilización de finally se hace obligatoria. (V)
· Aunque no se produzca la excepción en try, el bloque finally se ejecutará. (V)
· No es posible definir dos bloques finally para un mismo try. (V)
Respuesta: La primera opción es falsa. Un bloque FINALLY encierra código que siempre es ejecutado después del bloque TRY, sea que se produzca o no una excepción. La cláusula FINALLY no es obligatoria. Por otro lado, dado que el compilador no requiere una cláusula CATCH, podemos tener código con un bloque TRY seguido inmediatamente por un bloque FINALLY.
3. ¿Por qué es inapropiado el uso del assert en el siguiente contexto?
public class Pregunta3 {
int x = -1;
public static void main(String[] args) {
assert(x++ > 0);
}
}
Respuesta: Es inapropiado decir que la prueba es verdadera ya que la variable x primeramente no es estática static int x = -1. Por lo tanto, al probar la aplicación, la asunción fallará ya que la prueba es falsa. Lanzará un AssertionError.
4. Si queremos definir tres catch para controlar las excepciones RuntimeExcepcion, NumberFormatException y Exception. ¿Cuál debe ser el orden de colocación de estos? ¿Por qué?
Respuesta: La jerarquía de excepciones nos dice que primero debemos especificar las subclases y al final la superclase. Por lo tanto, el orden debería ser: NumberFormatException, RuntimeExcepcion y al final, Exception.
Parte 2: Práctica
Problema 1. Manejo de Excepciones
Este problema trata de la utilización de las capturas de error mediante las
sentencias ty..catch..finally
Se tiene los siguientes datos (nombre, notas (4) y promedio) para el
control de estudiantes de un aula. El profesor ingresará el nombre del
alumno, la cantidad de notas a evaluar y las notas correspondientes. En caso
de no ocurrir ningún problema se mostrará el promedio.
Se debe mostrar al usuario los avisos correspondientes a posibles errores
como: números mal ingresados o la cantidad de notas no es la adecuada, entre
otras a su criterio.
La aplicación debe continuar ingresando alumnos hasta indicar lo contrario.
Teniendo en cuenta que la cantidad de alumnos es 21 como máximo.
Solución:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
package parte2; import javax.swing.JOptionPane; public class Problema1 { public static void main(String[] args) { // Declaración de variables String nombre; int cant, nota1 = 0, nota2 = 0, nota3 = 0, nota4 = 0, cont=0; double promedio = 0; boolean OK = false; do { try { // Entrada de datos nombre = JOptionPane.showInputDialog( "Programa para saber el promedio de notas\n" + "Ingrese nombre"); cant = Integer.parseInt(JOptionPane .showInputDialog("Ingrese cantidad de notas")); // Validar el nombre ingresado if (nombre.isEmpty()) { JOptionPane.showMessageDialog(null, "Ingrese un nombre", "¡Oops!", JOptionPane.ERROR_MESSAGE); } else { // Validar la cantidad de notas ingresada if (cant == 4) { try { // Entrada de datos nota1 = ingresarNota("1"); nota2 = ingresarNota("2"); nota3 = ingresarNota("3"); nota4 = ingresarNota("4"); OK = true; } catch (NumberFormatException nfe) { JOptionPane.showMessageDialog(null, "Solo se admiten números", "¡Oops!", JOptionPane.ERROR_MESSAGE); } catch (Exception ex) { JOptionPane.showMessageDialog(null, ex.getMessage(), "¡Oops!", JOptionPane.ERROR_MESSAGE); } finally { if (OK) { promedio = (nota1 + nota2 + nota3 + nota4) / 4; JOptionPane.showMessageDialog(null, "Nombre: " + nombre + "\nEl promedio es: " + promedio); cont++; } } } else { JOptionPane.showMessageDialog(null, "Solo 4 notas.", "¡Oops!", JOptionPane.ERROR_MESSAGE); } } } catch (Exception e) { JOptionPane.showMessageDialog(null, "Solo se admiten números", "¡Oops!", JOptionPane.ERROR_MESSAGE); } // Validar el máximo de alumnos if (cont == 21) { JOptionPane.showMessageDialog(null, "Ya no se puede agregar más alumnos", "¡Oops!", JOptionPane.ERROR_MESSAGE); break; // termino el ciclo } } while (JOptionPane.showConfirmDialog(null, "Continua..") == 0); } private static int ingresarNota(String n) throws Exception { int nota = Integer.parseInt(JOptionPane. showInputDialog("Ingresar nota " + n + ": ")); if (nota < 0 || nota > 20) { throw new Exception("La nota debe ser de 0 a 20"); } return nota; } } |
Problema 2. Manejo de Aserciones
Deseamos comprobar que nuestra aplicación pueda obtener la raíz cuadrada de un
número. Realizar las asunciones necesarias.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package parte2; import java.util.Scanner; public class Problema2 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.print("Ingresar número: "); int num = sc.nextInt(); assert (num >= 0) : "El número no puede ser negativo"; System.out.print("La raíz cuadrada del número es: " + Math.sqrt(num)); } } |
Resultado:
Ingresar número: 4
La raíz cuadrada del número es: 2.0
Ingresar número: -4
Exception in thread "main" java.lang.AssertionError: El número no puede ser negativo
at parte2.Problema2.main(Problema2.java:17)
Problema 3. Manejo de Cadenas
Este problema hace empleo de las clases de cadena para optimizar la
actualización de información:
Se pide ingresar los datos de Apellido Paterno, Apellido Materno, Sexo y Nombre de los clientes de la empresa (máx. 10) mediante un arreglo de clase o arreglo de datos y generar su ID. Autogenerado, de acuerdo con las siguientes características:
. 1 y 3 carácter del apellido Paterno y Materno
. 1 y 3 carácter del nombre
. Carácter del sexo
. Número de acuerdo con la posición de registro
Todos los ID, se almacenarán en un StringBuffer de nombre codigos, separando
cada ID por el carácter “,”.
Mostrar al finalizar los datos ingresados, así como el ID generado y la cadena de códigos almacenada.
Solución:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 | package parte2; import java.util.Scanner; class Persona { private String apePat; private String apePMat; private String sexo; private String nombre; private String id; public Persona(String apePat, String apePMat, String sexo, String nombre, String id) { this.apePat = apePat; this.apePMat = apePMat; this.sexo = sexo; this.nombre = nombre; this.id = id; } @Override public String toString() { return "Persona [apePat=" + apePat + ", apePMat=" + apePMat + ", sexo=" + sexo + ", nombre=" + nombre + ", id=" + id + "]"; } } public class Problema3 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); Persona[] personas = new Persona[10]; StringBuffer codigos = new StringBuffer(); // Recorremos el arreglo for (int i = 0; i < personas.length; i++) { System.out.println("DATOS DE LA PERSONA: " + i); System.out.print("INGRESAR APELLIDO PATERNO: "); String ap = scanner.next(); System.out.print("INGRESAR APELLIDO MATERNO: "); String am = scanner.next(); System.out.print("INGRESAR SEXO (M/F) : "); String sex = scanner.next(); System.out.print("INGRESAR PRIMER NOMBRE : "); String nom = scanner.next(); String id1, id2, id3, id4, idgenerado; // ID1: 1° y 3° carácter del apellido Paterno y Materno id1 = "" + ap.charAt(0) + ap.charAt(2) + am.charAt(0) + am.charAt(2); // ID2: 1° y 3° carácter del nombre id2 = "" + nom.charAt(0) + nom.charAt(2); // ID3. Carácter del sexo id3 = "" + sex.charAt(0); // ID4: Número de acuerdo con la posición de registro id4 = "" + i; //ID GENERADO idgenerado = id1 + id2 + id3 + id4; System.out.println("\nAP : " + ap + "\n" + "AM : " + am + "\n" + "SEX: " + sex + "\n" + "NOM: " + nom + "\n" + "ID :" + idgenerado); // Adicionamos la persona al arreglo personas[i] = new Persona(ap, am, sex, nom, idgenerado); // Agregamos los códigos generados al SB if (i == 9) codigos.append(idgenerado); else codigos.append(idgenerado + ","); System.out.println("\n"); } // Imprimir for (Persona p : personas) { System.out.println(p); } System.out.println("Códigos: " + codigos); } } |
Resultado:
DATOS DE LA PERSONA: 0
INGRESAR APELLIDO PATERNO: TORO
INGRESAR APELLIDO MATERNO: ALCARRAZ
INGRESAR SEXO (M/F) : M
INGRESAR NOMBRE : JOSE
AP: TORO
AM: ALCARRAZ
SEX: M
NOM: JOSE
ID. TRACJSM0
DATOS DE LA PERSONA: 1
INGRESAR APELLIDO PATERNO: ROJAS
INGRESAR APELLIDO MATERNO: HUERTAS
INGRESAR SEXO (M/F) : F
INGRESAR NOMBRE : TATIANA
AP: ROJAS
AM: HUERTAS
SEX: F
NOM: TATIANA
ID: RJHETTF1
DATOS DE LA PERSONA: 2
INGRESAR APELLIDO PATERNO: LIMA
INGRESAR APELLIDO MATERNO: SOTO
INGRESAR SEXO (M/F) : F
INGRESAR NOMBRE : MERCIA
AP: LIMA
AM: SOTO
SEX: F
NOM: MERCIA
ID: LMSTMRF2
Persona [apePat=TORO, apePMat=ALCARRAZ,
sexo=M, nombre=JOSE, id=TRACJSM0]
Persona [apePat=ROJAS, apePMat=HUERTAS,
sexo=F, nombre=TATIANA, id=RJHETTF1]
Persona [apePat=LIMA, apePMat=SOTO, sexo=F, nombre=MERCIA,
id=LMSTMRF2]
Códigos: TRACJSM0,RJHETTF1,LMSTMRF2
Pregunta
|
Puntaje
|
Criterios de evaluación
|
|
|
Parte 1 |
8 |
Identifica y responde adecuadamente.
|
2 puntos c/u |
|
Parte 2 |
12 |
|
|
|
2 |
5 puntos |
Empleo de clases de las estructuras Lógica Funcionamiento |
3 ptos 1 pto. 1 pto. |
|
3 |
2 puntos |
Realiza la asunción mostrando el
error |
2 ptos |
|
4 |
5 puntos |
Empleo de clases de Cadena y sus
métodos Lógica Funcionamiento |
3 ptos 1 pto. 1 pto. |
DESARROLLO TUS ALGORITMOS 🔥🔥
No hay comentarios, ¡cuéntame algo!
Me gustaría saber tu opinión. ¡Saludos!