Tipuri de excepție

„Am vrut să vorbesc despre încă un lucru astăzi. În Java, toate excepțiile sunt împărțite în două tipuri: bifate și nebifate (cele care trebuie prinse și cele pe care nu trebuie să le prinzi). În mod implicit, toate excepțiile trebuie să fie prins."

„Poți introduce în mod intenționat excepții în codul tău?”

„Puteți arunca orice excepție în propriul cod. Puteți chiar să scrieți propriile excepții. Dar despre asta vom vorbi mai târziu. Acum, să ne concentrăm asupra excepțiilor aruncate de mașina Java.”

"BINE."

„Dacă ClassNotFoundException sau FileNotFoundException sunt aruncate (apar) într-o metodă, dezvoltatorul trebuie să le indice în declarația metodei. Acestea sunt excepții verificate . Așa arată de obicei:”

public static void method1() throws ClassNotFoundException, FileNotFoundException

public static void main() throws IOException

public static void main() // Doesn't throw any exceptions

„Așa că scriem doar „aruncări” urmate de o listă de excepții delimitată prin virgulă, nu?

„Da. Dar sunt mai multe. Pentru ca programul să fie compilat, metoda care apelează method1în exemplul de mai jos trebuie să facă unul dintre cele două lucruri: fie să prindă aceste excepții, fie să le arunce din nou (către apelant) , indicând excepțiile reintroduse în declarația sa. ”

„Din nou. Dacă metoda principală trebuie să apeleze o metodă a cărei declarație conține „ aruncă FileNotFoundException , …”, atunci trebuie să faceți unul dintre cele două lucruri:

1) Prindeți FileNotFoundException ,...

Trebuie să împachetați codul care apelează metoda nesigură într- un bloc try-catch .

2) Nu prindeți FileNotFoundException , ...

Trebuie să adăugați aceste excepții la lista de aruncări a metodei principale .”

— Ai putea să-mi dai un exemplu?

"Uita-te la asta:"

public static void main(String[] args)
{
    method1();
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

„Codul din acest exemplu nu se va compila, deoarece metoda principală apelează method1() , care aruncă excepții care trebuie să fie capturate.”

„Pentru a se compila, trebuie să adăugăm gestionarea excepțiilor la metoda principală. Puteți face acest lucru în unul din două moduri:”

public static void main(String[] args)  throws FileNotFoundException, ClassNotFoundException 
{
    method1();
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

„Și aici îl prindem cu un try-catch :”

public static void main(String[] args)
{
    try
    {
        method1();
    }
    catch(Exception e)
    {
    }
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

— Începe să devină mai clar.

"Uitați-vă la următorul exemplu. Vă va ajuta să înțelegeți restul."

public static void method2() throws FileNotFoundException, ClassNotFoundException
{
    method1();
}

public static void method3() throws ClassNotFoundException
{
   try
    {
        method1();
    }
    catch (FileNotFoundException e)
    {
        System.out.println("FileNotFoundException has been caught.");
    }
}

public static void method4()
{
    try
    {
        method1();
    }
    catch (FileNotFoundException e)
    {
        System.out.println("FileNotFoundException has been caught.");
    }
    catch (ClassNotFoundException e)
    {
        System.out.println("ClassNotFoundException has been caught.");
    }
}

„Există încă un tip de excepție, RuntimeException și clasele care o moștenesc. Nu trebuie să le prindeți. Acestea sunt excepții nebifate. Sunt considerate greu de prezis. Puteți face față în același mod, dar dvs. nu trebuie să le indicați într- o clauză de aruncare .”