Clases Utiles: Calendar y GregorianCalendar

Class Calendar

java.lang.Object
java.util.Calendar

La clase Calendar es sub-clase de object y pertenece al paquete "util" por lo cual será necesario importarlo previamente antes de usarlo. Implementa Serializable, Cloneable, Comparable<Calendar> como interfaces. Hay que notar que es una clase abstracta y no puede instanciarse.

Tiene sólo 2 constructores:

  • Calendar()
    • Construye un calendario con la zona horaria predeterminada y la configuración regional.
  • Calendar(TimeZone zone, Locale aLocale)
    • Construye un calendario con la zona horaria y la configuración regional especificada.

Cuenta con varias variables de clase del tipo int para la construcción de un calendario:

  • MILLISECOND
    • Número de milisegundo dentro de un segundo (0-999).
  • SECOND
    • Número de segundos dentro de un minuto (0-59).
  • MINUTE
    • Número de minutos dentro de una hora (0-59).
  • HOUR
    • Número de hora dentro del dia (0-11) o de la mañana o de la tarde-noche.
  • HOUR_OF_DAY
    • Número de hora dentro de un día(0-23).
  • DAY_OF_MONTH y DATE
    • Número de día del mes (1-31) para obtner y configurar.
  • DAY_OF_WEEK
    • Número de día de la semana (1-7, siendo 1 = domingo) para obtener y configurar.
  • DAY_OF_WEEK_IN_MONTH
    • Número de día del la semana en el mes: Nos dice que número de día (lunes a domingo) es en el mes. Por ejemplo si hoy es lunes y es el tercer lunes del mes el resultado será 3.
  • DAY_OF_YEAR
    • Número de día en el año (1-365) para configurar y obtener.
  • WEEK_OF_MONTH
    • Número de semana dentro del mes (1-5).
  • WEEK_OF_YEAR
    • Número de semana dentro del año (1-54).
  • MONTH
    • Número de mes en el año (0-11) para obtener y configurar.
  • YEAR
    • Número de año para obtener y configurar.

Métodos Calendar

Tenemos varios métodos para trabajar con esas variables:

  • add(int field, int amount)
    • Le agrega o resta a un varible de calendario el número indicado basado en las reglas del calendario, Por ejemplo si al dia 31 le agregamos 5 miCalendario.add(Calendar.DAY_OF_MONTH, 5) el resultado será 5 y 36 porque ahi acaba el mes.
  • roll(int field, boolean up)
    • Añade o resta una sola unidad de tiempo a el entero "field" si la condición "up" es cierta, de lo contrario resta.
  • roll(int field, int amount)
    • Idem anterior solo que cuenta con la liberta de sumar o resta más de una unidad de tiempo con el indice "amount".
  • getInstance()
    • Obtiene un calendario utilizando la zona horaria predeterminada y la configuración regional.
  • set(int field, int value)
    • Configura a "field" por el valor de "value",
      • ej miCalenDar10.set(Calendar.MONTH, 6);
  • getTime()
    • Obtiene un objeto Date que representa los valores de un calendario
      • se ve una cosa como: Sun Oct 26 22:13:15 ART 2014
  • get(int field)
    • Obtiene el valor de una variable de calendar que le pasemos como parámetro.
      • Por ejemplo: miCalenDar10.get(Calendar.YEAR) se verá: 2014

Class GregorianCalendar

java.lang.Object
java.util.Calendar
java.util.GregorianCalendar

La clase GregorianCalendar es sub-clase de Calendar y también pertenece al paquete "util" por lo cual será necesario importarlo previamente antes de usarlo. Implementa Serializable, Cloneable, Comparable<Calendar> como interfaces.

Agrega 2 nuevas variables de clases además de las que hereda de Calendar:

  • AD
    • Valor del campo ERA indicando antes de cristo,
  • BC
    • Valor del campor ERA indicando después de cristo.

