Tipos de excepción en Java con ejemplos – Part 1

 

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. 

exceptions-in-java

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. 

  1. ArithmeticException:  Se lanza cuando se ha producido una condición excepcional en una operación aritmética.
  2. 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.
  3. ClassNotFoundException:  esta excepción se genera cuando intentamos acceder a una clase cuya definición no se encuentra
  4. FileNotFoundException:  esta excepción se genera cuando no se puede acceder a un archivo o no se abre.
  5. IOException:  se lanza cuando una operación de entrada-salida falla o se interrumpe
  6. InterruptedException:  se lanza cuando un subproceso está esperando, durmiendo o realizando algún procesamiento, y se interrumpe.
  7. NoSuchFieldException:  se lanza cuando una clase no contiene el campo (o variable) especificado
  8. NoSuchMethodException: Se lanza al acceder a un método que no se encuentra.
  9. NullPointerException:  esta excepción se genera cuando se hace referencia a los miembros de un objeto nulo. nulo no representa nada
  10. NumberFormatException:  esta excepción se genera cuando un método no puede convertir una string en un formato numérico.
  11. RuntimeException:  Esto representa una excepción que ocurre durante el tiempo de ejecución.
  12. 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.
  13. 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. 
  14. 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");
        }
    }
}
Producción

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..");
        }
    }
}
Producción

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");
        }
    }
}
Producción

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");
        }
    }
}
Producción

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");
        }
    }
}
Producción

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...");
        }
    }
}
Producción

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

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *