PDF de programación - Ejercitación JAVA

Imágen de pdf Ejercitación JAVA

Ejercitación JAVAgráfica de visualizaciones

Actualizado el 21 de Marzo del 2018 (Publicado el 3 de Febrero del 2018)
639 visualizaciones desde el 3 de Febrero del 2018
335,3 KB
35 paginas
Creado hace 7a (28/09/2013)
EJERCITACIÓN

JAVA







2013

CÁTEDRA DE LENGUAJES ORIENTADOS A OBJETOS

Ing. Mario Bressano & Luciano Diamand









ENVÍO



10






LENGUAJES ORIENTADOS A OBJETOS

2013

{
[BLOQUE DE EJECUCIÓN NORMAL DE SENTENCIAS]
}


MANEJO DE EXCEPCIONES:

EL LENGUAJE Java, como se sabe, es independiente del Sistema Operativo, esto me implica,
perder el control sobre los periféricos, los cuales son fuente, generalmente, de la mayor
cantidad de errores.
Por esto, se dotó a este Lenguaje de una estructura robusta para el manejo de errores. La
misma se basa en la creación de un objeto denominado “EXCEPCIÓN”.
Este objeto contiene el informe sobre el acontecimiento producido y transmite esta información
al método que lo llamó o al usuario mediante un mensaje.
En algunos métodos el error se captura y en otros se expulsa.

La codificación se basa en la siguiente estructura:

try


catch (ClasedeExcepción1 e)


catch (ClasedeExcepción2 e)



catch (ClasedeExcepción3 e)


catch (Excepción e)




finally {


{
[BLOQUE DE EJECUCIÓN EXCEPCIÓN 1]
}
{
[BLOQUE DE EJECUCIÓN EXCEPCIÓN 2]
}

{
[BLOQUE DE EJECUCIÓN EXCEPCIÓN 3]
}

[BLOQUE DE EJECUCIÓN EXCEPCIONES NO CAPTURADAS]
}



{



[BLOQUE DE SENTENCIAS QUE SE EJECUTAN SIEMPRE]
}






























Exception



La jerarquía de excepciones en Java
























RuntimeException

IOException

Throwable

Error

AWTError



ThreadDeath

OutOfMemoryError



Página 2 de 35






LENGUAJES ORIENTADOS A OBJETOS

2013


