Este capítulo se centrará en dos aspectos importantes de la programación en Java: el tratamiento de excepciones y el manejo de archivos y flujos. Estos conceptos son fundamentales para escribir programas robustos y capaces de interactuar con archivos y flujos de datos.
4.1. Tratamiento de Excepciones
Las excepciones son eventos inesperados que pueden ocurrir durante la ejecución de un programa. Java proporciona un sistema de manejo de excepciones para detectar, informar y manejar excepciones de manera controlada.
Ejemplo 4.1.1: Tratamiento de Excepciones
public class DivisionPorCero {
public static void main(String[] args) {
int numerador = 5;
int denominador = 0;
try {
int resultado = numerador / denominador;
System.out.println("Resultado: " + resultado);
} catch (ArithmeticException e) {
System.out.println("Error: División por cero.");
}
}
}
Ejercicio 4.1.1: Tratamiento de Excepciones
Crea un programa que solicite al usuario dos números y realice una división. Implementa el manejo de excepciones para evitar la división por cero.
4.2. Manejo de Archivos y Flujos
El manejo de archivos es fundamental para leer y escribir datos en archivos. Java proporciona clases y flujos para realizar estas operaciones de manera efectiva.
Ejemplo 4.2.1: Lectura y Escritura en Archivos
import java.io.*;
public class ManejoArchivos {
public static void main(String[] args) {
try {
// Escritura en archivo
FileWriter escritor = new FileWriter("archivo.txt");
escritor.write("Hola, mundo");
escritor.close();
// Lectura desde archivo
FileReader lector = new FileReader("archivo.txt");
int caracter;
while ((caracter = lector.read()) != -1) {
System.out.print((char) caracter);
}
lector.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Ejercicio 4.2.1: Manejo de Archivos y Flujos
Crea un programa que escriba una lista de nombres en un archivo de texto y luego lea y muestre esos nombres en la consola.
4.3. Serialización y Deserialización de Objetos
La serialización se utiliza para convertir objetos en una secuencia de bytes que se pueden almacenar en archivos o transmitir a través de la red. La deserialización es el proceso inverso, que convierte la secuencia de bytes en un objeto.
Ejemplo 4.3.1: Serialización y Deserialización
import java.io.*;
class Persona implements Serializable {
private String nombre;
private int edad;
Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public String toString() {
return "Nombre: " + nombre + ", Edad: " + edad;
}
}
public class Serializacion {
public static void main(String[] args) {
// Serialización
try {
FileOutputStream archivoSalida = new FileOutputStream("persona.ser");
ObjectOutputStream objetoSalida = new ObjectOutputStream(archivoSalida);
Persona persona = new Persona("Juan", 30);
objetoSalida.writeObject(persona);
objetoSalida.close();
} catch (IOException e) {
e.printStackTrace();
}
// Deserialización
try {
FileInputStream archivoEntrada = new FileInputStream("persona.ser");
ObjectInputStream objetoEntrada = new ObjectInputStream(archivoEntrada);
Persona personaDeserializada = (Persona) objetoEntrada.readObject();
objetoEntrada.close();
System.out.println(personaDeserializada);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
Ejercicio 4.3.1: Serialización y Deserialización
Crea una clase Producto que implemente la interfaz Serializable y contiene información sobre productos como nombre, precio, y cantidad en stock. Realiza la serialización y deserialización de un objeto Producto en un archivo.
Resumen del Capítulo y Ejercicios
- Resumen de los conceptos clave de este capítulo, incluyendo el tratamiento de excepciones, el manejo de archivos y flujos, y la serialización de objetos.
- Completa los ejercicios proporcionados para practicar y fortalecer tu comprensión de estos conceptos importantes en Java.
Este capítulo te ha proporcionado las herramientas necesarias para escribir programas en Java que sean más robustos y capaces de interactuar con archivos y flujos de datos de manera efectiva.
Respuesta ejercicio 4.1.1:
Aquí tienes el código y los pasos para resolver el ejercicio de crear un programa que solicita al usuario dos números y realiza una división, con el manejo de excepciones para evitar la división por cero.
Paso 1: Creación del Programa
Primero, crea un programa Java que solicite al usuario dos números y realice la división. Utiliza un bloque try y catch para manejar las excepciones.
import java.util.Scanner;
public class DivisionConExcepciones {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Ingrese el numerador: ");
int numerador = scanner.nextInt();
System.out.print("Ingrese el denominador: ");
int denominador = scanner.nextInt();
try {
int resultado = numerador / denominador;
System.out.println("Resultado de la división: " + resultado);
} catch (ArithmeticException e) {
System.out.println("Error: División por cero no permitida.");
}
scanner.close();
}
}
Paso 2: Ejecución del Programa
Al ejecutar el programa, se le pedirá al usuario que ingrese el numerador y el denominador. El programa intentará realizar la división y, si el denominador es cero, atrapará la excepción ArithmeticException y mostrará un mensaje de error en lugar de lanzar una excepción no manejada.
Resultado Esperado:
- Si se ingresa un denominador distinto de cero, el programa mostrará el resultado de la división.
- Si se ingresa un denominador igual a cero, el programa mostrará un mensaje de error.
Este programa demuestra cómo manejar excepciones de división por cero de manera controlada para que el programa no se bloquee en caso de error.
Respuesta ejercicio 4.2.1:
Para resolver el ejercicio de crear un programa que escriba una lista de nombres en un archivo de texto y luego lea y muestre esos nombres en la consola, sigue estos pasos:
Paso 1: Creación del Programa de Escritura
Primero, crea un programa Java que escriba una lista de nombres en un archivo de texto. Utilizaremos las clases FileWriter y BufferedWriter para realizar la escritura.
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class EscrituraArchivos {
public static void main(String[] args) {
String[] nombres = {"Juan", "María", "Pedro", "Ana"};
try {
BufferedWriter escritor = new BufferedWriter(new FileWriter("nombres.txt"));
for (String nombre : nombres) {
escritor.write(nombre);
escritor.newLine(); // Nueva línea para cada nombre
}
escritor.close();
System.out.println("Nombres escritos en el archivo.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Paso 2: Creación del Programa de Lectura
A continuación, crea un programa separado que lea los nombres del archivo y los muestre en la consola.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class LecturaArchivos {
public static void main(String[] args) {
try {
BufferedReader lector = new BufferedReader(new FileReader("nombres.txt"));
String linea;
while ((linea = lector.readLine()) != null) {
System.out.println(linea);
}
lector.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Paso 3: Ejecución del Programa de Escritura
Ejecuta el programa de escritura para crear el archivo «nombres.txt» con la lista de nombres.
Paso 4: Ejecución del Programa de Lectura
Luego, ejecuta el programa de lectura para abrir y leer el archivo «nombres.txt» y mostrar los nombres en la consola.
Resultado Esperado:
El programa de lectura mostrará los nombres en la consola, uno por línea, obtenidos del archivo de texto creado por el programa de escritura.
Este ejercicio demuestra cómo escribir y leer datos desde un archivo de texto en Java.