Herada y sobreescribe algunos de los métodos heredados pero agreda nuevos:

  • getGregorianChange()
    • Obtiene la fecha de cambio de GregorianCalendar.
  • isLeapYear(int year)
    • devuelve un booleando evaluado a si el año es bisiesto o no.
  • setGregorianChange(Date date)
    • Establece la fecha de cambio de GregorianCalendar. Este es el punto en el cambio de fechas julianas a fechas gregorianas. El valor predeterminado es 15 de octubre 1582 (gregoriano). Anterior a esto, las fechas serán en el calendario juliano.
en No hay comentarios:
Etiquetas:

Clases Utiles: Scanner, Random y Math

Class Scanner

java.lang.Object
java.util.Scanner

La clase Scanner es sub-clase de object y pertenece al paquete "util" por lo cual será necesario importarlo previamente antes de usarlo.

Cuenta con varios constructores, hasta el momento solo he usado:

  • Scanner(InputStream source)
    • ej: Scanner miScanner = new Scanner (System. in);

Los métodos de la clase Scanner son:

  • close()
    • Cierra el Scanner.
  • hasNext()
    • Es un valor booleano que responde a si existe una nueva entrada por teclado mientras deja el scanner abierto. Existen de este métodos variaciones para que siguiente entrada sea verdadero si se ingresa el tipo adecuado como una primitiva, string, ect:

      hasNext(Pattern pattern) hasNext(String pattern) hasNextBigDecimal() hasNextBigInteger() hasNextBigInteger(int radix) hasNextBoolean() hasNextByte() hasNextByte(int radix) hasNextDouble() hasNextFloat() hasNextInt() hasNextInt(int radix) hasNextLine() hasNextLong() hasNextLong(int radix) hasNextShort() hasNextShort(int radix)
  • next()
    • Encuentra y devuelve la siguiente entrada exitosa de este escáner. Tambien existen variaciones para que las entradas sean de un tipo especifico como:

      next(Pattern pattern) next(String pattern) nextBigDecimal() nextBigInteger() nextBigInteger(int radix) nextBoolean() nextByte() nextByte(int radix) nextDouble() nextFloat() nextInt() nextInt(int radix) nextLine() nextLong() nextLong(int radix) nextShort() nextShort(int radix)

Class Random

java.lang.Object
java.util.Random

La clase Random es sub-clase de object, implementa la interface "Serializable" y pertenece al paquete "util" por lo cual será necesario importarlo previamente antes de usarlo.

Tiene sólo 2 constructores:

  • Random()
    • Crea un nuevo objeto generador de números aleatorios.
  • Random(long seed)
    • Crea un nuevo objeto generador de números al azar utilizando una sola semilla que es el punto de partida para generar números no tan aleatorios porque siempre serán los mismo.

Cuenta con varios métodos:

  • nextBoolean()
    • Genera valores booleanos al azar entre tru y false.
  • nextDouble()
    • Genera valores double con coma al azar entre 0 y 1.
  • nextFloat()
    • Genera valores float con coma al azar entre 0 y 1.
  • nextGaussian()
    • Genera valores double con coma al azar entre -1 y 1.
  • nextInt()
    • Genera valores int al azar entre el rango que soporta int.
  • nextInt(int n)
    • Genera números al azar entre 0 y "n"
  • nextLong()
    • Genera valores long al azar entre el rango que soporta long.
  • setSeed(long seed)
    • Configura una semilla, es igual al funcionamiento del segundo constructor.

Class Math

java.lang.Object
java.util.Math

La clase Math es final y no puede ser modificada, también es sub-clase de object y pertenece al paquete "lang" disponible sin importación.

Cuenta con 2 variables de clases: el número "e" y "pi". Están declaradas de la siguiente forma:

  • public static final double E = 2.718281828459045;
  • public static final double PI = 3.141592653589793;

Son publicas para acceder a ellas desde cualquier clase/paquete, son de clase por ende tienen que ser llamados por la clase Math.E ó MAth.PI, son "final" porque no pueden ser modificadas y además vemos que son valores "double".

