UNIVERSIDAD POLITECNICA

DE TLAXCALA

Alumno:
Samuel Denicia Gómez

Tema:
Excepciones y errores

Asignatura:
Programación Orientada a Objetos

Grado & Grupo:

6° “F”
Tabla de contenido
EXCEPCIONES DE JAVA ........................................................................................................................ 2
Excepciones no verificadas.............................................................................................................. 2
Excepciones comprobadas .............................................................................................................. 2
Clases de excepción ........................................................................................................................ 2
Manejo de excepciones................................................................................................................... 3
Manejo de excepciones comprobadas............................................................................................ 3
Manejo de excepciones no verificadas ........................................................................................... 3
Excepciones de lanzamiento ........................................................................................................... 3
La throwsdeclaración ...................................................................................................................... 3
Excepciones de agrupación ............................................................................................................. 4
Excepciones de anidación ............................................................................................................... 4
ERRORES DE JAVA ............................................................................................................................... 4
javac: file not found: Programa.java ............................................................................................... 4
Exception in thread “main” java.lang.NoClassDefFoundError: Clase/java ..................................... 5
Exception in thread “main” java.lang.NoSutchMethodError: main................................................ 5
javac: invalid flag: Clase.class .......................................................................................................... 5
Programa.java: 6: missing method body, or declared abstract. ..................................................... 6
Programa.java: 3: ‘(‘ expected ........................................................................................................ 6
Programa.java: 7: illegal start of expression ................................................................................... 6
Programa.java: 4: package system doesn’t exist ............................................................................ 6
EXCEPCIONES DE JAVA
• Las excepciones de Java son eventos que interrumpen la ejecución normal del programa.
• El principal objetivo de las excepciones es separar el manejo de errores del código regular.
• Las excepciones pueden deberse a una amplia gama de problemas, como la falta de
recursos, los errores de codificación, los errores de memoria y otros. En Java, hay dos tipos
de excepciones:
• Excepciones no verificadas (excepciones de tiempo de ejecución).
• Excepciones comprobadas (excepciones en tiempo de compilación).

Excepciones no verificadas.
Las excepciones sin marcar son problemas que ocurren en tiempo de ejecución. También se llaman
excepciones no capturadas o en tiempo de ejecución. Como las excepciones no marcadas no se
marcan en el momento de la compilación, no es necesario que especifique o maneje la excepción
(aunque puede hacerlo si lo desea). Por lo general, son el resultado de malas prácticas de
codificación o errores lógicos, como errores de datos, argumentos no válidos o recursos faltantes.

Excepciones comprobadas
Las excepciones comprobadas también se denominan excepciones de tiempo de compilación, ya
que surgen en el tiempo de compilación. El código Java que contiene cualquier excepción marcada
no se compilará. Cuando intenta ejecutar dicho código, el compilador le advierte sobre la presencia
de la excepción verificada. Si aún elige compilar el código, aparecerá el mensaje "Problemas de
compilación no resueltos".

Clases de excepción
Las clases de excepción son clases de Java que incluyen todas las excepciones marcadas y no
marcadas. Las excepciones que mencioné anteriormente, como ArithmeticExceptiony
IOExceptionestán representadas por una clase de excepción. De hecho, Java tiene una jerarquía
extensa de clases primarias y secundarias que cubren la mayoría de los problemas que pueden
ocurrir durante la compilación o en tiempo de ejecución.

Sin embargo, la clasificación de las excepciones de Java es un poco confusa. La Throwableclase es la

superclase de todas las excepciones y errores de Java. Tiene dos subclases, Error y Exceptionaunque
no representan marcada y sin marcar excepciones.
Manejo de excepciones
El manejo de excepciones en Java sucede con lostry, catchy finallybloques. Puede usarlos para
definir cómo desea manejar las excepciones cuando se producen. El trybloque debe incluir el código
que puede o no lanzar una excepción. Cada catchbloque es un controlador de excepciones que trata
con una excepción lanzada por el trybloque. El finallybloque se ejecuta, en cualquier caso, ya sea
que se haya lanzado una excepción o no.

Puedes incluir tantos catchbloques como quieras. Sin embargo, solo puede agregar uno final Lya
cada trybloque. Los programadores suelen utilizar finallybloques para realizar la limpieza después
de que se hayan ejecutado los bloques try catch.

Manejo de excepciones comprobadas

Aquí es cómo puede manejar el IOExceptionejemplo, utilizando un try-catchbloque. Adjuntamos el
código sensible que podrían lanzar una IOExceptioncon un trybloque. El catchbloque solo se dispara
si el trybloque lanza un IOException.

Manejo de excepciones no verificadas

También puede usar try-catchbloques para manejar una excepción sin marcar. Si bien el manejo de
excepciones sin marcar no es obligatorio, es una buena idea usar un try-catchbloque para fines de
registro y monitoreo. El siguiente ejemplo es del Wikilibro de programación de Java y muestra cómo
el registro de una excepción no verificada puede ser útil en la programación de servlets.

Excepciones de lanzamiento
Lanzar excepciones es una técnica de programación específica en Java. Solo puede capturar una
excepción que se haya lanzado antes, ya sea por la plataforma Java o por un código personalizado.
Excepción de lanzamiento en Java sucede con la throwdeclaración. ArithmeticException,
ArrayIndexOutOfBoundsExceptiony NullPointerException, IOExceptionen nuestros ejemplos, todos
fueron lanzados automáticamente por la plataforma Java.

La throwsdeclaración
Además, throw, Java también tiene una throwsdeclaración. Se puede usar en la firma de cualquier
método que pueda generar una excepción marcada. Supongamos que tiene una excepción marcada
que evitaría que el código se compile, pero no quiere o no puede manejarlo dentro del método
actual. Usando la throwspalabra clave, puede indicar que la persona que llama debe manejar esta
excepción con su propio try-catchbloque.
Excepciones de agrupación
Agrupar excepciones es un acceso directo de programación que le permite manejar múltiples
excepciones en un solo catchbloque. Esta técnica está disponible desde Java 7. Es una gran solución
cuando desea ejecutar el mismo código en diferentes excepciones. Como no tiene que manejar cada
excepción en una catchcláusula separada, tendrá una base de código mucho más limpia.

Excepciones de anidación
La anidación de excepciones ocurre en Java cuando una excepción da como resultado una segunda
excepción que se traduce en una tercera excepción, etc. Al lidiar con toda una cadena de
excepciones, las excepciones anidadas también se denominan excepciones encadenadas. El
seguimiento de pila de una excepción contiene la cadena de excepciones que han conducido a la
excepción final.

Puede anidar una excepción de Java en otra utilizando la catchcláusula. Las excepciones anidadas
pueden ayudarlo a identificar por qué se ha lanzado una excepción.

ERRORES DE JAVA

ERROR:

javac: file not found: Programa.java

POSIBLES PROBLEMAS:

A).- Estas tratando de compilar tu programa en una dirección en donde dicho programa no se
encuentra. Por ejemplo, si el prompt de MS-DOS está en C:/> y tu programa está guardado en C:/Mis
programas>, nunca se va a compilar el programa porque MS-DOS no lo encuentra.