Este esquema es una porción de la jerarquía de herencia para la clase Throwable (subclase de
Object).
Las clase Exception tiene dos subclases que están incluidas en java.lang y que contiene la
mayoría de las situaciones de error que se producen. En cambio la clase Error contiene errores
que se producen generalmente en tiempo de ejecución y que no deben ser capturadas por la
aplicación.
Java clasifica a las excepciones en verificadas y no verificadas. Las primeras son aquellas para
las cuales Java implementa un requerimiento para atrapar o declarar.
Si se intenta lanzar una excepción verificada que no esté listada en throw se produce un error
de ejecución.
Las excepciones no verificadas se pueden evitar programando correctamente. (Ej. Caso
ArithmeticException o NumberFormatExcpetion, que es subclase de RuntimeException, no
necesita colocarse en la cláusula throw.



ARTÍCULO PARA AMPLIAR CONTENIDOS


Fuente:

Manejo de Errores Usando Excepciones Java

Autor: Sun
Traductor: Juan Antonio Palos
Corrección y ampliación: Mario Osvaldo Bressano

Web: http://www.programacion.net/java/tutorial



¿Porqué capturar y mostrar errores?

El lenguaje Java fue creado con la intención de ser independiente del Sistema Operativo con el
cual se corre. Debido a esto se lo dotó de un manejo de errores que le confiera robustez (se
dice que “Java es tolerante a las fallas”) ante cualquier falla que pudiera tornar en desastrosa la
ejecución de la aplicación.

Una excepción ocurre cuando no se cumple la norma establecida; su pseudocódigo sería:

Realizar tarea





Si tarea no se realiza correctamente



Procesar errores

El lenguaje maneja errores sincrónicos tales como:

a- Índices fuera de rango,



Página 3 de 35

LENGUAJES ORIENTADOS A OBJETOS

2013








b- Desbordamiento aritmético,

c- División por cero,

d- Asignación fallida de memoria,

e- Interrupción de subprocesos,

f- Parámetros inválidos del método.

Por otro lado, no maneja errores asincrónicos:

a- Operaciones de E/S, de disco, de teclas, etc.

La estructura para la captura de errores es la siguiente:

try

{





Contiene instrucciones que pueden causar excepciones

}

catch (parámetros excepción)





finally





{

Manejador de la instrucción

}

{

Se ejecuta siempre









(Esta cláusula es opcional)

}



Página 4 de 35

LENGUAJES ORIENTADOS A OBJETOS

2013








Clases generadoras de excepciones de uso frecuente

NOMBRE DE LA CLASE

DESCRIPCIÓN

ArithmeticException

Excepción aritmética (p.e. división por cero)

ArrayStoreException

Excepción en una operación uso de un Array

NegativeArraySizeException

Excepción en una operación uso de un Array

NullPointerException

Excepción producida por una referencia a un
objeto nulo

SecurityException

Excepción en el sistema de seguridad

EOFException

Excepción producida al alcanzar el final del
fichero

IOException

Excepción en el proceso de E/S

FileNotFoundException

Excepción por no encontrar un fichero

NumberFormatException

Excepción en la conversión de una cadena de
caracteres a un valor numérico





Página 5 de 35

LENGUAJES ORIENTADOS A OBJETOS

2013










Ejemplo 82: Manejo de errores en una aplicación: Ingresar dos números enteros y dividirlos.
Mostrar el resultado. Manejar los errores esperados:

 División por cero



Ingreso de números no enteros

//Manejo de errores- División por cero y error de formato numérico

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class ManejoDeErrores extends JFrame

implements ActionListener {

private JTextField campoIngreso1, campoIngreso2, campoSalida;

private int numero1, numero2, resultado;

public static void main( String args[] )

{

ManejoDeErrores application = new ManejoDeErrores();

application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

}

// Configuramos GUI

public ManejoDeErrores()

{



Página 6 de 35

LENGUAJES ORIENTADOS A OBJETOS

2013







super( "Manejo de Excepciones" );

// Configuramos el panel contenedor y su layout

Container contenedor = getContentPane();

contenedor.setLayout( new GridLayout( 3, 2 ) );

// Configura etiqueta y campoIngreso1

contenedor.add(

new JLabel( "Ingresar el numerador: ", SwingConstants.RIGHT ) );

campoIngreso1 = new JTextField();

contenedor.add( campoIngreso1 );

// Configura etiqueta y campoIngreso2; registro la escucha

contenedor.add( new JLabel( "Ingresar el denominador y presionar <Enter> ",

SwingConstants.RIGHT ) );

campoIngreso2 = new JTextField();

contenedor.add( campoIngreso2 );

campoIngreso2.addActionListener( this );

// Configura etiqueta y campoSalida

contenedor.add( new JLabel( "Resultado ", SwingConstants.RIGHT ) );

campoSalida = new JTextField();

contenedor.add( campoSalida );

setSize( 425, 100 );

setVisible( true );



Página 7 de 35

LENGUAJES ORIENTADOS A OBJETOS

2013







} // fin del constructor ManejoDeErrores

// Procesar eventos de la GUI

public void actionPerformed( ActionEvent event )

{

campoSalida.setText( "" ); // Borro campoSalida

// Leo dos valores numéricos y calculo el cociente - Aquí comienza el bloque donde puede
haber errores

try {

numero1 = Integer.parseInt( campoIngreso1.getText() );

numero2 = Integer.parseInt( campoIngreso2.getText() );

resultado = cociente( numero1, numero2 );

campoSalida.setText( String.valueOf( resultado ) );

}

// Proceso el error de ingreso producido por mal formato del número

catch ( NumberFormatException numberFormatException ) {

JOptionPane.showMessageDialog( this,

"Usted debe ingresar números enteros", "Formato de número no válido",

JOptionPane.ERROR_MESSAGE );

campoIngreso1.setText( "" ); // Borro campoIngreso1

campoIngreso2.setText( "" ); // Borro campoIngreso2

}



Página 8 de 35

LENGUAJES ORIENTADOS A OBJETOS

2013







// Procesamiento error de división por cero

catch ( ArithmeticException arithmeticException ) {

JOptionPane.showMessageDialog( this,

"División por cero","Excepción Aritmética",

JOptionPane.ERROR_MESSAGE );

campoIngreso1.setText( "" ); // Borro campoIngreso1

campoIngreso2.setText( "" ); // Borro campoIngreso2

campoSalida.setText( "" ); // Borro campoSalida

}

} // fin de método ActionPerformed

// Toma del error en la división por cero

public int cociente( int numerador, int denominador )

throws ArithmeticException

{

return numerador / denominador;

}

} //

Cuando encontramos que un conjunto de sentencias puede lanzar un error, lo abarcamos

dentro de un bloque try. El objeto excepción es lanzado automáticamente y es capturado por

los bloques catch, los cuales se disponen uno a continuación del otro, de manera que el

programa investiga cuál le conviene.

La declaración del método throw permite lanzar excepciones especificadas por el usuario.



Página 9 de 35






LENGUAJES ORIENTADOS A OBJETOS

2013


Requerimientos Java para Capturar o Especificar Excepciones

Java requiere que un método o capture o especifique todas las excepciones chequeadas que

se pueden lanzar dentro de su ámbito. Este requerimiento tiene varios componentes que

necesitan una mayor descripción.

Capturar

Un método puede capturar una excepción proporcionando un manejador para ese tipo de

excepción.

Especificar

Si un método decide no capturar una excepción, debe especificar que puede lanzar esa

excepción. ¿Por qué hicieron este requerimiento los diseñadores de Java
  • Links de descarga
http://lwp-l.com/pdf8593

Comentarios de: Ejercitación JAVA (0)


No hay comentarios
 

Comentar...

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad