Algoritmos y
Programación II
Manejo de Excepciones
Se emplean para detectar hechos excepcionales, como por ejemplo, errores que ocurren dentro de un método.
Las excepciones son elementos que almacenan información y la transmiten a través de la secuencia de llamadas de los métodos
hasta que sean recogidas por alguna rutina.
funcion1(){ … funcion2(){
…
funcion3(){ …}
Manejo de Excepciones
El código que eventualmente puede generar una excepción se encierra en un bloque try {…}.
try{
z = x/y; // puede producirse una excepción de división por cero }
Luego del bloque try {…} vienen los bloques catch {…} que son los que manejarán las excepciones que se produzcan. Se define un bloque catch por cada excepción que queramos manejar.
catch (ArithmeticException e){ System.out.println( e ); }
Manejo de Excepciones
import java.io.*;
public class DivideByTwo {
public static void main( String [ ] args ) {
BufferedReader in = new BufferedReader( new InputStreamReader( System.in)); int x;
String oneLine;
System.out.println( "Enter an integer: " ); try {
oneLine = in.readLine( ); // puede lanzar IOException
x = Integer.parseInt( oneLine ); // puede lanzar NumberFormatException
System.out.println( "Half of x is " + ( x / 2 ) ); }
catch(IOException e ){ System.out.println( e ); }
catch(NumberFormatException e ){ System.out.println( e ); }
} }
Manejo de Excepciones Si necesitamos que una parte de código se ejecute siempre, hayan
ocurrido o no excepciones entonces los encerramos en un bloque finally {…}.
public class Numeros{
public static void main( String [ ] args ) { int [] vector1;
vector1 = new int [5]; try{
for (int i = 0; i <8; i++){ vector1 [i] = i+2;
} }
catch (IndexOutOfBounds e) { System.out.println( e ); }
finally{ System.out.println( “Esto se imprime siempre” ); }
} }
Manejo de Excepciones En Java vienen predefinidas un conjunto de excepciones que
podemos elegir manejarlas o no. Si no las manejamos se propagan y el programa se interrumpe lanzando un mensaje de error que
identifica a la excepción lanzada.
Algoritmos y
Manejo de Excepciones
Otro tipo de excepciones estándar que vienen definidas en Java son las standard checked. Si un método puede lanzar una de estas
excepciones directa o indirectamente, debemos indicar de forma explícita esta situación incluyendo la cláusula throws.
Manejo de Excepciones Ejemplo:
public procesarFichero() throws IOException {
… // código donde puede ocurrir la excepción pero no la manejamos ... // por lo tanto se propaga hacia el método padre
}
public static void main( String [ ] args ) { try {
procesarFichero(); }
catch (IOException e) { System.out.println( e ); }
}
Manejo de Excepciones También podemos lanzar excepciones a propósito, para esto se utiliza la cláusula throw.
public metodoConExcepcion() throws Exception { throw new Exception(“Excepción lanzada”); }
public static void main( String [ ] args ) { try {
if (….) { metodoConExcepcion(); } else {….}
}
catch (Exception e) { System.out.println( e ); }
}
Entrada y Salida
La entrada y salida (E/S) se realiza en Java empleando el paquete java.io:
import java.oi.*;
public class DemThrow{
public static void procesarFichero(String archivo) throws IOException{ //implementación que propaga cualquier excepción hacia arriba
}
public static void main (String [] args){ for (i=0; i<args.legth; i++){
Try{ procesarFichero(args[i]); }
Catch (IOException e) { System.out.println(e);} }
} }
E/S
Los medios básicos de entrada y salida de datos son la consola (terminal) y los archivos.
En java existen 3 canales de E/S por consola:
System.in: entrada estándar (por teclado).
System.out: salida estándar (por pantalla).
System.err: salida de errores .
E/S
Para leer una línea de la entrada estándar (teclado) empleamos el método readLine y guardamos el resultado en un objeto de tipo String.
El método readLine lee hasta que encuentra un final de línea o el final del archivo. Los caracteres leídos (salvo el final de línea o de archivo) se devuelven como un nuevo String.
Para usar readLine, primero debemos crear un objeto
BufferedReader sobre un objeto InputStreamReader que a su vez se crea partiendo de System.in de la siguiente forma:
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
E/S
Para leer datos ingresados por consola usamos: BufferedReader in = new BufferedReader( new InputStreamReader( System.in ));
String unaLinea;
unaLinea = in.readLine();
Para impresión de datos en pantalla usamos: System.out.println( “esto es un dato”);
Para impresión de mensajes de error en pantalla usamos: System.err.println(“Número de CUIT inválido”);
E/S Ejemplo:
import java.io.*;
public class DividePorDos{
public static void main( String [ ] args ){
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int x;
String unaLinea;
System.out.println(“Escribe un entero: “); try{
unaLinea = in.readLine( );
x = Integer.parseInt( unaLinea );
System.out.println( "La mitad de x es " + ( x / 2 ) ) ; }
catch( Exception e ){ System.out.println( e); } }
}
E/S
Para generar el tipo primitivo int a partir de un String podemos usar el método estático parseInt de la clase Integer:
int x;
String unaLinea = “cinco”
x = Integer.parseInt( unaLinea );
Si la línea que leemos con readLine tiene mas de un elemento y queremos separarlos usamos un objeto StringTokenizer, que permite separar en tokens un String. Consruimos este objeto tomando como parámetro el String:
StringTokenizer str = new StringTokenizer(“mi String”);
Para usar la clase StringTokenizer debemos importar el paquete java.util.*: import java.util.* ;
E/S La clase StringTokenizer nos permite dividir un String en sub-Strings o tokens en base a uno o mas delimitadores.
Ejemplo de uso:
public class EjStringTokenizer {
public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader(new
InputStreamReader(System.in)); String unaLinea;
unaLinea = in.readLine();
StringTokenizer st = new StringTokenizer(unaLinea); while (st.hasMoreTokens()) {
System.out.println(st.nextToken()); }
} }
import java.io.*; E/S
import java.util.*; public class MaxTest{
public static void main( String args[ ] ){
BufferedReader in=new BufferedReader( new InputStreamReader( System.in) ); String unaLinea;
StringTokenizer str; int x, y;
System.out.println(“Introduzca 2 ints en una misma línea:” ) ; try{ unaLinea = in.readLine( ) ;
str = new StringTokenizer( unaLinea ) ; if( str.countTokens( ) != 2 ){
throw new NumberFormatException( ) ;} x = Integer.parseint( str.nextToken()) ; y = Integer.parseint( str.nextToken()) ;
System.out.println( "Max: " + Math.max( x,y)); }
catch( Exception e ){ System.err.println(“Error: se necesitan dos enteros" ) ; } }
}
E/S con Archivos
En Java las mismas operaciones que funcionan con la E/S por consola también funciona en la E/S con archivos.
Para trabajar con archivos construimos un objeto
BufferedReader, como lo hacíamos con la entrada por teclado, pero a partir de un objeto FileReader, como en el siguiente ejemplo:
FileReader elArchivo= new FileReader(“nombreArchivo”); BufferedReader lector = new BufferedReader(elArchivo); String unaLinea;
unaLinea = lector.readLine();
E/S con Archivos Ejemplo: Impresión en pantalla del contenido de un archivo
import java.io.*;
public class ContenidoFicheros {
public static void listarArchivo( String fileName ) { FileReader theFile;
BufferedReader fileIn = null; String oneLine;
System.out.println(“El Archivo: “+fileName+“ contiene:”); continua…
E/S con Archivos try {
theFile = new FileReader( fileName ); fileIn = new BufferedReader( theFile );
oneLine = fileIn.readLine( ); while(oneLine != null ) {
System.out.println( oneLine ); oneLine = fileIn.readLine( );} }
catch( Exception e )
{ System.out.println( e ); } finally{ // Cerramos el archivo if(fileIn != null )
fileIn.close( ); }
} continua…
E/S con Archivos
public static void main( String [ ] args ) { if( args.length == 0 )
System.out.println( "No files specified" ); for( int i = 0; i < args.length; i++ )
listFile( args[ i ] ); }
}
E/S con Archivos
Y para escribir caracteres en un archivo en Java utilizamos un objeto FileWriter y un objeto PrintWriter como en el siguiente ejemplo:
FileWriter elArchivo= new FileWriter (“nombreArchivo”); PrintWriter escritor= new PrintWriter (elArchivo);
escritor.println(“Lo que queremos escribir.”);
E/S con Archivos import java.io.*;
public class EscribeFichero{
public static void main(String[] args){ FileWriter fichero = null;
PrintWriter pw = null; try{
fichero = new FileWriter("C:/Users/Vale/Downloads/pruebaescri.txt");
pw = new PrintWriter(fichero);
for (int i = 0; i < 10; i++) { pw.println("Linea " + i); } } catch (Exception e) { e.printStackTrace();}
finally { try { // Nos asegurarnos que se cierra el archivo. if (null != fichero) { fichero.close(); }
} catch (Exception e2) { e2.printStackTrace(); } }
} }
public class AgregarTextoArchivo { E/S con Archivos public static void main(String[] args){
FileWriter fichero = null; PrintWriter pw = null; try{
fichero = new FileWriter("C:/Users/Vale/Downloads/pruebaescri.txt", true); pw = new PrintWriter(fichero);
pw.println("Linea agregada"); }
catch (Exception e) {
e.printStackTrace(); }
finally { try {
if (null != fichero) { fichero.close();}
} catch (Exception e2) { e2.printStackTrace();} }
} }