SUGERENCIA: Debes dominar bien los comandos MS-DOS, principalmente los que se refieren a
directorios:

Aquí una pequeña lista con su descripción:

• CD Cambia de directorio.
• CD Se sale del directorio actual
• DIR Muestra una lista de directorios
• CD Se cambia a la raíz directamente (se sale de varios directorios al mismo tiempo).

B).- Escribiste mal el nombre del programa. Recuerda que en java las mayúsculas y las minúsculas
no son iguales.

SUGERENCIA: Recuerda que si presionas la tecla TAB el MS-DOS te propone el nombre completo y
esto te ayuda a evitar errores de escritura.
C).- Probablemente se te olvidó guardar tu archivo con extensión .java. No es lo mismo Programa
que Programa.java

ERROR:

Exception in thread “main” java.lang.NoClassDefFoundError: Clase/java

POSIBLES PROBLEMAS:

A).- Estás compilando equivocadamente, recuerda que el compilador de Java se llama javac no java:

Java Clase.java ¡= javac Clase.java

ERROR:

Exception in thread “main” java.lang.NoSutchMethodError: main

POSIBLES PROBLEMAS:

A).- Estás ejecutando una clase que no cuenta con método main. Recuerda que el main () es el punto
de arranque del programa de Java (al menos de consola o Swing).

Todo programa de este tipo se debe ejecutar con el nombre de la clase en la cual se encuentra el
método main().

B).- A pesar de que la clase que estás ejecutando cuenta con método main(), lo más probable es que
éste no haya sido definido como estático.

Recuerda la siguiente forma: public static void main(String args[]) {}

ERROR:

javac: invalid flag: Clase.class

POSIBLES PROBLEMAS:

A).- Estás compilando un programa que no tiene extensión .java, en el ejemplo de arriba se intentó
compilar un programa que tiene extensión .class.
ERROR:

Programa.java: 6: missing method body, or declared abstract.

POSIBLES PROBLEMAS:

A).- El método main() tiene punto y coma. El compilador te avisa que el main está definido como
método abstracto.

ERROR:

Programa.java: 3: ‘(‘ expected

POSIBLES PROBLEMAS:

A).- Probablemente estas definiendo un método, pero no colocaste paréntesis, recuerda que un
método se define de la forma: visibilidad tipo regreso nombre(lista de parámetros)

A).- Dejaste espacio en el nombre del método: por ejemplo: public void get X().

Recuerda las reglas de Identificadores.

ERROR:

Programa.java: 7: illegal start of expression

POSIBLES PROBLEMAS:

A).- Inicio ilegal de expresión: Se debe a que estás definiendo un nuevo método sin cerrar algún
método anterior. Aquí la recomendación es revisar bien las llaves y que queden bien cerradas.

Por lo regular este tipo de errores suceden más frecuentemente con el método main().

ERROR:

Programa.java: 4: package system doesn’t exist

POSIBLES PROBLEMAS:

A).- Al momento de utilizar System.out.println(“Hola”); , la palabra System fue escrita con “s”
minúscula.

Recuerda que java es Case-Sensitive.

Más adelante la segunda parte de este sencillo Manual de errores.

Recuerda que tomar en cuenta las recomendaciones de Sun Microsystems para el uso de
identificadores es muy importante y que las reglas de identificadores determinan en gran parte la
cantidad de errores en un Código.
Reglas de identificadores

1.- Que no sea una palabra reservada. (51 palabras reservadas).

2.-Que respete la siguiente gramática:

• Inicie con $, _ ó letra; donde: A es diferente de a.

• Seguido de cero o más: letras ó dígitos ó $ ó under-scores.

3.- Un identificador no puede llevar espacios.

BIBLIOGRAFIA:
1. http://elearning.uptlax.edu.mx/pluginfile.php/74738/mod_resource/content/2/Manejo_d
e_Excepciones_MA_2020.pdf