SCS

MODULO 8: Excepciones
Porque todos comentemos errores, existen las excepciones :-)

Definir Excepciones, Usar try, catch, and finally
                                                        --------
                                                       | Object |
                                                       ---------
                                                             ^
                                                 ->         |                 <¬
                                           Error                           Exception



Los errores se pueden personalizar por las diferentes que ofrece java pero siempre van de lo especifico a lo general

public class TestA {
    static Integer i;
    public static void main(String[] args) {
        A a = new A();
        try{
        a.cociente(100, i);
        }catch(ArithmeticException ae){ //mas especifico
            System.err.println("No puedes dividir por cero");
        }catch(NullPointerException npe){
            System.out.println("Variable null");
        }catch(Exception e){ //más general
         
        }
    }
}

Los errores no son tratados en el try{}catch(Exception e){}

public class TestA {
    static Integer i=5;
    public static void main(String[] args) {
        A a = new A();
        try{
        throw new ClassFormatError(); //Esto no es atrapado por ninguno porque no es exception es un                                                                   // ERROR.
     
        }catch(ArithmeticException ae){
            System.err.println("No puedes dividir por cero");
        }catch(NullPointerException npe){
            System.out.println("Variable null");
        }catch(Exception e){
            System.out.println("Error no identificado ");
        }
    }
}

Por lo tanto lanza un error.
Las exception NO son atrapados pero si se pone Error como lo siguiente
public class TestA {
    static Integer i=5;
    public static void main(String[] args) {
        A a = new A();
        try{
        a.cociente(100, i);
        throw new ClassFormatError();
     
        }catch(ArithmeticException ae){
            System.err.println("No puedes dividir por cero");
        }catch(NullPointerException npe){
            System.out.println("Variable null");
        }catch(Error e){ //                                               Error
            System.out.println("Error no identificado ");
        }
    }
}


Cuando nadie se hace responsable de una Eception al final la maquina virtual de java (JVM)  se hace responsable y lo único que hace es matar todo.

finally
El finally siempre se ejecuta y va con:
try{
}finally{

}

o bien
try{ }catch(Exception e){}finally{}




Describir categorias de excepciones
 - Excepciones lanzadas por la máquina virtual
 - Excepciones de programación

Para la certificación es importante aprenderse una tabla de 12 excepciones y quien las lanza si la máquina virtual o el programador

Otra forma de lanzar Excepciones
es a travez del throws es decir sólo lanza pero no se hace responsable.


package EjCTC;

public class A {
 public void cociente(int a, int b)throws ArithmeticException{
     System.out.println(" "+a+"/"+b+" = "+a/b );
 }  


}
Con lo anterior aun truena en donde se llamo, solo se le dice que es un código peligroso

Ahora bien si hacemos lo siguiente:
import java.io.IOException;

public class A {
 public void cociente(int a, int b)throws IOException {               //Linea 3
     throw new IOException();                                                   // Linea 5
     //System.out.println(" "+a+"/"+b+" = "+a/b );
 }  


}

Si la linea 3 no se pone pero si la linea 5 marca error porque tu estas enviando algo identificado por lo tanto o TE RESPONSABILIZAS (try catch) o la LANZAS (throws)

Con lo anterior no quiere decir que ya no truene ya que debemos tener cuidado en donde lo llamamos que es ahí donde dará problemas puesto que ahí llega la excepcion identificada y lanzada. Ahí es donde podemos atraparla con un try y un catch.

Si en el padre estas lanzando una Excepcion en el método hijo tienes que sobrescribirla 

Si queremos crear nuestras exception, sólo hay que extender (Extends Exception) de la clase Exception, pero tu tienes que definir los mensajes.

Aserciones
Sirven para depurar código, se pueden habilitar o deshabilitar. Verificamos cierto valor. Nos sirve como desarrolladores, una vez terminada la aplicación la puedes quitar.
Es una especie de un if.

Es una expresión boleana, en caso de que se verdadera la condición se va a ejecutar normalmente, pero si el resultado es false, entonces produce un ERROR. Entonces vas al código y lo corriges.


Usos inapropiados (si funcionan, pero no debería usarse para eso) -> Pregunta de examen
Métodos públicos

Las aserciones por default esta deshabilitadas para no consumir recursos, esa es la diferencia entre una aserción y un if. Las aserciones aunque esten estan deshabilitadas.

¿Cómo se hablitan?
Se configura en las propiedades del proyecto y en la forma VM Option: -ea

Por consola:
javac nomArchivo.java
java -ea nomArchivo

Las assert te mandan el error pero no corrigen el problema, es solo que te avisa.

USO:
public class A {
 public void cociente(int a, int b) {
   
     assert(a>0):"a no es mayor a 0";  
   
     System.out.println(" "+a+"/"+b+" = "+a/b );
 }  
   


}