Escala | Manejo de excepciones

¿Qué es una excepción?

Una excepción es un evento no deseado o inesperado que ocurre durante la ejecución de un programa, es decir, en tiempo de ejecución. Estos eventos cambian el control de flujo del programa en ejecución. Estas son situaciones que no son demasiado peligrosas y pueden ser manejadas por el programa.

Jerarquía de excepciones

Todos los tipos de excepciones y errores son subclases de la clase Throwable , que es la clase base de la jerarquía. Una rama está encabezada por Exception . Esta clase se utiliza para condiciones excepcionales que los programas de usuario deben detectar. NullPointerException es un ejemplo de tal excepción. Otra rama, Error , es utilizada por el sistema de tiempo de ejecución de Java ( JVM ) para indicar errores que tienen que ver con el propio entorno de tiempo de ejecución (JRE). StackOverflowError es un ejemplo de este tipo de error.

Excepciones en Scala

El manejo de excepciones en Scala se implementa de manera diferente, pero se comporta exactamente como Java y funciona perfectamente con las bibliotecas de Java existentes. En Scala, todas las excepciones están desmarcadas . no existe el concepto de excepción comprobada Scala facilita una gran flexibilidad en términos de la capacidad de elegir si capturar una excepción.

Nota: En tiempo de compilación, las excepciones «marcadas» se marcan en Java. Si un método puede lanzar una IOException , debemos declararlo.

¿Cómo funciona la excepción de Scala?

Las excepciones en Scala funcionan de la misma manera que en C++ o Java. Cuando ocurre una excepción, digamos una ArithmeticException como se muestra en el ejemplo anterior, la operación actual se anula y el sistema de tiempo de ejecución busca un controlador de excepciones que pueda aceptar una ArithmeticException. El control se reanuda con el controlador más interno. Si no existe dicho controlador, el programa termina.

Lanzar excepciones Lanzar
una excepción. Se ve igual que en Java. creamos un objeto de excepción y luego lo lanzamos usando la palabra clave throw.
Sintaxis:

throw new ArithmeticException

La construcción try/ catch La construcción
try/catch es diferente en Scala que en Java, try/catch en Scala es una expresión . La excepción en Scala y que da como resultado un valor puede coincidir con el patrón en el bloque catch en lugar de proporcionar una cláusula catch separada para cada excepción diferente. Porque try/catch en Scala es una expresión. Aquí hay un ejemplo de manejo de excepciones usando el bloque try-catch convencional en Scala.

// Scala program of try-catch Exception 
import java.io.IOException
  
// Creating object
object GFG
{  
    // Main method
    def main(args:Array[String])
    {  
        try
        {
            var N = 5/0
               
        } 
        catch 
        {
            // Catch block contain cases. 
            case i: IOException => 
            {
                println("IOException occurred.")
            }
            case a : ArithmeticException => 
            {
                println("Arithmetic Exception occurred.")
            }
   
        }
   
    }  
}  

Producción:

Arithmetic Exception occurred.

En Scala, un solo bloque catch puede manejar todo tipo de excepciones, lo que proporciona flexibilidad.

La cláusula final:

Si queremos que una parte de nuestro código se ejecute independientemente de cómo termine la expresión, podemos usar un bloque finalmente. Aquí hay un ejemplo de lo anterior:

// Scala program of finally Exception 
  
// Creating object
object GFG 
{
    // Main method
    def main(args: Array[String]) 
    {
        try
        {
            var N = 5/0
        } 
        catch
        {
            // Catch block contain case.
            case ex: ArithmeticException => 
            {
                println("Arithmetic Exception occurred.")
            }
        }
        finally
        {
            // Finally block will execute 
            println("This is final block.")
        }
    }
}

Producción:

Arithmetic Exception occurred.
This is final block.