La clase Math no tiene constructores. Pero tiene varios métodos para hacer operaciones matemáticas:

  • abs(double a) abs(float a) abs(int a) abs(long a)
    • abs devuelve el valor absoluto ó módulo del parámetro a si es double, float, int o long.
  • asin(double a)
    • devuelve el arco seno de un valor double "a".
  • acos(double a)
    • devuelve el arco coseno de un valor double "a".
  • atan(double a)
    • devuelve el arco tangente de un valor double "a".
  • sin(double a)
    • devuelve el seno de un ángulo "a".
  • cos(double a)
    • Devuelve el coseno de un ángulo "a".
  • tan(double a)
    • devuelve la tangente de un angulo "a".
  • toDegrees(double angrad)
    • Convierte un águlo de radianes a grados.
  • toRadians(double angdeg)
    • convierte un ángulo de grados a radianes.
  • cbrt(double a)
    • Devuelve la raíz cúbica de un valor doble "a".
  • pow(double a, double b)
    • devuelve "a" elevedo a la potencia de "b".
  • sqrt(double a)
    • Devuelve la raíz cuadrada positiva redondeada de un valor doble "a".
  • exp(double a)
    • Devuelve el número de Euler "e" elevado a la potencia de un valor doble "a".
  • expm1(double x)
    • devuelve el resultado de la operación: e (elevado a la) x (elevado a la) -1.
  • hypot(double x, double y)
    • Resuelve el teprema de pitagoras haciendo sqrt(sqrt(x)+sqrt(y)).
  • log(double a)
    • Devuelve el logaritmo natural (base e) de un valor doble "a".
  • log10(double a)
    • Devuelve el logaritmo (base 10) de un valor doble "a".
  • max(double a, double b) max(float a, float b) max(int a, int b) max(long a, long b)
    • devueve el valor maximo entre "a" y "b" de los parámetro si es double, float, int o long.
  • min(double a, double b) min(float a, float b) min(int a, int b) min(long a, long b)
    • devueve el valor minimo entre "a" y "b" de los parámetro si es double, float, int o long.
en No hay comentarios:
Etiquetas:

Clases Utiles: Object y String

Como recordaremos las clases en Java se organizan en paquetes. Toda la documentación oficial para la plataforma SE7 está disponible de manera libre en la web en el sitio de SunMicrosystems aquí.

Class Object

La clase objeto es la cima de todas las clases en java. De ella deriban todas las clases, por lo tanto todas heredan sus métodos alguno de ellos son:
  • clone() Crea y devuelve una copia del objeto .
    • protected Object clone() throws CloneNotSupportedException
  • equals(Object obj) Compara 2 objetos y devuelve true o false.
    • public boolean equals(Object obj)
  • getClass() Devuelve la clase en tiempo de ejecución de este objeto.
    • public final Class <?> getClass()
  • toString() Devuelve el objeto transformado en un String, gralmente cosas raras.
    • public String toString()
La clase Object esta dentro del paquete java.lang que está disponible sin importación

Class String

