Java define varios tipos de excepciones que se relacionan con sus diversas bibliotecas de clases. Java también permite a los usuarios definir sus propias excepciones.
Excepciones integradas :
Las excepciones integradas son las excepciones que están disponibles en las bibliotecas de Java. Estas excepciones son adecuadas para explicar ciertas situaciones de error. A continuación se muestra la lista de importantes excepciones integradas en Java.
- ArithmeticException: Se lanza cuando se ha producido una condición excepcional en una operación aritmética.
- ArrayIndexOutOfBoundsException: se lanza para indicar que se ha accedido a una array con un índice ilegal. El índice es negativo o mayor o igual que el tamaño de la array.
- ClassNotFoundException: esta excepción se genera cuando intentamos acceder a una clase cuya definición no se encuentra
- FileNotFoundException: esta excepción se genera cuando no se puede acceder a un archivo o no se abre.
- IOException: se lanza cuando una operación de entrada-salida falla o se interrumpe
- InterruptedException: se lanza cuando un subproceso está esperando, durmiendo o realizando algún procesamiento, y se interrumpe.
- NoSuchFieldException: se lanza cuando una clase no contiene el campo (o variable) especificado
- NoSuchMethodException: Se lanza al acceder a un método que no se encuentra.
- NullPointerException: esta excepción se genera cuando se hace referencia a los miembros de un objeto nulo. nulo no representa nada
- NumberFormatException: esta excepción se genera cuando un método no puede convertir una string en un formato numérico.
- RuntimeException: Esto representa una excepción que ocurre durante el tiempo de ejecución.
- StringIndexOutOfBoundsException: los métodos de la clase String la lanzan para indicar que un índice es negativo o mayor que el tamaño de la string.
- IllegalArgumentException: esta excepción arrojará el error o la declaración de error cuando el método recibe un argumento que no se ajusta con precisión a la relación o condición dada. Viene bajo la excepción no verificada.
- IllegalStateException: esta excepción generará un error o un mensaje de error cuando no se acceda al método para la operación particular en la aplicación. Viene bajo la excepción no verificada.
Ejemplos de excepción incorporada
A. Excepción aritmética
Java
// Java program to demonstrate ArithmeticException
class ArithmeticException_Demo
{
public static void main(String args[])
{
try {
int a = 30, b = 0;
int c = a/b; // cannot divide by zero
System.out.println ("Result = " + c);
}
catch(ArithmeticException e) {
System.out.println ("Can't divide a number by 0");
}
}
}
Can't divide a number by 0
B. Excepción de puntero nulo
Java
//Java program to demonstrate NullPointerException
class NullPointer_Demo
{
public static void main(String args[])
{
try {
String a = null; //null value
System.out.println(a.charAt(0));
} catch(NullPointerException e) {
System.out.println("NullPointerException..");
}
}
}
NullPointerException..
C. Excepción StringIndexOutOfBound
Java
// Java program to demonstrate StringIndexOutOfBoundsException
class StringIndexOutOfBound_Demo
{
public static void main(String args[])
{
try {
String a = "This is like chipping "; // length is 22
char c = a.charAt(24); // accessing 25th element
System.out.println(c);
}
catch(StringIndexOutOfBoundsException e) {
System.out.println("StringIndexOutOfBoundsException");
}
}
}
StringIndexOutOfBoundsException
D. Excepción FileNotFound
Java
//Java program to demonstrate FileNotFoundException
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
class File_notFound_Demo {
public static void main(String args[]) {
try {
// Following file does not exist
File file = new File("E://file.txt");
FileReader fr = new FileReader(file);
} catch (FileNotFoundException e) {
System.out.println("File does not exist");
}
}
}
Producción:
File does not exist
E. Excepción de formato de número
Java
// Java program to demonstrate NumberFormatException
class NumberFormat_Demo
{
public static void main(String args[])
{
try {
// "akki" is not a number
int num = Integer.parseInt ("akki") ;
System.out.println(num);
} catch(NumberFormatException e) {
System.out.println("Number format exception");
}
}
}
Number format exception
F. Excepción ArrayIndexOutOfBounds
Java
// Java program to demonstrate ArrayIndexOutOfBoundException
class ArrayIndexOutOfBound_Demo
{
public static void main(String args[])
{
try{
int a[] = new int[5];
a[6] = 9; // accessing 7th element in an array of
// size 5
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println ("Array Index is Out Of Bounds");
}
}
}
Array Index is Out Of Bounds
G. Excepción de OI
Java
// Java program to demonstrate IOException
class IOException_Demo {
public static void main(String[] args)
{
// Create a new scanner with the specified String
// Object
Scanner scan = new Scanner("Hello Geek!");
// Print the line
System.out.println("" + scan.nextLine());
// Check if there is an IO exception
System.out.println("Exception Output: "
+ scan.ioException());
scan.close();
}
}
Producción:
Hello Geek! Exception Output: null
H. Excepción NoSuchMethod
Java
// Java program to demonstrate NoSuchElementException
public class NoSuchElementException_Demo {
public static void main(String[] args)
{
Set exampleleSet = new HashSet();
Hashtable exampleTable = new Hashtable();
exampleleSet.iterator().next();
//accessing Set
exampleTable.elements().nextElement();
//accessing Hashtable
// This throws a NoSuchElementException as there are
// no elements in Set and HashTable and we are
// trying to access elements
}
}
I. IllegalArgumentException: este programa verifica si la persona es elegible para votar o no. Si la edad es mayor o igual a 18 entonces no arrojará ningún error. Si la edad es menor de 18 años, arrojará un error con la declaración de error.
Además, podemos especificar «lanzar una nueva IllegalArgumentException()» sin el mensaje de error. También podemos especificar Integer.toString(variable_name) dentro de IllegalArgumentException() e imprimirá el nombre del argumento que no cumple la condición dada.
Java
/*package whatever //do not write package name here */
import java.io.*;
class GFG {
public static void print(int a)
{
if(a>=18){
System.out.println("Eligible for Voting");
}
else{
throw new IllegalArgumentException("Not Eligible for Voting");
}
}
public static void main(String[] args) {
GFG.print(14);
}
}
Producción :
Exception in thread "main" java.lang.IllegalArgumentException: Not Eligible for Voting at GFG.print(File.java:13) at GFG.main(File.java:19)
J. IllegalStateException: este programa muestra la suma de números solo para enteros positivos. Si ambos números son positivos, solo llamará al método de impresión para imprimir el resultado; de lo contrario, arrojará IllegalStateException con una declaración de error. Aquí, el método no es accesible para enteros no positivos.
Además, podemos especificar «lanzar una nueva IllegalStateException()» sin la declaración de error.
Java
/*package whatever //do not write package name here */
import java.io.*;
class GFG {
public static void print(int a,int b)
{
System.out.println("Addition of Positive Integers :"+(a+b));
}
public static void main(String[] args) {
int n1=7;
int n2=-3;
if(n1>=0 && n2>=0)
{
GFG.print(n1,n2);
}
else
{
throw new IllegalStateException("Either one or two numbers are not Positive Integer");
}
}
}
Producción :
Exception in thread "main" java.lang.IllegalStateException: Either one or two numbers are not Positive Integer at GFG.main(File.java:20)
k. Excepción ClassNotFound:
Java
// Java program to demonstrate ClassNotFoundException
public class ClassNotFoundException_Demo
{
public static void main(String[] args) {
try{
Class.forName("Class1"); // Class1 is not defined
}
catch(ClassNotFoundException e){
System.out.println(e);
System.out.println("Class Not Found...");
}
}
}
java.lang.ClassNotFoundException: Class1 Class Not Found...
Excepciones definidas por el usuario
A veces, las excepciones integradas en Java no pueden describir una situación determinada. En tales casos, el usuario también puede crear excepciones que se denominan ‘Excepciones definidas por el usuario’.
Se siguen los siguientes pasos para la creación de una excepción definida por el usuario.
- El usuario debe crear una clase de excepción como una subclase de la clase de excepción. Dado que todas las excepciones son subclases de la clase Exception, el usuario también debe hacer de su clase una subclase de ella. Esto se hace como:
class MyException extends Exception
- Podemos escribir un constructor predeterminado en su propia clase de excepción.
MyException(){}
- También podemos crear un constructor parametrizado con una string como parámetro.
Podemos usar esto para almacenar detalles de excepciones. Podemos llamar al constructor de superclase (Excepción) desde aquí y enviar la string allí.
MyException(String str)
{
super(str);
}
- Para generar una excepción de un tipo definido por el usuario, necesitamos crear un objeto para su clase de excepción y lanzarlo usando la cláusula throw, como:
MyException me = new MyException(“Exception details”); throw me;
- El siguiente programa ilustra cómo crear su propia clase de excepción MyException.
- Los detalles de los números de cuenta, los nombres de los clientes y los saldos se toman en forma de tres arrays.
- En el método main(), los detalles se muestran mediante un bucle for. En este momento, se realiza una verificación si en alguna cuenta el monto del saldo es menor que el monto del saldo mínimo para ser apto en la cuenta.
- Si es así, se genera MyException y se muestra el mensaje «El monto del saldo es menor».
Ejemplo
Java
// Java program to demonstrate user defined exception
// This program throws an exception whenever balance
// amount is below Rs 1000
class MyException extends Exception
{
//store account information
private static int accno[] = {1001, 1002, 1003, 1004};
private static String name[] =
{"Nish", "Shubh", "Sush", "Abhi", "Akash"};
private static double bal[] =
{10000.00, 12000.00, 5600.0, 999.00, 1100.55};
// default constructor
MyException() { }
// parameterized constructor
MyException(String str) { super(str); }
// write main()
public static void main(String[] args)
{
try {
// display the heading for the table
System.out.println("ACCNO" + "\t" + "CUSTOMER" +
"\t" + "BALANCE");
// display the actual account information
for (int i = 0; i < 5 ; i++)
{
System.out.println(accno[i] + "\t" + name[i] +
"\t" + bal[i]);
// display own exception if balance < 1000
if (bal[i] < 1000)
{
MyException me =
new MyException("Balance is less than 1000");
throw me;
}
}
} //end of try
catch (MyException e) {
e.printStackTrace();
}
}
}
Error de tiempo de ejecución
MyException: Balance is less than 1000
at MyException.main(fileProperty.java:36)
Producción:
ACCNO CUSTOMER BALANCE 1001 Nish 10000.0 1002 Shubh 12000.0 1003 Sush 5600.0 1004 Abhi 999.0
Artículos relacionados:
Este artículo es una contribución de Nishant Sharma . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA