Scala higher order (10): exception handling in Scala

Hello everyone , I can't think of Xiao Zhao .

Creation time ：2022 year 7 month 27 Japan
Blog home page ： Click here to enter the blog home page
—— Migrant workers in the new era
—— Look at the world with another kind of thinking logic
Today is to join CSDN Of the 1243 God . I think it's helpful and troublesome. I like it 、 Comment on 、️ Collection

---

---

Scala Exception mechanism in syntax processing and Java similar , But it's different .

One 、 Exception Overview

• Exception mechanism ： Abnormal conditions occurred during the execution of the program .

Code demonstration ：

public class ExceptionText {
    
    public static void main(String[] args) {
    
        int a=100;
        int b=0;
        System.out.println(a/b);
    }
}

Running results ：

Two 、 review Java Abnormal mechanism in

Java There are two ways of exception handling in

• At the location of the method declaration , Use throws keyword , Throw it to the next level . Who calls me , I'll throw it to whoever . Throw it to the next level .

public class ExceptionText {
    
    public static void main(String[] args) throws Exception{
    
        int a=100;
        int b=0;
        divide(a,b);
    }

    public static void divide(int a, int b) throws Exception{
    
        int c = a / b;
        System.out.println(c);
    }
}

• Use try…catch Statement to catch exceptions .

public class ExceptionText {
    
    public static void main(String[] args){
    
        int a=100;
        int b=0;
        try {
    
            divide(a,b);
        } catch (Exception e) {
    
            e.printStackTrace();
        }
    }
    public static void divide(int a, int b) throws Exception{
    
        int c = a / b;
        System.out.println(c);
    }

Be careful ：

1.Java If you keep throwing up after the exception in , Finally, it was thrown to main Method ,main Methods keep throwing up , Thrown to the caller JVM,JVM Know that this exception happened , There is only one result . End java Execution of procedures .
2.try An exception occurs in a line in the statement, and the subsequent code of that line will not be executed try…catch After the capture , Subsequent code can be executed .

try…catch and finally summary

• Grammar format ：

try {
    

}catch(OneException e) {
     

}catch(TwoException e) {
    

}finally {
    
 
}

• try Contains code that may cause exceptions

• try And then catch,catch There can be one or more ,catch Is the exception that needs to be caught

• finally Express ： Whether it's an exception , There are still no exceptions ,finally The code in the is executed ,finally and catch
  Can be used separately , but finally It has to be with try Use it together

try {
    

}finally {
    

}

• catch( abnormal 1 | abnormal 2 | abnormal 3 |......) jdk8 New characteristics ！！

Sample code （1）：

public class ExceptionText {
    
    public static void main(String[] args){
    
        int a=100;
        int b=0;
        try {
    
            divide(a,b);
            // There is an exception in the previous line of code , Go straight into catch Inside ！！
            System.out.println(" Can I execute ？");
        } catch (Exception e) {
    
            System.out.println(" By 0 except ！！");
        }
    }
    public static void divide(int a, int b) throws Exception{
    
        int c = a / b;
        System.out.println(c);
    }
}

Running results ：

 By 0 except ！！

Sample code （2）：

public class ExceptionText {
    
    public static void main(String[] args){
    
        int a=100;
        int b=0;
        try {
    
            divide(a,b);
            // There is an exception in the previous line of code , Go straight into catch Inside ！！
            System.out.println(" Can I execute ？");
        } catch (Exception e) {
    
            System.out.println(" By 0 except ！！");
        }finally {
    
            System.out.println("finally Yes ！！");
        }
    }
    public static void divide(int a, int b) throws Exception{
    
        int c = a / b;
        System.out.println(c);
    }
}

Running results ：

 By 0 except ！！
finally Yes ！！

throws And try…catch How to choose ？
Abnormal use needs to be reported throws, Use... When you need to catch exceptions try…catch Capture ！！

finally Important interview questions

Sample code （3）：

public class FinallyText {
    
    public static void main(String[] args) {
    
        System.out.println(n());
    }
    
    public static int n(){
    
        int i=100;
        try {
    
            return i;
        }finally {
    
            i++;
        }
    }
}

3、 ... and 、Scala Abnormal mechanism in

• The code that will cause exceptions is encapsulated in try In block . stay try Block followed by a catch Handler to catch exceptions . If anything goes wrong ,catch The handler will process it , The program will not terminate abnormally .
• Scala The abnormal working mechanism and Java equally , however Scala No, “checked（ Compile time ）” abnormal , namely Scala There is no concept of compiling exceptions , Exceptions are caught and handled at runtime .
• The mechanism of exception catching is the same as in other languages , If something goes wrong ,catch Clauses are captured in order . therefore , stay catch clause , The more specific the exception, the more it depends on the front , The more common the anomaly, the later , If the more common exceptions are written before , Write the specific exception after , stay Scala There's no mistake in reporting , But this is a very bad programming style .
• finally Clause is used to perform the steps that need to be performed whether normal processing or exception occurs , Generally used for object cleaning , This and Java equally .
• use throw keyword , Throw an exception object . All exceptions are Throwable Subtypes of .throw Expressions are of type , Namely Nothing, because Nothing Is a subtype of all types , therefore throw Expressions can be used where types are needed .
• java Provides throws Keyword to declare an exception . You can use method definitions to declare exceptions . It provides the caller function with information that this method might throw this exception . It helps to call function handling and include the code in try-catch In block , To avoid abnormal program termination . stay Scala in , have access to throws Annotations to declare exceptions .

	def main(args: Array[String]): Unit = {
    
		 f11()
	}
	@throws(classOf[NumberFormatException])
	def f11()={
    
		 "abc".toInt
	}

Sample code （4）：

object Test_Exception {
    
  def main(args: Array[String]): Unit = {
    
      try{
    
        val n =10 /0;
      }catch {
    
        case e: ArithmeticException =>{
    
          println(" Arithmetic exception occurred ")
        }
        case e: Exception => {
    
          println(" A general exception occurred ")
        }
      }finally {
    
        println(" End of processing ")
      }
  }
}

This time Scala The content shared by the exception mechanism in ends here , And Java Compared with the exception mechanism, there are indeed many flexible places , I hope that's helpful ！！！