Aquí te muestro un ejemplo de código en Java que cumple con las especificaciones que me proporcionaste:
```java
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Ingrese el ID del equipo:");
String idEquipo = scanner.nextLine();
String descripcionEquipo = obtenerDescripcionEquipo(scanner);
int añoCompra = obtenerAñoCompra(scanner);
int añosDepreciacion = calcularAñosDepreciacion(añoCompra);
System.out.println("ID del equipo: " + idEquipo);
System.out.println("Descripción del equipo: " + descripcionEquipo);
System.out.println("Año de compra: " + añoCompra);
System.out.println("Años de depreciación: " + añosDepreciacion);
if (añosDepreciacion > 2) {
System.out.println("El equipo no cuenta con garantía vigente.");
} else {
System.out.println("El equipo cuenta con garantía.");
}
}
private static String obtenerDescripcionEquipo(Scanner scanner) {
while (true) {
System.out.println("Ingrese la descripción del equipo:");
String descripcion = scanner.nextLine();
if (descripcion.matches("^[a-zA-Z ]+$")) {
return descripcion;
} else {
System.out.println("Error: La descripción del equipo solo puede contener letras.");
}
}
}
private static int obtenerAñoCompra(Scanner scanner) {
while (true) {
try {
System.out.println("Ingrese el año de compra del equipo:");
int año = scanner.nextInt();
scanner.nextLine(); // Limpiar el buffer
if (año > 0) {
return año;
} else {
System.out.println("Error: El año de compra debe ser mayor a 0.");
}
} catch (InputMismatchException e) {
System.out.println("Error: El año de compra debe ser un número.");
scanner.nextLine(); // Limpiar el buffer
}
}
}
private static int calcularAñosDepreciacion(int añoCompra) {
int añosActual = 2024; // Año actual
return añosActual - añoCompra;
}
}
```
Este código utiliza un `Scanner` para leer la entrada del usuario y realizar las validaciones correspondientes. La función `obtenerDescripcionEquipo` utiliza una expresión regular para verificar que la descripción del equipo solo contenga letras. La función `obtenerAñoCompra` utiliza un `try-catch` para verificar que el año de compra sea un número mayor a 0. La función `calcularAñosDepreciacion` calcula la cantidad de años de depreciación restantes.
Aquí te muestro un ejemplo de cómo calcular el promedio ponderado en Java:
```java
public class PromedioPonderado {
public static void main(String[] args) {
// Definir notas y créditos
double nota1 = 85.0;
double nota2 = 90.0;
double nota3 = 78.0;
double nota4 = 92.0;
double nota5 = 88.0;
double credito1 = 3.0;
double credito2 = 4.0;
double credito3 = 3.0;
double credito4 = 4.0;
double credito5 = 3.0;
// Calcular promedio ponderado
double promedioPonderado = calcularPromedioPonderado(nota1, credito1, nota2, credito2, nota3, credito3, nota4, credito4, nota5, credito5);
System.out.println("El promedio ponderado es: " + promedioPonderado);
}
/**
* Calcula el promedio ponderado de acuerdo con las notas y créditos dados.
*
* @param nota1 La primera nota.
* @param credito1 El crédito de la primera nota.
* @param nota2 La segunda nota.
* @param credito2 El crédito de la segunda nota.
* @param nota3 La tercera nota.
* @param credito3 El crédito de la tercera nota.
* @param nota4 La cuarta nota.
* @param credito4 El crédito de la cuarta nota.
* @param nota5 La quinta nota.
* @param credito5 El crédito de la quinta nota.
* @return El promedio ponderado.
*/
public static double calcularPromedioPonderado(double nota1, double credito1, double nota2, double credito2, double nota3, double credito3, double nota4, double credito4, double nota5, double credito5) {
// Calcular la suma de los productos de las notas y créditos
double sumaProductos = (nota1 * credito1) + (nota2 * credito2) + (nota3 * credito3) + (nota4 * credito4) + (nota5 * credito5);
// Calcular la suma de los créditos
double sumaCreditos = credito1 + credito2 + credito3 + credito4 + credito5;
// Calcular el promedio ponderado
double promedioPonderado = sumaProductos / sumaCreditos;
return promedioPonderado;
}
}
```
En este ejemplo, se definen las notas y créditos de cinco materias. Luego, se llama al método `calcularPromedioPonderado` para calcular el promedio ponderado. El método calcula la suma de los productos de las notas y créditos, la suma de los créditos y luego divide la suma de los productos por la suma de los créditos para obtener el promedio ponderado.
También puedes crear una clase `Materia` para representar cada materia y un método `calcularPromedioPonderado` que reciba un arreglo de materias y calcule el promedio ponderado de todas ellas:
```java
public class Materia {
private String nombre;
private double nota;
private double credito;
public Materia(String nombre, double nota, double credito) {
this.nombre = nombre;
this.nota = nota;
this.credito = credito;
}
public String getNombre() {
return nombre;
}
public double getNota() {
return nota;
}
public double getCredito() {
return credito;
}
}
public class PromedioPonderado {
public static void main(String[] args) {
// Definir materias
Materia materia1 = new Materia("Matemáticas", 85.0, 3.0);
Materia materia2 = new Materia("Física", 90.0, 4.0);
Materia materia3 = new Materia("Química", 78.0, 3.0);
Materia materia4 = new Materia("Biología", 92.0, 4.0);
Materia materia5 = new Materia("Inglés", 88.0, 3.0);
// Calcular promedio ponderado
double promedioPonderado = calcularPromedioPonderado(materia1, materia2, materia3, materia4, materia5);
System.out.println("El promedio ponderado es: " + promedioPonderado);
}
/**
* Calcula el promedio ponderado de acuerdo con las materias dadas.
*
* @param materias Los materiales.
* @return El promedio ponderado.
*/
public static double calcularPromedioPonderado(Materia... materias) {
// Calcular la suma de los productos de las notas y créditos
double sumaProductos = 0;
for (Materia materia : materias) {
sumaProductos += materia.getNota() * materia.getCredito();
}
// Calcular la suma de los créditos
double sumaCreditos = 0;
for (Materia materia : materias) {
sumaCreditos += materia.getCredito();
}
// Calcular el promedio ponderado
double promedioPonderado = sumaProductos / sumaCreditos;
return promedioPonderado;
}
}
```
En este ejemplo, se define una clase `Materia` para representar cada materia y un método `calcularPromedioPonderado` que reciba un arreglo de materias y calcule el promedio ponderado de todas ellas. El método utiliza el operador `...` para permitir que se pasen un número variable de argumentos.
Aquí te presento un ejemplo de código en Java que simula la falla del correo electrónico de un estudiante y presenta una nota en pantalla con la información solicitada:
```java
import java.util.Scanner;
public class FallaCorreoElectronico {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Ingrese su nombre:");
String nombre = scanner.nextLine();
System.out.println("Ingrese su primer apellido:");
String primerApellido = scanner.nextLine();
System.out.println("Ingrese su segundo apellido:");
String segundoApellido = scanner.nextLine();
System.out.println("Ingrese su correo electrónico principal:");
String correoPrincipal = scanner.nextLine();
System.out.println("Ingrese la descripción de la falla:");
String descripcionFalla = scanner.nextLine();
System.out.println("Ingrese su correo electrónico alterno:");
String correoAlterno = scanner.nextLine();
System.out.println("Ingrese su número de teléfono:");
String numeroTelefono = scanner.nextLine();
// Presentar nota en pantalla
System.out.println("\nNota de registro de falla del correo electrónico:");
System.out.println("-----------------------------------------------");
System.out.println("Nombre: " + nombre);
System.out.println("Apellido: " + primerApellido + " " + segundoApellido);
System.out.println("Correo electrónico principal: " + correoPrincipal);
System.out.println("Descripción de la falla: " + descripcionFalla);
System.out.println("Correo electrónico alterno: " + correoAlterno);
System.out.println("Número de teléfono: " + numeroTelefono);
System.out.println("-----------------------------------------------");
// Enviar información al correo alterno (simulación)
System.out.println("\nInformación enviada al correo electrónico alterno:");
System.out.println("-----------------------------------------------");
System.out.println("Estimado/a " + nombre + " " + primerApellido + " " + segundoApellido + ",");
System.out.println("le informamos que se ha registrado la falla del correo electrónico principal.");
System.out.println("Se le enviará información adicional a su correo electrónico alterno: " + correoAlterno);
System.out.println("Número de teléfono: " + numeroTelefono);
System.out.println("-----------------------------------------------");
}
}
```
Este código solicita la información necesaria al usuario y luego presenta una nota en pantalla con la información solicitada. Luego, simula el envío de la información al correo electrónico alterno.
Recuerda que este es solo un ejemplo y no es una implementación real de un sistema de gestión de fallas de correo electrónico.
A continuación, te proporciono un ejemplo de código en Java que implementa las funcionalidades que mencionaste:
```java
import java.util.InputMismatchException;
import java.util.Scanner;
public class CorreoElectronico {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String correo = obtenerCorreo(scanner);
String falla = obtenerFalla(scanner);
String correoAlterno = obtenerCorreoAlterno(scanner);
String telefono = obtenerTelefono(scanner);
System.out.println("Correo electrónico: " + correo);
System.out.println("Falla: " + falla);
System.out.println("Correo electrónico alterno: " + correoAlterno);
System.out.println("Teléfono: " + telefono);
}
private static String obtenerCorreo(Scanner scanner) {
while (true) {
System.out.print("Ingrese su cuenta de correo electrónico (nombre.apellido.apellido@est.uned.ac.cr): ");
String correo = scanner.nextLine();
if (correo.matches("^[a-zA-Z]+\\.[a-zA-Z]+\\.[a-zA-Z]+@est\\.uned\\.ac\\.cr$")) {
return correo;
} else {
System.out.println("Formato de correo electrónico incorrecto. Por favor, inténtelo de nuevo.");
}
}
}
private static String obtenerFalla(Scanner scanner) {
while (true) {
System.out.print("Describa la falla: ");
String falla = scanner.nextLine();
if (!falla.isEmpty()) {
return falla;
} else {
System.out.println("La falla no puede estar en blanco. Por favor, inténtelo de nuevo.");
}
}
}
private static String obtenerCorreoAlterno(Scanner scanner) {
while (true) {
System.out.print("Ingrese su correo electrónico alterno (opcional): ");
String correoAlterno = scanner.nextLine();
if (!correoAlterno.isEmpty()) {
return correoAlterno;
} else {
System.out.println("El correo electrónico alterno no puede estar en blanco. Por favor, inténtelo de nuevo.");
}
}
}
private static String obtenerTelefono(Scanner scanner) {
while (true) {
try {
System.out.print("Ingrese su número de teléfono: ");
String telefono = scanner.nextLine();
if (telefono.matches("\\d+")) {
return telefono;
} else {
System.out.println("El número de teléfono solo puede contener números. Por favor, inténtelo de nuevo.");
}
} catch (InputMismatchException e) {
System.out.println("El número de teléfono solo puede contener números. Por favor, inténtelo de nuevo.");
scanner.next(); // Limpiar el buffer de entrada
}
}
}
}
```
Este código utiliza un bucle `while` para solicitar al usuario que ingrese la información requerida hasta que se ingrese correctamente. La función `obtenerCorreo` utiliza una expresión regular para verificar que el formato de correo electrónico sea correcto. La función `obtenerTelefono` utiliza un `try-catch` para verificar que el número de teléfono solo contenga números.
Aquí te muestro un ejemplo de código en Java que cumple con las especificaciones que me proporcionaste:
```java
import java.util.InputMismatchException;
import java.util.Scanner;
public class RegistrarFalla {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String nombre, apellidos, correo, descripcion, correoAlterno;
int telefono;
// Ingresar nombre y apellidos del estudiante
System.out.print("Ingrese su nombre: ");
nombre = scanner.nextLine();
System.out.print("Ingrese sus apellidos: ");
apellidos = scanner.nextLine();
// Ingresar correo electrónico
boolean correoValido = false;
while (!correoValido) {
System.out.print("Ingrese su correo electrónico (formato: nombre.apellido.apellido@est.uned.ac.cr): ");
correo = scanner.nextLine();
if (correo.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$") && correo.contains("@est.uned.ac.cr")) {
correoValido = true;
} else {
System.out.println("Correo electrónico inválido. Por favor, ingrese un correo electrónico válido.");
}
}
// Ingresar descripción de la falla
System.out.print("Ingrese la descripción de la falla: ");
descripcion = scanner.nextLine();
// Ingresar correo alterno
System.out.print("Ingrese su correo electrónico alterno: ");
correoAlterno = scanner.nextLine();
// Ingresar número de teléfono
boolean telefonoValido = false;
while (!telefonoValido) {
try {
System.out.print("Ingrese su número de teléfono: ");
telefono = scanner.nextInt();
scanner.nextLine(); // Limpiar el buffer de entrada
if (telefono > 0) {
telefonoValido = true;
} else {
System.out.println("Número de teléfono inválido. Por favor, ingrese un número de teléfono positivo.");
}
} catch (InputMismatchException e) {
System.out.println("Número de teléfono inválido. Por favor, ingrese un número de teléfono numérico.");
scanner.nextLine(); // Limpiar el buffer de entrada
}
}
// Presentar nota de registro y enviar información al correo alterno
System.out.println("\nSe ha registrado el caso con éxito.");
System.out.println("Se enviará información al correo electrónico alterno: " + correoAlterno);
System.out.println("Nombre: " + nombre + " " + apellidos);
System.out.println("Correo electrónico: " + correo);
System.out.println("Descripción de la falla: " + descripcion);
System.out.println("Número de teléfono: " + telefono);
}
}
```
Este código utiliza un `Scanner` para leer la entrada del usuario y realizar validaciones para asegurarse de que los datos sean correctos. Si el usuario ingresa un correo electrónico inválido o un número de teléfono no numérico, se le solicita que lo ingrese de nuevo. Una vez que se han ingresado todos los datos, se presenta una nota de registro y se envía información al correo electrónico alterno.
Aquí te muestro un ejemplo de código en Java que implementa el menú que solicitaste:
```java
import java.util.Scanner;
public class MenuPrincipal {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int opcion;
do {
System.out.println("Menú Principal");
System.out.println("1. Clase Principal");
System.out.println("2. Salir");
System.out.print("Seleccione una opción: ");
opcion = scanner.nextInt();
switch (opcion) {
case 1:
System.out.println("Seleccione tipo de Usuario:");
System.out.println("1. Estudiante");
System.out.println("2. Funcionario Académico");
System.out.println("3. Funcionario Administrativo");
System.out.println("4. Salir");
int usuarioOpcion = scanner.nextInt();
switch (usuarioOpcion) {
case 1:
subMenuEstudiante(scanner);
break;
case 2:
subMenuAcademico(scanner);
break;
case 3:
subMenuAdministrativo(scanner);
break;
case 4:
System.out.println("Saliendo...");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
break;
case 2:
System.out.println("Saliendo...");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} while (opcion != 2);
}
private static void subMenuEstudiante(Scanner scanner) {
int opcion;
do {
System.out.println("Submenú Estudiante");
System.out.println("1. Falla en correo electrónico*");
System.out.println("2. Solicitud de cuenta de office");
System.out.println("3. Salir");
System.out.print("Seleccione una opción: ");
opcion = scanner.nextInt();
switch (opcion) {
case 1:
System.out.println("Falla en correo electrónico*");
break;
case 2:
System.out.println("Solicitud de cuenta de office");
break;
case 3:
System.out.println("Saliendo...");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} while (opcion != 3);
}
private static void subMenuAcademico(Scanner scanner) {
int opcion;
do {
System.out.println("Submenú Académico");
System.out.println("1. Registros de Notas*");
System.out.println("2. Historial de Cursos");
System.out.println("3. Repositorio Académico");
System.out.println("4. Salir");
System.out.print("Seleccione una opción: ");
opcion = scanner.nextInt();
switch (opcion) {
case 1:
System.out.println("Registros de Notas*");
break;
case 2:
System.out.println("Historial de Cursos");
break;
case 3:
System.out.println("Repositorio Académico");
break;
case 4:
System.out.println("Saliendo...");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} while (opcion != 4);
}
private static void subMenuAdministrativo(Scanner scanner) {
int opcion;
do {
System.out.println("Submenú Administrativo");
System.out.println("1. Soporte técnico");
System.out.println("2. Acceso a sistemas institucionales");
System.out.println("3. Garantía de equipos");
System.out.println("4. Salir");
System.out.print("Seleccione una opción: ");
opcion = scanner.nextInt();
switch (opcion) {
case 1:
System.out.println("Soporte técnico");
break;
case 2:
System.out.println("Acceso a sistemas institucionales");
break;
case 3:
System.out.println("Garantía de equipos");
break;
case 4:
System.out.println("Saliendo...");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} while (opcion != 4);
}
}
```
Este código utiliza un menú principal con opciones para seleccionar el tipo de usuario y luego despliega un submenú según la opción seleccionada. Cada submenú tiene sus propias opciones y se despliega hasta que se selecciona la opción de salir.
Puedes llamar a otras clases en Java de varias maneras, dependiendo de la estructura de tu proyecto y la relación entre las clases. Aquí te presento algunas opciones:
### 1. Importar la clase
Si la clase que deseas llamar está en el mismo paquete que la clase actual, no necesitas hacer nada. Si la clase está en un paquete diferente, debes importarla al principio de tu archivo Java.
```java
import paquete.ClaseQueDeseasLlamar;
```
### 2. Crear un objeto de la clase
Una vez que hayas importado la clase, puedes crear un objeto de ella y llamar a sus métodos.
```java
ClaseQueDeseasLlamar objeto = new ClaseQueDeseasLlamar();
objeto.metodoQueDeseasLlamar();
```
### 3. Herencia
Si la clase que deseas llamar es una clase base y la clase actual es una clase hija, puedes heredar de la clase base y llamar a sus métodos.
```java
public class ClaseHija extends ClaseBase {
public ClaseHija() {
super();
ClaseBase objeto = new ClaseBase();
objeto.metodoQueDeseasLlamar();
}
}
```
### 4. Polimorfismo
Si la clase que deseas llamar es una clase que implementa una interfaz o es una clase abstracta, puedes crear un objeto de la clase y llamar a sus métodos.
```java
ClaseQueDeseasLlamar objeto = new ClaseQueDeseasLlamar();
objeto.metodoQueDeseasLlamar();
```
### 5. Uso de interfaces
Si la clase que deseas llamar es una clase que implementa una interfaz, puedes crear un objeto de la clase y llamar a los métodos de la interfaz.
```java
ClaseQueDeseasLlamar objeto = new ClaseQueDeseasLlamar();
objeto.metodoQueDeseasLlamar();
```
### 6. Uso de patrones de diseño
Existen varios patrones de diseño que te permiten llamar a otras clases de manera más flexible y escalable. Algunos ejemplos son:
* **Patrón Singleton**: permite crear un objeto único de una clase.
* **Patrón Factory**: permite crear objetos de una clase sin especificar la clase concreta.
* **Patrón Observer**: permite que una clase observe cambios en otra clase.
Aquí te presento un ejemplo de cómo podrías implementar el patrón Singleton para llamar a una clase:
```java
public class ClaseSingleton {
private static ClaseSingleton instancia;
private ClaseSingleton() {}
public static ClaseSingleton getInstancia() {
if (instancia == null) {
instancia = new ClaseSingleton();
}
return instancia;
}
public void metodoQueDeseasLlamar() {
// código del método
}
}
public class ClaseQueDeseaLlamar {
public void llamarAMetodo() {
ClaseSingleton objeto = ClaseSingleton.getInstancia();
objeto.metodoQueDeseasLlamar();
}
}
```
Recuerda que la elección del patrón de diseño depende del contexto y de las necesidades específicas de tu proyecto.
Aquí te muestro un ejemplo de cómo podrías implementar un programa en Java que calcule la potencia de un número y maneje errores si se ingresa una letra:
```java
import java.util.InputMismatchException;
import java.util.Scanner;
public class Potencia {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (true) {
try {
System.out.print("Ingrese el número base: ");
double base = scanner.nextDouble();
System.out.print("Ingrese la potencia: ");
double potencia = scanner.nextDouble();
double resultado = calcularPotencia(base, potencia);
System.out.println("El resultado es: " + resultado);
break;
} catch (InputMismatchException e) {
System.out.println("Error: Por favor ingrese un número.");
scanner.next(); // Limpiar el buffer de entrada
} catch (ArithmeticException e) {
System.out.println("Error: No se puede calcular la raíz cuadrada de un número negativo.");
}
}
scanner.close();
}
public static double calcularPotencia(double base, double potencia) {
return Math.pow(base, potencia);
}
}
```
En este programa, utilizamos un bucle `while` para continuar solicitando la entrada al usuario hasta que se ingrese un número válido. Si se ingresa una letra, se captura la excepción `InputMismatchException` y se muestra un mensaje de error. Si se ingresa un número negativo como base y se intenta calcular la potencia, se captura la excepción `ArithmeticException` y se muestra un mensaje de error.
El método `calcularPotencia` utiliza la función `Math.pow` para calcular la potencia del número base.
Recuerda que en Java, `double` es un tipo de dato flotante que puede representar números decimales. Si necesitas trabajar con números enteros, puedes utilizar el tipo `int` en lugar de `double`.
Aquí te presento un ejemplo de cómo podrías implementar el módulo de cálculo de planilla en Java:
```java
import java.util.Scanner;
public class CalculoPlanilla {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
boolean salir = false;
while (!salir) {
System.out.println("Menú:");
System.out.println("i. Registro de deducción");
System.out.println("ii. Cálculo de Planilla individual");
System.out.println("iii. Salir");
System.out.print("Ingrese una opción: ");
String opcion = scanner.nextLine().toLowerCase();
switch (opcion) {
case "i":
registroDeducción(scanner);
break;
case "ii":
cálculoPlanillaIndividual(scanner);
break;
case "iii":
salir = true;
break;
default:
System.out.println("Opción inválida. Por favor, ingrese una opción válida.");
}
}
scanner.close();
}
private static void registroDeducción(Scanner scanner) {
System.out.println("Registro de deducción");
System.out.println("---------------------");
System.out.println("Esta opción no está funcional");
System.out.println("Ingrese 's' para salir");
String opcion = scanner.nextLine().toLowerCase();
if (opcion.equals("s")) {
System.out.println("Saliendo del programa...");
} else {
System.out.println("Opción inválida. Saliendo del programa...");
}
}
private static void cálculoPlanillaIndividual(Scanner scanner) {
System.out.println("Cálculo de Planilla individual");
System.out.println("-----------------------------");
System.out.print("Ingrese el nombre del empleado: ");
String nombreEmpleado = scanner.nextLine();
System.out.print("Ingrese el salario bruto: ");
double salarioBruto = scanner.nextDouble();
scanner.nextLine(); // Limpiar el buffer
double salarioBase = salarioBruto;
double ccss = calcularCcss(salarioBase);
double popular = calcularPopular(salarioBase);
double renta = calcularRenta(salarioBase);
System.out.println("\nResumen de la planilla individual:");
System.out.println("--------------------------------");
System.out.println("Nombre del empleado: " + nombreEmpleado);
System.out.println("Salario bruto: $" + salarioBruto);
System.out.println("Salario base: $" + salarioBase);
System.out.println("CCSS: $" + ccss);
System.out.println("Popular: $" + popular);
System.out.println("Renta: $" + renta);
System.out.println("Salario neto: $" + (salarioBruto - ccss - popular - renta));
}
private static double calcularCcss(double salarioBase) {
return salarioBase * 0.09;
}
private static double calcularPopular(double salarioBase) {
return salarioBase * 0.03;
}
private static double calcularRenta(double salarioBase) {
if (salarioBase > 900000) {
return salarioBase * 0.13;
} else {
return 0;
}
}
}
```
Este código crea un menú que permite al usuario seleccionar la opción de cálculo de planilla individual. Cuando se selecciona esta opción, se solicita el nombre del empleado y el salario bruto. Luego, se calculan los rubros de CCSS, Popular y Renta según las reglas definidas, y se muestra un resumen de la planilla individual con los resultados de los cálculos.
A continuación, te proporciono un ejemplo de código en Java que cumple con las condiciones que mencionaste:
```java
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CorreoElectronico {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String correo = obtenerCorreo(scanner);
String falla = obtenerFalla(scanner);
String correoAlterno = obtenerCorreoAlterno(scanner);
String telefono = obtenerTelefono(scanner);
System.out.println("Nota: Se ha registrado el caso y se enviará información al correo alterno.");
System.out.println("Correo electrónico: " + correo);
System.out.println("Falla: " + falla);
System.out.println("Correo alterno: " + correoAlterno);
System.out.println("Teléfono: " + telefono);
}
private static String obtenerCorreo(Scanner scanner) {
while (true) {
System.out.print("Ingrese su cuenta de correo electrónico (nombre.apellido.apellido@est.uned.ac.cr): ");
String correo = scanner.nextLine();
if (validarCorreo(correo)) {
return correo;
} else {
System.out.println("Error: El formato de correo electrónico es incorrecto. Por favor, inténtelo de nuevo.");
}
}
}
private static boolean validarCorreo(String correo) {
String patron = "^[a-zA-Z0-9]+\\.[a-zA-Z0-9]+\\.[a-zA-Z0-9]+@est\\.uned\\.ac\\.cr$";
Pattern pattern = Pattern.compile(patron);
Matcher matcher = pattern.matcher(correo);
return matcher.matches();
}
private static String obtenerFalla(Scanner scanner) {
while (true) {
System.out.print("Ingrese la falla (mínimo 5 caracteres): ");
String falla = scanner.nextLine();
if (falla.length() >= 5) {
return falla;
} else {
System.out.println("Error: La falla debe tener al menos 5 caracteres. Por favor, inténtelo de nuevo.");
}
}
}
private static String obtenerCorreoAlterno(Scanner scanner) {
while (true) {
System.out.print("Ingrese su correo electrónico alterno: ");
String correoAlterno = scanner.nextLine();
if (!correoAlterno.isEmpty()) {
return correoAlterno;
} else {
System.out.println("Error: El correo electrónico alterno no puede estar en blanco. Por favor, inténtelo de nuevo.");
}
}
}
private static String obtenerTelefono(Scanner scanner) {
while (true) {
try {
System.out.print("Ingrese su número de teléfono: ");
String telefono = scanner.nextLine();
if (telefono.matches("\\d+")) {
return telefono;
} else {
System.out.println("Error: El número de teléfono solo puede contener números. Por favor, inténtelo de nuevo.");
}
} catch (InputMismatchException e) {
System.out.println("Error: El número de teléfono solo puede contener números. Por favor, inténtelo de nuevo.");
scanner.next(); // Limpiar el buffer de entrada
}
}
}
}
```
Este código utiliza un bucle `while` para solicitar al usuario que ingrese la información requerida hasta que se ingrese correctamente. La función `validarCorreo` utiliza una expresión regular para verificar si el formato de correo electrónico es correcto. La función `obtenerTelefono` utiliza un `try-catch` para capturar cualquier excepción que pueda ocurrir al intentar leer un número de teléfono.
Si te dice que no se encontró el Javadoc en una clase en Java, es probable que estés utilizando un IDE (Entorno de Desarrollo Integrado) como Eclipse, IntelliJ o NetBeans, y que el IDE no pueda encontrar la documentación de la clase en el archivo Javadoc correspondiente.
Aquí hay algunas posibles causas y soluciones:
1. **No hay archivo Javadoc**: Asegúrate de que el archivo Javadoc (.jar o .zip) esté disponible en el proyecto y que esté configurado correctamente en el IDE.
2. **Archivo Javadoc no está actualizado**: Si el archivo Javadoc no está actualizado, el IDE no podrá encontrar la documentación de la clase. Asegúrate de que el archivo Javadoc esté actualizado y que esté configurado correctamente en el IDE.
3. **Clase no está en el archivo Javadoc**: Asegúrate de que la clase esté incluida en el archivo Javadoc. Si la clase no está en el archivo Javadoc, el IDE no podrá encontrar la documentación de la clase.
4. **Configuración del IDE**: Asegúrate de que la configuración del IDE esté correcta. Por ejemplo, en Eclipse, debes configurar el archivo Javadoc en la sección "Java Build Path" del proyecto.
5. **Error en la ruta del archivo Javadoc**: Asegúrate de que la ruta del archivo Javadoc esté correcta. Si la ruta está incorrecta, el IDE no podrá encontrar el archivo Javadoc.
Para solucionar el problema, puedes intentar las siguientes acciones:
* Verifica que el archivo Javadoc esté disponible en el proyecto y que esté configurado correctamente en el IDE.
* Actualiza el archivo Javadoc y configúralo nuevamente en el IDE.
* Asegúrate de que la clase esté incluida en el archivo Javadoc.
* Verifica la configuración del IDE y asegúrate de que esté correcta.
* Verifica la ruta del archivo Javadoc y asegúrate de que esté correcta.
Si sigues teniendo problemas, puedes intentar buscar ayuda en la documentación del IDE o en foros de desarrollo Java.
Please keep input under 1000 characters
Aquí te muestro un ejemplo de cómo podrías implementar el menú en Java:
```java
import java.util.Scanner;
public class MenuPrincipal {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int opcion;
do {
System.out.println("Seleccione tipo de Usuario:");
System.out.println("1. Estudiante");
System.out.println("2. Funcionario Académico");
System.out.println("3. Funcionario Administrativo");
System.out.println("4. Salir");
opcion = scanner.nextInt();
scanner.nextLine(); // Consumir el salto de línea
switch (opcion) {
case 1:
menuEstudiante(scanner);
break;
case 2:
menuAcademico(scanner);
break;
case 3:
menuAdministrativo(scanner);
break;
case 4:
System.out.println("Gracias por utilizar el sistema.");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} while (opcion != 4);
}
private static void menuEstudiante(Scanner scanner) {
int opcion;
do {
System.out.println("Submenú Estudiante:");
System.out.println("1. Falla en correo electrónico*");
System.out.println("2. Solicitud de cuenta de office");
System.out.println("3. Salir");
opcion = scanner.nextInt();
scanner.nextLine(); // Consumir el salto de línea
switch (opcion) {
case 1:
System.out.println("Falla en correo electrónico: Por favor, contacte con el soporte técnico.");
break;
case 2:
System.out.println("Solicitud de cuenta de office: Por favor, contacte con el soporte técnico.");
break;
case 3:
System.out.println("Ha salido del submenú Estudiante.");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} while (opcion != 3);
}
private static void menuAcademico(Scanner scanner) {
int opcion;
do {
System.out.println("Submenú Académico:");
System.out.println("1. Registros de Notas*");
System.out.println("2. Historial de Cursos");
System.out.println("3. Repositorio Académico");
System.out.println("4. Salir");
opcion = scanner.nextInt();
scanner.nextLine(); // Consumir el salto de línea
switch (opcion) {
case 1:
System.out.println("Registros de Notas: Por favor, contacte con el soporte técnico.");
break;
case 2:
System.out.println("Historial de Cursos: Por favor, contacte con el soporte técnico.");
break;
case 3:
System.out.println("Repositorio Académico: Por favor, contacte con el soporte técnico.");
break;
case 4:
System.out.println("Ha salido del submenú Académico.");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} while (opcion != 4);
}
private static void menuAdministrativo(Scanner scanner) {
int opcion;
do {
System.out.println("Submenú Administrativo:");
System.out.println("1. Soporte técnico");
System.out.println("2. Acceso a sistemas institucionales");
System.out.println("3. Garantía de equipos");
System.out.println("4. Salir");
opcion = scanner.nextInt();
scanner.nextLine(); // Consumir el salto de línea
switch (opcion) {
case 1:
System.out.println("Soporte técnico: Por favor, contacte con el soporte técnico.");
break;
case 2:
System.out.println("Acceso a sistemas institucionales: Por favor, contacte con el soporte técnico.");
break;
case 3:
System.out.println("Garantía de equipos: Por favor, contacte con el soporte técnico.");
break;
case 4:
System.out.println("Ha salido del submenú Administrativo.");
break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} while (opcion != 4);
}
}
```
Este código crea un menú principal con las opciones de Estudiante, Funcionario Académico, Funcionario Administrativo y Salir. Dependiendo de la opción seleccionada, se muestra un submenú con las opciones correspondientes. El programa sigue ejecutándose hasta que se selecciona la opción Salir.
Aquí te dejo un ejemplo de código en Java que cumple con las especificaciones que me proporcionaste:
```java
import java.util.InputMismatchException;
import java.util.Scanner;
public class RegistrarNota {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
boolean continuar = true;
while (continuar) {
System.out.println("Ingrese la cédula del estudiante:");
String cedula = scanner.nextLine();
while (!esValidaCedula(cedula)) {
System.out.println("Error: La cédula debe ser un número de 10 dígitos. Por favor, ingrese nuevamente.");
cedula = scanner.nextLine();
}
System.out.println("Ingrese el código de materia (5 caracteres):");
String codigoMateria = scanner.nextLine();
while (!esValidoCodigoMateria(codigoMateria)) {
System.out.println("Error: El código de materia debe ser un string de 5 caracteres. Por favor, ingrese nuevamente.");
codigoMateria = scanner.nextLine();
}
System.out.println("Ingrese la nota obtenida:");
String nota = scanner.nextLine();
while (!esValidaNota(nota)) {
System.out.println("Error: La nota debe ser un número entre 1 y 100. Por favor, ingrese nuevamente.");
nota = scanner.nextLine();
}
int notaInt = Integer.parseInt(nota);
String resultado = obtenerResultado(notaInt);
System.out.println("Resultado: " + resultado);
System.out.println("¿Desea registrar otra nota? (s/n)");
String respuesta = scanner.nextLine().toLowerCase();
if (!respuesta.equals("s")) {
continuar = false;
}
}
scanner.close();
}
private static boolean esValidaCedula(String cedula) {
return cedula.matches("\\d{10}");
}
private static boolean esValidoCodigoMateria(String codigoMateria) {
return codigoMateria.matches("[a-zA-Z0-9]{5}");
}
private static boolean esValidaNota(String nota) {
try {
int notaInt = Integer.parseInt(nota);
return notaInt >= 1 && notaInt <= 100;
} catch (NumberFormatException e) {
return false;
}
}
private static String obtenerResultado(int nota) {
if (nota < 65) {
return "Ha reprobado el curso";
} else if (nota >= 65 && nota < 69) {
return "Tiene opción de realizar examen extraordinario";
} else {
return "Ha ganado el curso";
}
}
}
```
Este código utiliza un bucle `while` para permitir al usuario registrar múltiples notas. En cada iteración, se solicita la cédula del estudiante, el código de materia y la nota obtenida. Se validan cada uno de estos campos utilizando métodos `esValidaCedula`, `esValidoCodigoMateria` y `esValidaNota`. Si el campo no es válido, se muestra un mensaje de error y se solicita nuevamente. Una vez que se ingresa una nota válida, se calcula el resultado utilizando el método `obtenerResultado` y se muestra al usuario. Finalmente, se pregunta al usuario si desea registrar otra nota. Si la respuesta es "no", el bucle se cierra y el programa termina.
Aquí te muestro un ejemplo de código en Java que cumple con las especificaciones que me proporcionaste:
```java
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class FallaCorreo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Ingrese el nombre del estudiante:");
String nombre = scanner.nextLine();
System.out.println("Ingrese los apellidos del estudiante:");
String apellidos = scanner.nextLine();
System.out.println("Ingrese la cuenta de correo del estudiante (formato: nombre.apellido.apellido@est.uned.ac.cr):");
String correo = scanner.nextLine();
System.out.println("Ingrese la descripción de la falla:");
String descripcion = scanner.nextLine();
System.out.println("Ingrese el correo alterno:");
String correoAlterno = scanner.nextLine();
System.out.println("Ingrese el número de teléfono:");
String telefono = scanner.nextLine();
// Validación del correo electrónico
Pattern pattern = Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
Matcher matcher = pattern.matcher(correo);
if (!matcher.matches()) {
System.out.println("Error: El correo electrónico no tiene el formato correcto.");
return;
}
// Validación del número de teléfono
if (!telefono.matches("\\d+")) {
System.out.println("Error: El número de teléfono debe ser numérico.");
return;
}
// Registro de la falla
System.out.println("Se ha registrado la falla del correo electrónico del estudiante.");
System.out.println("Se enviará información al correo alterno: " + correoAlterno);
// Presentación de la nota
System.out.println("Nota:");
System.out.println("Nombre del estudiante: " + nombre + " " + apellidos);
System.out.println("Correo electrónico: " + correo);
System.out.println("Descripción de la falla: " + descripcion);
System.out.println("Correo alterno: " + correoAlterno);
System.out.println("Número de teléfono: " + telefono);
}
}
```
Este código utiliza la clase `Scanner` para leer los datos del usuario y la clase `Pattern` y `Matcher` para validar el correo electrónico y el número de teléfono. Si se ingresa un valor no válido, se muestra un mensaje de error y se termina el programa. Si se ingresa un valor válido, se registra la falla y se presenta una nota con la información del estudiante y la falla.
Nota: El patrón de validación del correo electrónico utilizado en este código es un patrón básico que solo verifica que el correo electrónico tenga un formato similar a `nombre.apellido.apellido@est.uned.ac.cr`. Si deseas validar el correo electrónico de manera más estricta, puedes utilizar un patrón más complejo que verifique la existencia de un dominio y un servidor de correo electrónico.
Aquí te presento un ejemplo de código en Java que cumple con los requisitos que se te han proporcionado:
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class FallaCorreoEstudiante extends JFrame {
private JTextField nombreField;
private JTextField apellido1Field;
private JTextField apellido2Field;
private JTextField correoField;
private JTextField correoAlternoField;
private JTextField telefonoField;
private JTextArea descripcionField;
public FallaCorreoEstudiante() {
setLayout(new BorderLayout());
// Panel de entrada de datos
JPanel panelDatos = new JPanel();
panelDatos.setLayout(new GridLayout(6, 2));
panelDatos.add(new JLabel("Nombre:"));
nombreField = new JTextField();
panelDatos.add(nombreField);
panelDatos.add(new JLabel("Apellido 1:"));
apellido1Field = new JTextField();
panelDatos.add(apellido1Field);
panelDatos.add(new JLabel("Apellido 2:"));
apellido2Field = new JTextField();
panelDatos.add(apellido2Field);
panelDatos.add(new JLabel("Correo:"));
correoField = new JTextField();
panelDatos.add(correoField);
panelDatos.add(new JLabel("Correo Alterno:"));
correoAlternoField = new JTextField();
panelDatos.add(correoAlternoField);
panelDatos.add(new JLabel("Teléfono:"));
telefonoField = new JTextField();
panelDatos.add(telefonoField);
add(panelDatos, BorderLayout.CENTER);
// Panel de descripción de la falla
JPanel panelDescripcion = new JPanel();
panelDescripcion.setLayout(new BorderLayout());
descripcionField = new JTextArea(10, 20);
descripcionField.setLineWrap(true);
descripcionField.setWrapStyleWord(true);
JScrollPane scrollPane = new JScrollPane(descripcionField);
panelDescripcion.add(scrollPane, BorderLayout.CENTER);
add(panelDescripcion, BorderLayout.SOUTH);
// Botón de enviar
JButton enviarButton = new JButton("Enviar");
enviarButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
enviarFalla();
}
});
add(enviarButton, BorderLayout.EAST);
}
private void enviarFalla() {
String nombre = nombreField.getText();
String apellido1 = apellido1Field.getText();
String apellido2 = apellido2Field.getText();
String correo = correoField.getText();
String correoAlterno = correoAlternoField.getText();
String telefono = telefonoField.getText();
String descripcion = descripcionField.getText();
if (nombre.isEmpty() || apellido1.isEmpty() || apellido2.isEmpty() || correo.isEmpty() || correoAlterno.isEmpty() || telefono.isEmpty() || descripcion.isEmpty()) {
JOptionPane.showMessageDialog(this, "Por favor, complete todos los campos.");
return;
}
if (!correo.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")) {
JOptionPane.showMessageDialog(this, "El correo electrónico no tiene un formato válido.");
return;
}
if (!correoAlterno.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")) {
JOptionPane.showMessageDialog(this, "El correo electrónico alterno no tiene un formato válido.");
return;
}
// Enviar correo electrónico
String asunto = "Falla de correo electrónico de estudiante";
String mensaje = "Nombre: " + nombre + "\nApellido 1: " + apellido1 + "\nApellido 2: " + apellido2 + "\nCorreo: " + correo + "\nCorreo Alterno: " + correoAlterno + "\nTeléfono: " + telefono + "\nDescripción: " + descripcion;
String destinatario = correoAlterno;
try {
javax.mail.Session session = javax.mail.Session.getDefaultInstance(new javax.mail.Properties() {{
setProperty("mail.smtp.host", "smtp.gmail.com");
setProperty("mail.smtp.port", "587");
setProperty("mail.smtp.auth", "true");
setProperty("mail.smtp.starttls.enable", "true");
}});
javax.mail.Message message = new javax.mail.internet.MimeMessage(session, new javax.mail.internet.InternetAddress(destinatario));
javax.mail.Transport.send(message);
JOptionPane.showMessageDialog(this, "Se ha enviado un correo electrónico a " + destinatario + " con la descripción de la falla.");
} catch (Exception ex) {
JOptionPane.showMessageDialog(this, "Error al enviar correo electrónico: " + ex.getMessage());
}
}
public static void main(String[] args) {
FallaCorreoEstudiante ventana = new FallaCorreoEstudiante();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ventana.setSize(600, 400);
ventana.setVisible(true);
}
}
```
Este código crea una ventana con campos para ingresar la información del estudiante, incluyendo el correo electrónico y el correo electrónico alterno. Cuando se presiona el botón "Enviar", se verifica que todos los campos estén completos y que los correos electrónicos tengan un formato válido. Si todo está correcto, se envía un correo electrónico al correo electrónico alterno con la descripción de la falla.
A continuación, te proporciono un ejemplo de código en Java que cumple con las especificaciones que me proporcionaste:
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class FallaCorreo extends JFrame {
private JTextField txtCorreo;
private JTextField txtDescripcion;
private JTextField txtCorreoAlterno;
private JTextField txtTelefono;
public FallaCorreo() {
setLayout(new BorderLayout());
// Panel de ingreso de datos
JPanel panelDatos = new JPanel();
panelDatos.setLayout(new GridLayout(4, 2));
panelDatos.add(new JLabel("Correo electrónico:"));
txtCorreo = new JTextField();
panelDatos.add(txtCorreo);
panelDatos.add(new JLabel("Descripción de la falla:"));
txtDescripcion = new JTextField();
panelDatos.add(txtDescripcion);
panelDatos.add(new JLabel("Correo electrónico alterno:"));
txtCorreoAlterno = new JTextField();
panelDatos.add(txtCorreoAlterno);
panelDatos.add(new JLabel("Número de teléfono:"));
txtTelefono = new JTextField();
panelDatos.add(txtTelefono);
add(panelDatos, BorderLayout.CENTER);
// Botón de registro
JButton btnRegistrar = new JButton("Registrar falla");
btnRegistrar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
registrarFalla();
}
});
add(btnRegistrar, BorderLayout.SOUTH);
setSize(400, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
private void registrarFalla() {
String correo = txtCorreo.getText();
String descripcion = txtDescripcion.getText();
String correoAlterno = txtCorreoAlterno.getText();
String telefono = txtTelefono.getText();
// Validación del correo electrónico
if (!correo.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")) {
JOptionPane.showMessageDialog(this, "Formato de correo electrónico inválido. Por favor, ingrese un correo electrónico válido.");
txtCorreo.requestFocus();
return;
}
// Validación de la descripción de la falla
if (descripcion.length() < 10) {
JOptionPane.showMessageDialog(this, "La descripción de la falla debe tener al menos 10 caracteres.");
txtDescripcion.requestFocus();
return;
}
// Validación del correo electrónico alterno
if (correoAlterno.isEmpty()) {
JOptionPane.showMessageDialog(this, "El correo electrónico alterno no puede estar en blanco.");
txtCorreoAlterno.requestFocus();
return;
}
// Validación del número de teléfono
if (!telefono.matches("\\d+")) {
JOptionPane.showMessageDialog(this, "El número de teléfono solo puede contener números.");
txtTelefono.requestFocus();
return;
}
// Registro de la falla
JOptionPane.showMessageDialog(this, "La falla se ha registrado con éxito. Se enviará información al correo electrónico alterno.");
JOptionPane.showMessageDialog(this, "Correo electrónico alterno: " + correoAlterno + "\nNúmero de teléfono: " + telefono);
}
public static void main(String[] args) {
new FallaCorreo();
}
}
```
Este código crea una ventana con campos de texto para ingresar la cuenta del correo, la descripción de la falla, el correo electrónico alterno y el número de teléfono. Cuando se presiona el botón de registro, se validan los campos de texto y se registra la falla si todos los campos son válidos. Si algún campo es inválido, se muestra un mensaje de error y se pide al usuario que ingrese los datos correctamente.
Aquí te muestro un ejemplo de cómo podrías implementar esto en Java utilizando un método que solicite un valor al usuario y luego lo valide para asegurarse de que sea numérico. Si el valor no es numérico, el programa mostrará un mensaje de error.
```java
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int numero = solicitarNumero(scanner);
System.out.println("Has ingresado el número: " + numero);
}
public static int solicitarNumero(Scanner scanner) {
while (true) {
try {
System.out.print("Ingrese un número: ");
int numero = scanner.nextInt();
return numero;
} catch (InputMismatchException e) {
System.out.println("Error: Debes ingresar un número.");
scanner.next(); // Limpiar el buffer para evitar problemas futuros
}
}
}
}
```
En este código, el método `solicitarNumero` utiliza un bucle `while` para continuar solicitando un número al usuario hasta que se ingrese un valor numérico válido. Si se ingresa un valor que no es numérico, el programa mostrará un mensaje de error y solicitará otro valor.
El método `scanner.nextInt()` es el que realiza la conversión del valor ingresado por el usuario a un número entero. Si el valor no es numérico, se lanza una `InputMismatchException`, que es capturada por el `catch` y maneja el error mostrando un mensaje de error.
Finalmente, el método `scanner.next()` se utiliza para limpiar el buffer de entrada, lo que evita problemas futuros si se ingresa un valor que no es numérico.
Aquí te presento un ejemplo de código en Java que simula la falla del correo electrónico de un estudiante y envía una nota al correo alterno:
```java
import java.util.Scanner;
public class FallaCorreo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Ingrese su nombre:");
String nombre = scanner.nextLine();
System.out.println("Ingrese su primer apellido:");
String primerApellido = scanner.nextLine();
System.out.println("Ingrese su segundo apellido:");
String segundoApellido = scanner.nextLine();
System.out.println("Ingrese su correo electrónico alterno:");
String correoAlterno = scanner.nextLine();
System.out.println("Ingrese su número de teléfono:");
String telefono = scanner.nextLine();
// Verificar si el correo electrónico tiene el formato correcto
if (!nombre.matches("[a-zA-Z]+") || !primerApellido.matches("[a-zA-Z]+") || !segundoApellido.matches("[a-zA-Z]+")) {
System.out.println("Error: El nombre o apellidos deben ser solo letras.");
return;
}
if (!nombre.matches("[a-zA-Z]+") || !primerApellido.matches("[a-zA-Z]+") || !segundoApellido.matches("[a-zA-Z]+")) {
System.out.println("Error: El nombre o apellidos deben ser solo letras.");
return;
}
if (!correoAlterno.matches("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")) {
System.out.println("Error: El correo electrónico alterno no tiene el formato correcto.");
return;
}
if (!telefono.matches("\\d{8}")) {
System.out.println("Error: El número de teléfono debe tener 8 dígitos.");
return;
}
// Registrar la falla del correo electrónico
System.out.println("Nota: Se ha registrado la falla del correo electrónico. Se enviará información al correo alterno.");
// Enviar información al correo alterno
System.out.println("Se enviará la siguiente información al correo alterno:");
System.out.println("Nombre: " + nombre);
System.out.println("Primer Apellido: " + primerApellido);
System.out.println("Segundo Apellido: " + segundoApellido);
System.out.println("Correo electrónico alterno: " + correoAlterno);
System.out.println("Número de teléfono: " + telefono);
}
}
```
Este código solicita al usuario que ingrese su nombre, primer apellido, segundo apellido, correo electrónico alterno y número de teléfono. Luego, verifica si el correo electrónico tiene el formato correcto y si el número de teléfono tiene 8 dígitos. Si todo está correcto, registra la falla del correo electrónico y envía la información al correo alterno.
Nota: En este ejemplo, no se envía un correo electrónico real al correo alterno, sino que solo se imprime la información en la consola. Para enviar un correo electrónico real, se necesitaría utilizar una biblioteca de correo electrónico como JavaMail.
A continuación, te proporciono el código en Java que cumple con las especificaciones que me has proporcionado:
```java
// Clase abstracta Persona
public abstract class Persona {
protected String nombre;
protected String cedula;
public Persona(String nombre, String cedula) {
this.nombre = nombre;
this.cedula = cedula;
}
public String getNombre() {
return nombre;
}
public String getCedula() {
return cedula;
}
}
// Clase Estudiante que hereda de Persona
public class Estudiante extends Persona {
private String carrera;
private String carnet;
public Estudiante(String nombre, String cedula, String carrera, String carnet) {
super(nombre, cedula);
this.carrera = carrera;
this.carnet = carnet;
}
public String getCarrera() {
return carrera;
}
public String getCarnet() {
return carnet;
}
}
// Clase Académico que hereda de Persona
public class Academico extends Persona {
private double salario;
private String escuela;
public Academico(String nombre, String cedula, double salario, String escuela) {
super(nombre, cedula);
this.salario = salario;
this.escuela = escuela;
}
public double getSalario() {
return salario;
}
public String getEscuela() {
return escuela;
}
}
// Clase Administrativo que hereda de Persona
public class Administrativo extends Persona {
private double salario;
private String escuela;
private String telefono;
public Administrativo(String nombre, String cedula, double salario, String escuela, String telefono) {
super(nombre, cedula);
this.salario = salario;
this.escuela = escuela;
this.telefono = telefono;
}
public double getSalario() {
return salario;
}
public String getEscuela() {
return escuela;
}
public String getTelefono() {
return telefono;
}
}
// Clase Contenedores
public class Contenedores {
private Estudiante[] listaEstudiante;
private Academico[] listaAcademico;
private Administrativo[] listaAdministrativo;
public Contenedores() {
this.listaEstudiante = new Estudiante[5];
this.listaAcademico = new Academico[5];
this.listaAdministrativo = new Administrativo[5];
}
public void agregarEstudiante(Estudiante estudiante, int posicion) {
if (posicion >= 0 && posicion < listaEstudiante.length) {
listaEstudiante[posicion] = estudiante;
} else {
System.out.println("Posición fuera de rango");
}
}
public void agregarAcademico(Academico academico, int posicion) {
if (posicion >= 0 && posicion < listaAcademico.length) {
listaAcademico[posicion] = academico;
} else {
System.out.println("Posición fuera de rango");
}
}
public void agregarAdministrativo(Administrativo administrativo, int posicion) {
if (posicion >= 0 && posicion < listaAdministrativo.length) {
listaAdministrativo[posicion] = administrativo;
} else {
System.out.println("Posición fuera de rango");
}
}
public void mostrarEstudiantes() {
for (int i = 0; i < listaEstudiante.length; i++) {
if (listaEstudiante[i] != null) {
System.out.println("Estudiante " + (i + 1));
System.out.println("Nombre: " + listaEstudiante[i].getNombre());
System.out.println("Cédula: " + listaEstudiante[i].getCedula());
System.out.println("Carrera: " + listaEstudiante[i].getCarrera());
System.out.println("Carnet: " + listaEstudiante[i].getCarnet());
System.out.println();
}
}
}
public void mostrarAcademicos() {
for (int i = 0; i < listaAcademico.length; i++) {
if (listaAcademico[i] != null) {
System.out.println("Académico " + (i + 1));
System.out.println("Nombre: " + listaAcademico[i].getNombre());
System.out.println("Cédula: " + listaAcademico[i].getCedula());
System.out.println("Salario: " + listaAcademico[i].getSalario());
System.out.println("Escuela: " + listaAcademico[i].getEscuela());
System.out.println();
}
}
}
public void mostrarAdministrativos() {
for (int i = 0; i < listaAdministrativo.length; i++) {
if (listaAdministrativo[i] != null) {
System.out.println("Administrativo " + (i + 1));
System.out.println("Nombre: " + listaAdministrativo[i].getNombre());
System.out.println("Cédula: " + listaAdministrativo[i].getCedula());
System.out.println("Salario: " + listaAdministrativo[i].getSalario());
System.out.println("Escuela: " + listaAdministrativo[i].getEscuela());
System.out.println("Teléfono: " + listaAdministrativo[i].getTelefono());
System.out.println();
}
}
}
}
public class Main {
public static void main(String[] args) {
Contenedores contenedores = new Contenedores();
Estudiante estudiante1 = new Estudiante("Juan Pérez", "123456789", "Ingeniería en Sistemas", "12345");
Estudiante estudiante2 = new Estudiante("María Gómez", "987654321", "Ingeniería en Electrónica", "67890");
contenedores.agregarEstudiante(estudiante1, 0);
contenedores.agregarEstudiante(estudiante2, 1);
Academico academico1 = new Academico("Pedro López", "111111111", 50000.0, "Universidad de la República");
Academico academico2 = new Academico("Ana Rodríguez", "222222222", 60000.0, "Universidad de la República");
contenedores.agregarAcademico(academico1, 0);
contenedores.agregarAcademico(academico2, 1);
Administrativo administrativo1 = new Administrativo("Carlos Díaz", "333333333", 40000.0, "Universidad de la República", "123456789");
Administrativo administrativo2 = new Administrativo("Lucía Martínez", "444444444", 45000.0, "Universidad de la República", "987654321");
contenedores.agregarAdministrativo(administrativo1, 0);
contenedores.agregarAdministrativo(administrativo2, 1);
contenedores.mostrarEstudiantes();
contenedores.mostrarAcademicos();
contenedores.mostrarAdministrativos();
}
}
```
Este código define las clases `Persona`, `Estudiante`, `Academico` y `Administrativo` con sus respectivos atributos y métodos. La clase `Contenedores` permite almacenar y mostrar estudiantes, académicos y administrativos. En el método `main` se crean objetos de cada tipo y se agregan a la clase `Contenedores` para mostrarlos posteriormente.
Aquí te muestro un ejemplo de cómo podrías implementar el menú principal y los submenús en Java:
```java
import java.util.ArrayList;
import java.util.Scanner;
class Estudiante {
private String cedula;
private String nombre;
private String telefono;
private String direccion;
public Estudiante(String cedula, String nombre, String telefono, String direccion) {
this.cedula = cedula;
this.nombre = nombre;
this.telefono = telefono;
this.direccion = direccion;
}
public String getCedula() {
return cedula;
}
public String getNombre() {
return nombre;
}
public String getTelefono() {
return telefono;
}
public String getDireccion() {
return direccion;
}
}
class FuncionarioAcademico {
private String cedula;
private String nombre;
private String telefono;
private String direccion;
public FuncionarioAcademico(String cedula, String nombre, String telefono, String direccion) {
this.cedula = cedula;
this.nombre = nombre;
this.telefono = telefono;
this.direccion = direccion;
}
public String getCedula() {
return cedula;
}
public String getNombre() {
return nombre;
}
public String getTelefono() {
return telefono;
}
public String getDireccion() {
return direccion;
}
}
class FuncionarioAdministrativo {
private String cedula;
private String nombre;
private String telefono;
private String direccion;
public FuncionarioAdministrativo(String cedula, String nombre, String telefono, String direccion) {
this.cedula = cedula;
this.nombre = nombre;
this.telefono = telefono;
this.direccion = direccion;
}
public String getCedula() {
return cedula;
}
public String getNombre() {
return nombre;
}
public String getTelefono() {
return telefono;
}
public String getDireccion() {
return direccion;
}
}
public class Main {
private static ArrayList<Estudiante> estudiantes = new ArrayList<>();
private static ArrayList<FuncionarioAcademico> funcionariosAcademicos = new ArrayList<>();
private static ArrayList<FuncionarioAdministrativo> funcionariosAdministrativos = new ArrayList<>();
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int opcion;
while (true) {
System.out.println("Menú 1 [Clase Principal]");
System.out.println("Seleccione una opción");
System.out.println("1. Mantenimiento de Estudiante");
System.out.println("2. Mantenimiento de funcionario Académico");
System.out.println("3. Mantenimiento de funcionario Administrativo");
System.out.println("4. Salir");
opcion = scanner.nextInt();
scanner.nextLine(); // Consume el salto de línea
switch (opcion) {
case 1:
subMenuEstudiante(scanner);
break;
case 2:
subMenuFuncionarioAcademico(scanner);
break;
case 3:
subMenuFuncionarioAdministrativo(scanner);
break;
case 4:
System.out.println("Saliendo del programa...");
return;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
}
}
private static void subMenuEstudiante(Scanner scanner) {
int opcion;
while (true) {
System.out.println("Submenú Estudiante");
System.out.println("Seleccione una opción");
System.out.println("1. Agregar Estudiante");
System.out.println("2. Eliminar Estudiante");
System.out.println("3. Buscar Estudiante");
System.out.println("4. Salir");
opcion = scanner.nextInt();
scanner.nextLine(); // Consume el salto de línea
switch (opcion) {
case 1:
agregarEstudiante(scanner);
break;
case 2:
eliminarEstudiante(scanner);
break;
case 3:
buscarEstudiante(scanner);
break;
case 4:
System.out.println("Saliendo del submenú...");
return;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
}
}
private static void subMenuFuncionarioAcademico(Scanner scanner) {
int opcion;
while (true) {
System.out.println("Submenú Funcionario Académico");
System.out.println("Seleccione una opción");
System.out.println("1. Agregar Funcionario Académico");
System.out.println("2. Eliminar Funcionario Académico");
System.out.println("3. Buscar Funcionario Académico");
System.out.println("4. Salir");
opcion = scanner.nextInt();
scanner.nextLine(); // Consume el salto de línea
switch (opcion) {
case 1:
agregarFuncionarioAcademico(scanner);
break;
case 2:
eliminarFuncionarioAcademico(scanner);
break;
case 3:
buscarFuncionarioAcademico(scanner);
break;
case 4:
System.out.println("Saliendo del submenú...");
return;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
}
}
private static void subMenuFuncionarioAdministrativo(Scanner scanner) {
int opcion;
while (true) {
System.out.println("Submenú Funcionario Administrativo");
System.out.println("Seleccione una opción");
System.out.println("1. Agregar Funcionario Administrativo");
System.out.println("2. Eliminar Funcionario Administrativo");
System.out.println("3. Buscar Funcionario Administrativo");
System.out.println("4. Salir");
opcion = scanner.nextInt();
scanner.nextLine(); // Consume el salto de línea
switch (opcion) {
case 1:
agregarFuncionarioAdministrativo(scanner);
break;
case 2:
eliminarFuncionarioAdministrativo(scanner);
break;
case 3:
buscarFuncionarioAdministrativo(scanner);
break;
case 4:
System.out.println("Saliendo del submenú...");
return;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
}
}
private static void agregarEstudiante(Scanner scanner) {
if (estudiantes.size() < 5) {
System.out.println("Ingrese la cédula del estudiante:");
String cedula = scanner.nextLine();
System.out.println("Ingrese el nombre del estudiante:");
String nombre = scanner.nextLine();
System.out.println("Ingrese el teléfono del estudiante:");
String telefono = scanner.nextLine();
System.out.println("Ingrese la dirección del estudiante:");
String direccion = scanner.nextLine();
estudiantes.add(new Estudiante(cedula, nombre, telefono, direccion));
System.out.println("Estudiante agregado con éxito.");
} else {
System.out.println("No hay espacio disponible para agregar más estudiantes.");
}
}
private static void eliminarEstudiante(Scanner scanner) {
if (!estudiantes.isEmpty()) {
System.out.println("Seleccione el estudiante a eliminar:");
for (int i = 0; i < estudiantes.size(); i++) {
System.out.println((i + 1) + ". " + estudiantes.get(i).getNombre());
}
int opcion = scanner.nextInt();
scanner.nextLine(); // Consume el salto de línea
if (opcion > 0 && opcion <= estudiantes.size()) {
estudiantes.remove(opcion - 1);
System.out.println("Estudiante eliminado con éxito.");
} else {
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} else {
System.out.println("No hay estudiantes para eliminar.");
}
}
private static void buscarEstudiante(Scanner scanner) {
if (!estudiantes.isEmpty()) {
System.out.println("Ingrese la cédula del estudiante a buscar:");
String cedula = scanner.nextLine();
for (Estudiante estudiante : estudiantes) {
if (estudiante.getCedula().equals(cedula)) {
System.out.println("Estudiante encontrado:");
System.out.println("Nombre: " + estudiante.getNombre());
System.out.println("Teléfono: " + estudiante.getTelefono());
System.out.println("Dirección: " + estudiante.getDireccion());
return;
}
}
System.out.println("Estudiante no encontrado.");
} else {
System.out.println("No hay estudiantes para buscar.");
}
}
private static void agregarFuncionarioAcademico(Scanner scanner) {
if (funcionariosAcademicos.size() < 5) {
System.out.println("Ingrese la cédula del funcionario académico:");
String cedula = scanner.nextLine();
System.out.println("Ingrese el nombre del funcionario académico:");
String nombre = scanner.nextLine();
System.out.println("Ingrese el teléfono del funcionario académico:");
String telefono = scanner.nextLine();
System.out.println("Ingrese la dirección del funcionario académico:");
String direccion = scanner.nextLine();
funcionariosAcademicos.add(new FuncionarioAcademico(cedula, nombre, telefono, direccion));
System.out.println("Funcionario académico agregado con éxito.");
} else {
System.out.println("No hay espacio disponible para agregar más funcionarios académicos.");
}
}
private static void eliminarFuncionarioAcademico(Scanner scanner) {
if (!funcionariosAcademicos.isEmpty()) {
System.out.println("Seleccione el funcionario académico a eliminar:");
for (int i = 0; i < funcionariosAcademicos.size(); i++) {
System.out.println((i + 1) + ". " + funcionariosAcademicos.get(i).getNombre());
}
int opcion = scanner.nextInt();
scanner.nextLine(); // Consume el salto de línea
if (opcion > 0 && opcion <= funcionariosAcademicos.size()) {
funcionariosAcademicos.remove(opcion - 1);
System.out.println("Funcionario académico eliminado con éxito.");
} else {
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} else {
System.out.println("No hay funcionarios académicos para eliminar.");
}
}
private static void buscarFuncionarioAcademico(Scanner scanner) {
if (!funcionariosAcademicos.isEmpty()) {
System.out.println("Ingrese la cédula del funcionario académico a buscar:");
String cedula = scanner.nextLine();
for (FuncionarioAcademico funcionarioAcademico : funcionariosAcademicos) {
if (funcionarioAcademico.getCedula().equals(cedula)) {
System.out.println("Funcionario académico encontrado:");
System.out.println("Nombre: " + funcionarioAcademico.getNombre());
System.out.println("Teléfono: " + funcionarioAcademico.getTelefono());
System.out.println("Dirección: " + funcionarioAcademico.getDireccion());
return;
}
}
System.out.println("Funcionario académico no encontrado.");
} else {
System.out.println("No hay funcionarios académicos para buscar.");
}
}
private static void agregarFuncionarioAdministrativo(Scanner scanner) {
if (funcionariosAdministrativos.size() < 5) {
System.out.println("Ingrese la cédula del funcionario administrativo:");
String cedula = scanner.nextLine();
System.out.println("Ingrese el nombre del funcionario administrativo:");
String nombre = scanner.nextLine();
System.out.println("Ingrese el teléfono del funcionario administrativo:");
String telefono = scanner.nextLine();
System.out.println("Ingrese la dirección del funcionario administrativo:");
String direccion = scanner.nextLine();
funcionariosAdministrativos.add(new FuncionarioAdministrativo(cedula, nombre, telefono, direccion));
System.out.println("Funcionario administrativo agregado con éxito.");
} else {
System.out.println("No hay espacio disponible para agregar más funcionarios administrativos.");
}
}
private static void eliminarFuncionarioAdministrativo(Scanner scanner) {
if (!funcionariosAdministrativos.isEmpty()) {
System.out.println("Seleccione el funcionario administrativo a eliminar:");
for (int i = 0; i < funcionariosAdministrativos.size(); i++) {
System.out.println((i + 1) + ". " + funcionariosAdministrativos.get(i).getNombre());
}
int opcion = scanner.nextInt();
scanner.nextLine(); // Consume el salto de línea
if (opcion > 0 && opcion <= funcionariosAdministrativos.size()) {
funcionariosAdministrativos.remove(opcion - 1);
System.out.println("Funcionario administrativo eliminado con éxito.");
} else {
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
}
} else {
System.out.println("No hay funcionarios administrativos para eliminar.");
}
}
private static void buscarFuncionarioAdministrativo(Scanner scanner) {
if (!funcionariosAdministrativos.isEmpty()) {
System.out.println("Ingrese la cédula del funcionario administrativo a buscar:");
String cedula = scanner.nextLine();
for (FuncionarioAdministrativo funcionarioAdministrativo : funcionariosAdministrativos) {
if (funcionarioAdministrativo.getCedula().equals(cedula)) {
System.out.println("Funcionario administrativo encontrado:");
System.out.println("Nombre: " + funcionarioAdministrativo.getNombre());
System.out.println("Teléfono: " + funcionarioAdministrativo.getTelefono());
System.out.println("Dirección: " + funcionarioAdministrativo.getDireccion());
return;
}
}
System.out.println("Funcionario administrativo no encontrado.");
} else {
System.out.println("No hay funcionarios administrativos para buscar.");
}
}
}
```
Este código define las clases `Estudiante`, `Func
Aquí te muestro un ejemplo de código en Java que cumple con las especificaciones que me proporcionaste:
```java
import java.util.Scanner;
public class FallaCorreo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Ingrese el nombre del estudiante:");
String nombre = scanner.nextLine();
System.out.println("Ingrese los apellidos del estudiante:");
String apellidos = scanner.nextLine();
System.out.println("Ingrese la cuenta de correo del estudiante (formato: nombre.apellido.apellido@est.uned.ac.cr):");
String correo = scanner.nextLine();
System.out.println("Ingrese la descripción de la falla:");
String descripcion = scanner.nextLine();
System.out.println("Ingrese el correo alterno:");
String correoAlterno = scanner.nextLine();
System.out.println("Ingrese el número de teléfono:");
String telefono = scanner.nextLine();
// Validar formato de correo electrónico
if (!correo.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")) {
System.out.println("Formato de correo electrónico inválido.");
return;
}
// Registrar la falla
System.out.println("Se ha registrado la falla del correo electrónico del estudiante " + nombre + " " + apellidos + ".");
System.out.println("Se enviará información al correo alterno: " + correoAlterno);
// Mostrar nota de registro
System.out.println("Nota: Se ha registrado el caso con éxito. Se enviará información al correo alterno.");
}
}
```
Este código utiliza un `Scanner` para leer los datos del usuario y validar el formato de la cuenta de correo electrónico. Si el formato es inválido, muestra un mensaje de error y termina el programa. De lo contrario, registra la falla y muestra una nota de registro.
Recuerda que este es solo un ejemplo básico y que en un entorno real, sería recomendable utilizar una base de datos para almacenar la información de la falla y enviar un correo electrónico real al correo alterno.
**Nota:** Para enviar un correo electrónico real, necesitarías utilizar una biblioteca de correo electrónico como JavaMail o una API de correo electrónico como SendGrid. Este código solo muestra una nota de registro en la consola.
Aquí te muestro un ejemplo de cómo crear un menú en Java:
```java
import java.util.Scanner;
public class Menu {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int opcion;
do {
System.out.println("Menú principal");
System.out.println("1. Opción 1");
System.out.println("2. Opción 2");
System.out.println("3. Opción 3");
System.out.println("4. Salir");
System.out.print("Ingrese su opción: ");
opcion = scanner.nextInt();
switch (opcion) {
case 1:
System.out.println("Opción 1 seleccionada");
// Código para la opción 1
break;
case 2:
System.out.println("Opción 2 seleccionada");
// Código para la opción 2
break;
case 3:
System.out.println("Opción 3 seleccionada");
// Código para la opción 3
break;
case 4:
System.out.println("Adiós!");
break;
default:
System.out.println("Opción inválida. Por favor, ingrese un número entre 1 y 4.");
}
} while (opcion != 4);
}
}
```
En este ejemplo, creamos un menú con 4 opciones y un bucle `do-while` para que el usuario pueda seleccionar una opción y luego volver a seleccionar una opción hasta que elija la opción de salir.
El `switch` se utiliza para evaluar la opción seleccionada por el usuario y ejecutar el código correspondiente.
Recuerda que debes reemplazar el código comentado (`// Código para la opción 1`, etc.) con el código real que deseas ejecutar para cada opción.
También es importante mencionar que este es un ejemplo básico y puedes personalizarlo según tus necesidades.
**Ejemplo de uso:**
1. Corre el programa y verás el menú principal.
2. Ingresa un número entre 1 y 4 para seleccionar una opción.
3. El programa ejecutará el código correspondiente a la opción seleccionada.
4. Si deseas salir, ingresa la opción 4.
5. El programa se cerrará.
Aquí te dejo un ejemplo de código en Java que cumple con las especificaciones que me proporcionaste:
```java
import java.util.InputMismatchException;
import java.util.Scanner;
public class RegistrarNota {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("Ingrese la cédula del estudiante: ");
String cedula = scanner.nextLine();
if (validarCedula(cedula)) {
break;
} else {
System.out.println("Error: La cédula debe ser un número de 10 dígitos. Por favor, inténtelo de nuevo.");
}
}
while (true) {
System.out.print("Ingrese el código de materia (5 caracteres): ");
String codigoMateria = scanner.nextLine();
if (validarCodigoMateria(codigoMateria)) {
break;
} else {
System.out.println("Error: El código de materia debe ser un string de 5 caracteres. Por favor, inténtelo de nuevo.");
}
}
while (true) {
System.out.print("Ingrese la nota obtenida (número entre 1 y 100): ");
String nota = scanner.nextLine();
if (validarNota(nota)) {
break;
} else {
System.out.println("Error: La nota debe ser un número entre 1 y 100. Por favor, inténtelo de nuevo.");
}
}
int notaInt = Integer.parseInt(nota);
String resultado = obtenerResultado(notaInt);
System.out.println("La nota del estudiante es: " + notaInt);
System.out.println(resultado);
}
private static boolean validarCedula(String cedula) {
if (cedula.length() != 10 || !cedula.matches("\\d+")) {
return false;
}
return true;
}
private static boolean validarCodigoMateria(String codigoMateria) {
if (codigoMateria.length() != 5 || !codigoMateria.matches("[a-zA-Z0-9]+")) {
return false;
}
return true;
}
private static boolean validarNota(String nota) {
try {
int notaInt = Integer.parseInt(nota);
if (notaInt < 1 || notaInt > 100) {
return false;
}
} catch (NumberFormatException e) {
return false;
}
return true;
}
private static String obtenerResultado(int nota) {
if (nota >= 70) {
return "Ha ganado el curso.";
} else if (nota < 65) {
return "Ha reprobado el curso.";
} else {
return "Debe realizar examen extraordinario.";
}
}
}
```
Este código utiliza un bucle `while` para solicitar la cédula, código de materia y nota hasta que se ingrese un valor válido. Luego, utiliza un método `obtenerResultado` para determinar el resultado final basado en la nota obtenida.
A continuación, te proporciono un ejemplo de cómo podrías implementar el módulo en Java:
```java
import java.util.Scanner;
class Estudiante {
private String nombre;
private int cantidadMateriasMatriculadasAnterior;
private double[] notasAnteriores;
private int cantidadCreditosMatriculadosActual;
private double promedioPonderado;
public Estudiante(String nombre, int cantidadMateriasMatriculadasAnterior, double[] notasAnteriores, int cantidadCreditosMatriculadosActual) {
this.nombre = nombre;
this.cantidadMateriasMatriculadasAnterior = cantidadMateriasMatriculadasAnterior;
this.notasAnteriores = notasAnteriores;
this.cantidadCreditosMatriculadosActual = cantidadCreditosMatriculadosActual;
this.promedioPonderado = calcularPromedioPonderado();
}
private double calcularPromedioPonderado() {
double suma = 0;
for (int i = 0; i < notasAnteriores.length; i++) {
suma += notasAnteriores[i] * (i + 1);
}
return suma / (notasAnteriores.length * (notasAnteriores.length + 1) / 2);
}
public boolean esCandidatoABeca() {
return cantidadMateriasMatriculadasAnterior >= 12 && promedioPonderado > 89 && cantidadCreditosMatriculadosActual >= 12;
}
public String getNombre() {
return nombre;
}
public int getCantidadMateriasMatriculadasAnterior() {
return cantidadMateriasMatriculadasAnterior;
}
public double getPromedioPonderado() {
return promedioPonderado;
}
public int getCantidadCreditosMatriculadosActual() {
return cantidadCreditosMatriculadosActual;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Ingrese el nombre del estudiante: ");
String nombre = scanner.nextLine();
System.out.print("Ingrese la cantidad de materias matriculadas en el semestre anterior: ");
int cantidadMateriasMatriculadasAnterior = scanner.nextInt();
scanner.nextLine(); // Consumir el salto de línea
System.out.print("Ingrese la cantidad de notas del semestre anterior: ");
int cantidadNotas = scanner.nextInt();
scanner.nextLine(); // Consumir el salto de línea
double[] notasAnteriores = new double[cantidadNotas];
for (int i = 0; i < cantidadNotas; i++) {
System.out.print("Ingrese la nota " + (i + 1) + " del semestre anterior: ");
notasAnteriores[i] = scanner.nextDouble();
scanner.nextLine(); // Consumir el salto de línea
}
System.out.print("Ingrese la cantidad de créditos matriculados actualmente: ");
int cantidadCreditosMatriculadosActual = scanner.nextInt();
scanner.nextLine(); // Consumir el salto de línea
Estudiante estudiante = new Estudiante(nombre, cantidadMateriasMatriculadasAnterior, notasAnteriores, cantidadCreditosMatriculadosActual);
System.out.println("Reporte del estudiante:");
System.out.println("Nombre: " + estudiante.getNombre());
System.out.println("Cantidad de materias matriculadas en el semestre anterior: " + estudiante.getCantidadMateriasMatriculadasAnterior());
System.out.println("Promedio ponderado: " + estudiante.getPromedioPonderado());
System.out.println("Cantidad de créditos matriculados actualmente: " + estudiante.getCantidadCreditosMatriculadosActual());
if (estudiante.esCandidatoABeca()) {
System.out.println("El estudiante es candidato a beca.");
} else {
System.out.println("El estudiante no es candidato a beca.");
}
}
}
```
Este código define una clase `Estudiante` que almacena los datos del estudiante y tiene un método `esCandidatoABeca()` que verifica si el estudiante cumple con los requisitos para ser candidato a beca. La clase `Main` es la clase principal que solicita los datos al usuario y crea un objeto `Estudiante` con esos datos. Luego, imprime un reporte con los datos del estudiante y indica si es candidato a beca o no.
A continuación, te proporciono un ejemplo de código en Java que cumple con las instrucciones proporcionadas. Este código utiliza NetBeans como entorno de desarrollo.
**Clase Estudiante**
```java
public class Estudiante {
private String nombre;
private int cantidadMateriasMatriculadas;
private double[] notas;
private int cantidadCreditosMatriculados;
public Estudiante(String nombre, int cantidadMateriasMatriculadas, double[] notas, int cantidadCreditosMatriculados) {
this.nombre = nombre;
this.cantidadMateriasMatriculadas = cantidadMateriasMatriculadas;
this.notas = notas;
this.cantidadCreditosMatriculados = cantidadCreditosMatriculados;
}
public String getNombre() {
return nombre;
}
public int getCantidadMateriasMatriculadas() {
return cantidadMateriasMatriculadas;
}
public double[] getNotas() {
return notas;
}
public int getCantidadCreditosMatriculados() {
return cantidadCreditosMatriculados;
}
public double calcularPromedioPonderado() {
double suma = 0;
for (int i = 0; i < notas.length; i++) {
suma += notas[i] * (i + 1);
}
return suma / (notas.length * (notas.length + 1) / 2);
}
public boolean esCandidatoABeca() {
return cantidadMateriasMatriculadas >= 12 && calcularPromedioPonderado() > 89 && cantidadCreditosMatriculados >= 12;
}
}
```
**Clase Main**
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Main {
private JFrame frame;
private JTextField nombreField;
private JTextField cantidadMateriasField;
private JTextField cantidadCreditosField;
private JTextArea notasArea;
private JButton calcularButton;
private JLabel resultadoLabel;
public Main() {
frame = new JFrame("Validación de Beca");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLayout(new BorderLayout());
JPanel panel = new JPanel();
panel.setLayout(new GridLayout(5, 2));
panel.add(new JLabel("Nombre:"));
nombreField = new JTextField();
panel.add(nombreField);
panel.add(new JLabel("Cantidad de materias matriculadas:"));
cantidadMateriasField = new JTextField();
panel.add(cantidadMateriasField);
panel.add(new JLabel("Notas (separadas por comas):"));
notasArea = new JTextArea(5, 20);
panel.add(new JScrollPane(notasArea));
panel.add(new JLabel("Cantidad de créditos matriculados:"));
cantidadCreditosField = new JTextField();
panel.add(cantidadCreditosField);
calcularButton = new JButton("Calcular");
calcularButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
calcular();
}
});
panel.add(new JLabel(""));
panel.add(calcularButton);
frame.add(panel, BorderLayout.CENTER);
resultadoLabel = new JLabel("");
frame.add(resultadoLabel, BorderLayout.SOUTH);
frame.pack();
frame.setVisible(true);
}
private void calcular() {
try {
String nombre = nombreField.getText();
int cantidadMaterias = Integer.parseInt(cantidadMateriasField.getText());
String[] notasStr = notasArea.getText().split(",");
double[] notas = new double[notasStr.length];
for (int i = 0; i < notasStr.length; i++) {
notas[i] = Double.parseDouble(notasStr[i].trim());
}
int cantidadCreditos = Integer.parseInt(cantidadCreditosField.getText());
Estudiante estudiante = new Estudiante(nombre, cantidadMaterias, notas, cantidadCreditos);
String resultado = "Nombre: " + estudiante.getNombre() + "\n";
resultado += "Cantidad de materias matriculadas: " + estudiante.getCantidadMateriasMatriculadas() + "\n";
resultado += "Promedio ponderado: " + estudiante.calcularPromedioPonderado() + "\n";
resultado += "Cantidad de créditos matriculados: " + estudiante.getCantidadCreditosMatriculados() + "\n";
resultado += "Es candidato a beca: " + estudiante.esCandidatoABeca();
resultadoLabel.setText(resultado);
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(frame, "Error: los campos deben ser números enteros o decimales.");
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new Main();
}
});
}
}
```
Este código crea una ventana con campos para ingresar la información del estudiante, incluyendo el nombre, cantidad de materias matriculadas, notas y cantidad de créditos matriculados. Al presionar el botón "Calcular", se calcula el promedio ponderado y se verifica si el estudiante es candidato a beca. El resultado se muestra en la ventana.
Aquí te muestro un ejemplo de código en Java que cumple con las especificaciones que me proporcionaste:
```java
import java.util.InputMismatchException;
import java.util.Scanner;
public class RegistrarNota {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
boolean continuar = true;
while (continuar) {
System.out.println("Ingrese la cédula del estudiante:");
String cedula = scanner.nextLine();
while (!esValidaCedula(cedula)) {
System.out.println("Error: La cédula debe ser un número de 10 dígitos. Por favor, ingrese nuevamente.");
cedula = scanner.nextLine();
}
System.out.println("Ingrese el código de materia (5 caracteres):");
String codigoMateria = scanner.nextLine();
while (!esValidoCodigoMateria(codigoMateria)) {
System.out.println("Error: El código de materia debe ser un string de 5 caracteres. Por favor, ingrese nuevamente.");
codigoMateria = scanner.nextLine();
}
System.out.println("Ingrese la nota obtenida:");
String nota = scanner.nextLine();
while (!esValidaNota(nota)) {
System.out.println("Error: La nota debe ser un número entre 1 y 100. Por favor, ingrese nuevamente.");
nota = scanner.nextLine();
}
int notaInt = Integer.parseInt(nota);
String resultado = obtenerResultado(notaInt);
System.out.println("La nota del estudiante es: " + notaInt);
System.out.println(resultado);
System.out.println("¿Desea registrar otra nota? (s/n)");
String respuesta = scanner.nextLine().toLowerCase();
while (!respuesta.equals("s") && !respuesta.equals("n")) {
System.out.println("Error: Por favor, ingrese 's' para sí o 'n' para no.");
respuesta = scanner.nextLine().toLowerCase();
}
continuar = respuesta.equals("s");
}
scanner.close();
}
private static boolean esValidaCedula(String cedula) {
return cedula.matches("\\d{10}");
}
private static boolean esValidoCodigoMateria(String codigoMateria) {
return codigoMateria.matches("[a-zA-Z0-9]{5}");
}
private static boolean esValidaNota(String nota) {
try {
int notaInt = Integer.parseInt(nota);
return notaInt >= 1 && notaInt <= 100;
} catch (NumberFormatException e) {
return false;
}
}
private static String obtenerResultado(int nota) {
if (nota > 69) {
return "Ha ganado el curso.";
} else if (nota < 65) {
return "Ha reprobado el curso.";
} else {
return "Debe realizar examen extraordinario.";
}
}
}
```
Este código utiliza un bucle `while` para permitir al usuario registrar múltiples notas. En cada iteración, se solicita la cédula del estudiante, el código de materia y la nota obtenida. Si el usuario ingresa algo inválido, se muestra un mensaje de error y se le pide que ingrese nuevamente.
La función `esValidaCedula` verifica si la cédula es un número de 10 dígitos. La función `esValidoCodigoMateria` verifica si el código de materia es un string de 5 caracteres. La función `esValidaNota` verifica si la nota es un número entre 1 y 100.
La función `obtenerResultado` devuelve una leyenda que indica si el estudiante ha ganado el curso, ha reprobado el curso o debe realizar examen extraordinario.
Finalmente, se muestra una leyenda con el resultado de la nota y se le pide al usuario si desea registrar otra nota. Si el usuario ingresa 's', se repite el proceso. Si ingresa 'n', se cierra el programa.