java.lang.Object
java.lang.String
La clase String es sub-clase de Object y pertenece también al paquete "java.lang", implementa 3 interfaces: Serializable, CharSequence, Comparable, la clase se veria como:
  • public final class String extends Object implements Serializable, Comparable, CharSequence { //Cuerpo}
String cuenta con varios contructores (15 de ellos) el que siempre usamos es:
  • public String(String original)
    • Que crea un objeto string con la misma secuencia de caracteres que cuenta en sus parametros
Además cuenta con más de 60 métodos mas lo que hereda de object, no hay que saberlos de memoria simplemente recurrir a la especificación api de java. Lo más útil e interesante de los objetos son sus atributos y métodos para poder usarlos y hacer que el código haga algo.

Métodos String

  • charAt(int index)
    • devuelve el caracter en el indice que vale "index"
  • length()
    • devuelve un numero entero que representa la longitud de caracteres de la cadena de texto.
  • equals(Object anObject)
    • Compara mi String con un objeto que puede ser otro String y devuelve un resultado booleano.
  • equalsIgnoreCase(String anotherString)
    • Compara 2 String sin tener en cuenta las diferencias entre mayúsculas y minúsculas de ambas cadenas.
  • indexOf(String str)
    • Devuelve un indice donde se encuentre el String del paramétro, sino lo encuentra devuelve -1.
  • isEmpty()
    • Es un booleano que se vuelve verdadero si el String esta vacio o nulo, es decir si lenght() es 0.
  • replace(char oldChar, char newChar)
    • Devuelve un nuevo String reemplazando todas las coincidencias del caracter viejo por el nuevo que le demos.
  • replaceAll(String regex, String replacement)
    • devuelve un nuevo String pero reemplaza el contenido del String "regex" por el de "replacement".
  • substring(int beginIndex)
    • Devuelve un nuevo String con el contenido de quien llama al método con el contenido empezando en el indice especificado.
  • substring(int beginIndex, int endIndex)
    • Idem anterior pero indicando el final del substring.
  • toCharArray()
    • Convierte esta cadena en un nuevo array de caracteres.
  • toLowerCase()
    • Convierte todos los caracteres de esta cadena a minúsculas.
  • toUpperCase()
    • Convierte todos los caracteres de la cadena a mayúsculas.

Ejemplo

  1. import static java. lang. System. out;
  2. public class Cadena {
  4.     public static void main(String[] args) {
  5.         String str = "El hombre que se levanta es aun más grande que el que no ha caído. ";
  6.         String strn = "Cuanto más alto estamos, más debemos bajarnos hacia nuestros inferiores.";
  7.        
  8.          out.println("El primer String es \"" str "\"");
  9.          out.println("El segundo String es \"" strn "\"");
  10.          
  11.          out.println("\nEl caracter en la posicion 10 del primer String es " str.charAt(10));
  12.          out.println("\nLa longitud del primer String es de: " str.length());
  13.          out.println("\nEl indice del substring \"levanta\" es: " str.indexOf("levanta"));
  14.          out.println("\n¿El segundo String se encuentra vacio? " strn.isEmpty());
  15.          out.print("\nSi reemplazamos las letras \'a\' por las \'x\' el primer String queda: ");
  16.          out.println(str.replace('a', 'x'));
  17.          out.print("\nSi reemplazamos \"alto\" por \"bajo\" en el segundo String queda: ");
  18.          out.println(strn.replaceAll("alto", "bajo"));
  19.          out.print("\nEl subString del indice 5 al 20 del primer String es: ");
  20.          out.println(str.substring(5, 20));
  21.          out.print("\nEl primer String convertido todo en mayúsculas sería de la forma: ");
  22.          out.println(str.toUpperCase());
  23.          out.print("\nEl segundo String transformado en minúsuculas es: ");
  24.          out.println(strn.toLowerCase());
  25.     }
  26. }
Mi resultado fue:
en No hay comentarios:
Etiquetas:

Streams de Datos - Flujo de Entrada/Salida

En java todos los datos se escriben y se leen, entran y salen usando Streams. Un stream es un "flujo, corriente" es una ruta de datos similar a el flujo o corriente de agua que transporta un río, solo que trasnportamos datos. Los streams es la manera que java tiene para comunicarse, estos están implementados dentro del paquete "java.io"

Existen de 2 tipos:

  • --> De Entrada (InputStream) desde una fuente a un programa java como destino.
  • <-- De Salida (OutputStream) nuestro programa es el origen, envia datos a un destino.

El procedimiento para crear y usar streams de datos de entrada o salida es muy similar:

  1. Ceamos un archivo "File"
  2. Creamos un archivo "File-Stream" de entrada o salida.
  3. Crear un Stream lector o escritor.
  4. Creamos y asociar un Buffer (filtro) a el Stream lector/escritor.
  5. Leemos o escribimos datos desde el filtro con los métodos especificos( read() write() ).
  6. Cerramos el buffer
************************************************************************************************************************************************************

Los streams desde luego están muy ligados a las "Exceptions", y tenemos que tratarlas con el bloque try-catch. Contamos con una super-clase IOException para manejar excepciones, y sub-clases como FileNotFoundExpection para cuando intentamos leer o escribir un archivo que no está disponible o no se puede acceder a el, y EOFEception (EOF = End Of File) para cuando se produce el final inesperado de un archivo del que se estaba leyendo o escribiendo.

El tipo más común es el Stream File que son usados para intercambiar bytes generalmente con nuestro disco duro, entre otros dispositivos.

InputStream - Flujo de Entrada

En el siguiente ejemplo leeremos un archivo de texto usando dentro de nuestro bloque try-catch la creación de un objeto FileInputStream y le pasamos el nombre y/o la ruta donde se encuentra (en este caso use un parametro archivo que debe existir), luego creamos el objeto de entrada InputStreamReader con el parametro del objeto File, y posteriormente creamos el BufferedReader, el filtro para el objeto de entrada llamado "reader".
Después hay un String que tomará el valor de cada linea que el buffer obtenga con el método "readLine()", y el ciclo while se ejecutará hasta que la obtención de alguna linea sea nulo porque se haya llegado al final del archivo de texto.
Pasamos a cerrar el buffer para liberar espacio en memoria con el método "close()" y capturamos las excepciones que puedan surgir como que el archivo no se encontrado (FileNotFoundException) y muestra ese error por pantalla junto con un mensaje o algún otro error que se pueda dar (IOException) y simplemente hara lo mismo.

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.InputStreamReader;
  4. import java.io.BufferedReader;
  5. import java.io.IOException;
  6. import java.io.FileNotFoundException;
  7.  
  8. public class EscribirArchivo {
  9.     public static void main(String[] args) {
  10.         try {
  11.             File archivo = new File("c:\\archivoPrueba.txt");
  12.             FileInputStream inputStream = new FileInputStream(archivo);
  13.             InputStreamReader reader = new InputStreamReader(inputStream);
  14.             BufferedReader bufferedReader = new BufferedReader(reader);
  15.            
  16.             String linea;
  17.             while ((linea = bufferedReader.readLine()) != null) {
  18.                 System.out.println(linea);
  19.             }
  20.             bufferedReader.close();
  21.            
  22.         } catch (FileNotFoundException e) {
  23.             System.out.println("Error el archivo no existe" + e.getStackTrace());
  24.         } catch (IOException e) {
  25.             System.out.println("No es posible leer el archivo" + e.getStackTrace());
  26.         }
  27.     }
  28. }

Para que el programa funcione perfectamente hay que tener un archivo previamente con el nombre indicado en la dirección indicada de lo contrario actuará el catch de FileNotFound.

OutputStream - Flujo de Salida

Para escribir un archivo el procedimiento es igual salvo que habrá que tener cuidado de que el archivo no sea sobreescrito! Para lo cual existen 2 constructores de FileOutputStream:

  • FileOutputStream(string) donde el String es el nombre de nuestro archivo File.
  • FileOutputStream(String, boolean) idem anterior y el boolean verdadero continua escribiendo desde el final, falso sobreescribe el archivo perdiendo el contenido anterior.
  1. import java.io.File;
  2. import java.io.FileOutputStream;
  3. import java.io.OutputStreamWriter;
  4. import java.io.BufferedWriter;
  5. import java.io.IOException;
  6. import java.io.FileNotFoundException;
  7.  
  8. public class EscribeArchivo {
  9.     public static void main(String[] args) {
  10.         try {
  11.             File archivo = new File("c:\\archivoPrueba.txt");
  12.             FileOutputStream outputStream = new FileOutputStream(archivo, true);
  13.             OutputStreamWriter writer = new OutputStreamWriter(outputStream);
  14.             BufferedWriter bufferedWriter = new BufferedWriter(writer);
  15.            
  16.             bufferedWriter.write("NUEVO CONTENIDO DEL ARCHIVO");
  17.             bufferedWriter.append("CONTINUA COLOCANDO UNA NUEVA LINEA");
  18.             bufferedWriter.flush();
  19.             bufferedWriter.close();
  20.         } catch (FileNotFoundException e) {
  21.             e.printStackTrace();
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }  
  25.     }
  26. }

El método write(String) pertenece a la clase padre "Write" de bufferedWriter el cual escribe el string del parametro.
flush() vacia el contenido del Stream.
Close() cierre el flujo de entrada vaciándolo previamente por lo cual el método flush no es muy necesario en este ejemplo.
append(CharSequence csq) es otro método heredado de "Write" el cual escribe una secuencia de caracteres.
BufferedWriter ademas cuenta con el método newLine() que escribe un separador de línea. no es necesariamente un solo salto de línea ('\ n') y varios métodos write() con diferentes parámetros.

en No hay comentarios:
Etiquetas:

Try-Catch y Manejo de Errores

Try-Catch

El bloque "try-Catch" castenillando las palabras "intentar sino atrapar" es un bloque de declaración encerrado entre llaves{} como cualquier otro donde en nuestro try incluimos declaraciones que "pueden" ocacionar errores en tiempo de compilación es decir que nuestro codigo no se encuentra mal escrito, y por eso le pedimos que "Intente" hacerlo sino que atrape lo que declaramos en nuestro "catch".
Podemos usarlo donde queramos pero el sentido es hacerlo cuando sabemos o sospechamos que nuestras declaraciones puedan ocacionar algún error como cargar ficheros y la ruta pueda no estar disponible.
Nuestro "try" se ejecuta normalmente hasta el momento que se encuentre un error, y desde esa linea "salta" a el bloque catch y no le importa las declaraciones siguientes.
Podemos incluir tantos "catchs" como excepciones querramos.

Un ejemplo básico sería mostrar un indice de un array que este fuera del límite del mismo, es decir declaramos un arreglo que contenga "x" variables y le pedimos mostrar "x+1" que no lo va a encontrar. En ese momento al no poder "intentar" mostrar un indice que se no encuentra deja de ejecutar nuestro bloque try para ejecutar el bloque catch.
  1. public class IntentarAtrapar {
  3.     public static void main(String[] args) {
  4.         int numeros[] = {1,2,3,4,5};
  5.        
  6.         try{
  7.             System.out.println(numeros[5]);
  8.         }catch (Exception e){
  9.             System.out.println(e);
  10.         }
  11.     }
  12. }
El resultado será que el indice 5 (en arrays empezamos a contar desde cero) no esta declarado y como resultado solo se ejecuta el bloque catch
  • java.lang.ArrayIndexOutOfBoundsException: 5
Al mostrar nuestra "e" nos menciona la clase java para el error ocacionado y el n° del indice que intentamos acceder, en conclución "Excepción fuera de los límites del arreglo: 5" nos da la pista que ese indice no está declarado.

Finally

El bloque "finally" (Finalmente) es opcional a nuestro try/catch. La funcionalidad es que este bloque se ejecutara en cualquiera de los casos, es decir si ocurre una ecepción o no siempre se ejecuta este bloque al final.
La utilidad de contar con este bloque se da por ejemplo al abrir un flujo de datos en nuestro try, donde al final del mismo lo cerrariamos pero si ocurre una excepción esta queda salteada, entonces usaremos este bloque para cerrar ese flujo porque sabemos que se ejecuta de todos modos.

Si modificamos un poquito nuestro ejemplo anterior, no tendriamos un error y por último nuestra declaración "finally"
  1. public class IntentarAtrapar {
  3.     public static void main(String[] args) {
  4.         int numeros[] = {1,2,3,4,5};
  5.        
  6.         try{
  7.             System.out.println(numeros[2]);
  8.         }catch (Exception e){
  9.             System.out.println(e);
  10.         }finally{
  11.             System.out.println("El bloque finally se ejecuta siempre");
  12.         }
  13.     }
  14. }
El resultado será:
  • 3
  • El bloque finally se ejecuta siempre

Errores y Excepciones

Los Errores y excepciones son los mecanismos por el cual podemos hacer frente a distintos incovenientes que pueden o no surgir y que pueden ser dados por razón lógica del programa como un índice fuera de rango, dividir por cero o errores creados a partir de ciertos objetos como cargar archivos o URL de páginas web que pueden estar mal escrita la ruta o no estar disponibles.
Existe toda una jerarquia de Clases Java para el manejo de errores a partir de la Clase Throwable, sus hijas Error y Exception, la clase RunTimeException entre muchas otras.

Throws y Throw

Otra manera de manejar excepciones en java es la de "Lanzar" las misma, es decir no tratamos de ninguna forma, para que SI lo haga quien lo llame.

Para los lanzamientos de excepciones usamo dos palabras claves throws y throw.
  • Throws (Con S) se utiliza en la firma de los métodos para anunciar que en el mismo se pueden dar errores y que deben ser tratados.
  • Throw (Sin S) se utiliza en el catch, una vez atrapado, para lanzar la excepción para quien nos llame.
La declaración throw (lanzar) sirve para manejar nuestros errores o excepciones simplemente de la manera más facil que es no haciéndose cargo del error sino que además lo lanza para que quién lo tome se encargue de el como es debido (lo atrape).
*En el mismo ejemplo reformado, genero mi array y el try-catch dentro de un método de instancia pero el catch solo lanza la excepción, luego desde el main un objeto hace la llamada al método desde otro try-catch pero esta mostrar un mensaje que se produce un error.
  1. public class IntentarAtrapar {
  2.     public void mostrar(){
  3.         int numeros[] = {1,2,3,4,5};
  4.        
  5.         try{
  6.             System.out.println(numeros[5]);
  7.         }catch (Exception e){
  8.             throw e;
  9.         }
  10.     }
  11.     public static void main(String[] args) {
  12.         IntentarAtrapar objeto = new IntentarAtrapar();
  13.         try{
  14.             objeto.mostrar();
  15.         }catch(Exception e){
  16.             System.out.println("Lo sentimos, ha ocurrido un error.");
  17.         }
  18.     }
  19. }
La salida de este códgio es:
  • Lo sentimos, ha ocurrido un error.
La declaración throws se utliza en la firma de nuestro método para alertar que nuestras declaraciones pueden ocacionar errores y que estos deben ser tratados. Si nadie captura la excepción interviene un manejador por defecto que normalmente imprime información que ayuda a encontrar quién produjo la excepción.
  1. public cargarURL(String direccionPagina) throws MalFormedURLException{
  2.     URL miPagina = new URL(direccionPagina);
  3.     loadWebPage(miPagina);
  4. }
*En este otro ejemplo intentamos hacer una división que tendrá 2 excepciones la cuales son ingresar un valor no-entero y la de dividir por cero. Para lo cual lo vamos a hacer dentro un método el cual avisa que se puede producir este error con la declaración throws
  1. import java.util.InputMismatchException;
  2. import java.util.Scanner;
  4. public class DividirCero {
  5.    
  6.     public static int cociente( int numerador, int denominador ) throws ArithmeticException {
  7.        
  8.         return numerador / denominador; // posible división entre cero
  9.     }
  10.    
  11.     public static void main(String args[]) {
  12.         System.out.println("*******************************");
  13.         System.out.println("División de números de enteros:");
  14.         System.out.println("*******************************");
  15.        
  16.         Scanner miScanner = new Scanner( System.in );
  17.         boolean ciclo = true;  
  18.        
  19.         do{
  20.             try {
  21.                 System.out.print("\nIntroduzca un numerador entero: ");
  22.                 int numerador = miScanner.nextInt();
  23.                
  24.                 System.out.print("Introduzca un denominador entero: ");
  25.                 int denominador = miScanner.nextInt();
  26.                
  27.                 int resultado = numerador / denominador;
  28.                
  29.                 System.out.print("Resultado: " + numerador + " dividido entre " + denominador + " = " + resultado);
  30.                 ciclo = false;
  31.                
  32.             } catch ( InputMismatchException e) {          
  33.                 System.err.println("\nExcepcion: " e);
  34.                 miScanner.nextLine(); //descarta la entrada previa       
  35.                 System.out.println("Debe introducir enteros. Intente de nuevo.\n" );
  36.                
  37.                
  38.             } catch ( ArithmeticException aE){
  39.                 System.err.println("\nExcepcion: " aE);
  40.                 System.out.println( "Cero es un denominador invalido. Intente de nuevo.\n" );
  41.             }
  42.         } while ( ciclo );
  43.     }
  44.    
  45.  }
El resultado será:
en No hay comentarios:
Etiquetas:
Suscribirse a: Entradas (Atom)

Java 25 de 2025

  • Look and Feel
    El look and feel(Aspecto y comportamiento) es la forma en que los JComponent de swing (JLabel, JButton, JTextField, JTextArea, JCheck...
  • Tips: Como reproducir sonidos en java
    Para poder reproducir sonidos en java, por ejemplo al presionar un boton, tendremos que agregar el siguiente método en alún lugar de nuestra...