˗ˋˏ♡ˎˊ˗

举例：实现将一个文件从硬盘加载近来，导致加载可能失败的运行错误有硬盘错误、文件无法找到等
int status=loadTextfile();
If (status!=1){
  //something unusual happened, describe it
 switch(status) {
    case 2: 
       //file not found
      break;
   case 3:
       //disk error
   default:
      //other error}
}else {
    //file loaded OK, continue with program} 
```      

 
 
#### <font color="#20B2AA" face="Comic sans MS">1.3  Java异常处理方法</font>
<table><tr><td bgcolor=#ADD8E6><font face="Comic sans MS">Java异常处理方法：Java为运行错误引入了异常、异常类和异常处理机制。
  **异常：**特殊的运行错误，是在程序运行过程中发生的、会打断程序正常执行的错误
　例如：
　除0溢出
　文件找不到
  数组元素下标越界　

**异常类：**Java用面向对象的方法处理异常，Java的异常类是处理运行时错误的特殊类，每一种异常类对应一种
特定的运行错误，每一个异常事件由一个异常类的对象来代表。
 *例如：除0溢出（ArithmeticException）
　　　文件找不到（FileNotFoundException）
　　　数组元素下标越界（ArrayIndexOutofBoundsException）*

**异常处理机制：抛出异常——捕捉异常：**
 1.  当出现了一些错误，方法都会产生一个<font color="red">异常对象</font>，这个异常对象将交由运行系统来处理。此过程就称为抛出
     <font color="red">(throwing)异常</font>。**包括：系统抛出、用户自定义抛出。**
 2.  接着，运行系统开始寻找合适的处理方法，来处理这个异常。如果系统找到了一个适合的处理该异常方法，
     这一过程就叫<font color="red">捕获异常</font>。
</font></td></tr></table>

&emsp;
&emsp;
#### <font color="#20B2AA" face="Comic sans MS">1.4  异常处理的语法支持</font>
<table><tr><td bgcolor=#ADD8E6><font face="Comic sans MS">       **－try,catch,throws,throw,finally**
(1) try包含可能出现异常的语句块；
(2) 一个或多个catch块紧随try{}块，每个catch块通常处理指定类型的异常；
(3) finally引导块紧随catch块后，主要用于清理现场（可有可无）。
格式：
try
{ ......
}catch( ExceptionName1 e )
{ ......}
catch( ExceptionName2 e )
{ ......}
finally
{ ......}
注意：finally总是执行，catch块不一定执行
</font></td></tr></table>

&emsp;
&emsp;
#### <font color="#20B2AA" face="Comic sans MS">1.5  总结</font>
<table><tr><td bgcolor=#EEE0E5><font face="Comic sans MS"> (1) Java的异常处理把错误集中起来统一处理。程序员只需要说明何处可能出现异常，如何处理即可；
 (2) 采用面向对象的思想标准化了各种错误的类型；
 (3) Java把程序运行过程中可能遇到的问题分为两类，一类是致命性的，即程序遇到了非常严重的不正常状
 态，不能简单地恢复执行，这就是<font color="red">**错误(对应Error类)**</font>，如程序运行过程中内存耗尽。另一类是非致命性的，
 通过某种处理后程序还能继续运行，这就是<font color="red">**异常(对应Exception类)**</font>。
</font></td></tr></table>


&emsp;
&emsp;
### <font color="#FF6347" face="Comic sans MS">二、 异常类的层次</font>
#### <font color="#20B2AA" face="Comic sans MS">2.1  异常分类</font>

<font face="Comic sans MS"><font color="red">**☕异常类：**</font>异常在Java中都是作为类的实例(对象)的形式出现的。
&emsp;     如 Throwable类, Exception类, Error类……

<font color="red">**☕Java中异常分类：**</font>
 (1)  <font color="#00B2EE">**Error类及其子类：**</font>描述Java运行时刻系统内部的错误或资源枯竭导致的错误，无法恢复和抛出，发生几率小；
 (2)  <font color="#00B2EE">**Exception类及其子类：**</font>普通程序可以从中恢复，分为<font color="red">**运行时异常**</font>和<font color="red">**非运行时异常**</font>。

&emsp;异常在Java中也是作为类的实例的形式出现的。Java中的所有的异常类都是从Throwable类派生出来的。<font color="red">**Throwable类有两个直接子类：**</font><font color="#00B2EE">**java.lang.Error**</font> 和 <font color="#00B2EE">**java.lang.Exception**</font>。


异常类的层次结构如下图所示。
![58.png](https://i.loli.net/2018/12/28/5c2621a200c43.png)
**(1) 🔺Error类及其子类主要用来描述一些Java运行时刻系统内部的错误或资源枯竭导致的错误。**普通的程序不能从这类错误中恢复，也无法抛出这种类型的错误，这类错误出现的几率是很小的。
**(2) 🔺另一个异常类的子类是Exception类和它的子类。**在编程中错误的处理主要是对这类错误的处理，如除数为零、数组下标越界等。类Exception是普通程序可以从中恢复的所有规范了的异常的父类。
</font>

&emsp;
&emsp;
#### <font color="#20B2AA" face="Comic sans MS">2.2  Exception类的子类</font>

<font face="Comic sans MS"><font color="red">**☕Exception类子类有两种：**</font>
**运行时异常**和**非运行时异常（一般异常）**　&emsp;&emsp;&emsp;　*区别？？？*
<font color="#00B2EE">**（1）运行时异常：**</font>RuntimeException类及其所有子类。      运行时异常是程序员编写程序不正确所导致的异常，理论上，程序员经过检查和测试可以查出这类错误。如**除数为零等，错误的强制类型转换、数组越界访问、空引用**。
<font color="#00B2EE">**（2）非运行时异常（一般异常）：**</font>指可以由编译器在编译时检测到的、可能会发生在方法执行过程中的异常，如找不到指定的文件等，这不是程序本身的错误，如果这些异常情况没有发生，程序本身仍然是完好的。　　
<font color="red">**注意：**</font>**编译器强制要求Java程序必须**<font color="#00B2EE">**捕获**</font>**或**<font color="#00B2EE">**声明抛出**</font>**所有非运行时异常，但对运行时异常不作要求。运行时异常编译可以通过但是运行时出现异常；非运行时异常编译的时候就通不过。**

*例如：格式不正确的URL、试图为一个不存在的类找到一个代表它的类的对象。除了runtimeexception及其子类以外，其他exception类的子类都是非运行时异常。*
</font>

```java
//运行时异常和非运行时异常区别举例  
[例5-1] RuntimeExceptionDemo1.java
class RuntimeExceptionDemo1{  
public static void main(String args[]){
    int i=0;
System.out.println(2/0);
}}

该程序能编译通过，而在运行时，出现如下提示：
> javac RuntimeExceptionDemo1.java
> java RuntimeExceptionDemo1
Exception in thread "main" java.lang.ArithmeticException: / by zero at 
RuntimeExceptionDemo1.main(RuntimeExceptionDemo1.java:4)
//这里的"ArithmeticException"

[例5-2] NonRuntimeExceptionDemo1.java
import java.io.*;
class NonRuntimeExceptionDemo1
{ 
      public static void main(String args[]){
       FileInputStream in=new FileInputStream("text.txt");
        int s;
        while((s=in.read())!=-1) System.out.print(s);
        in.close();
   }
}
会出现如下的错误提示：
javac NonRuntimeExceptionDemo1.java
NonRuntimeExceptionDemo1.java:5: unreported exception java.io.FileNotFoundException; must
 be caught or declared to be thrown
FileInputStream in=new FileInputStream("text.txt");
                   ^
NonRuntimeExceptionDemo1.java:7: unreported exception java.io.IOException; mustbe
 caught or declared to be thrown
while((s=in.read())!=-1) System.out.print(s);
                ^
NonRuntimeExceptionDemo1.java:8: unreported exception java.io.IOException; mustbe caught 
or declared to be thrown
in.close();

① 捕获该类异常
[例5-2] NonRuntimeExceptionDemo1.java
import java.io.*;
class NonRuntimeExceptionDemo1
{ 
      public static void main(String args[]){
        try{
             FileInputStream in=new FileInputStream("text.txt");
            int s;
            while((s=in.read())!=-1) System.out.print(s);
           in.close();
              }catch(Exception e){…}
   }
}


② 声明抛出
[例5-2] NonRuntimeExceptionDemo1.java
import java.io.*;
class NonRuntimeExceptionDemo1
{ 
      public static void main(String args[])throws Exception{
      FileInputStream in=new FileInputStream("text.txt");
      int s;
      while((s=in.read())!=-1) System.out.print(s);
      in.close();
}
}

try-catch-finally语句对程序运行进行监控，捕获和处理异常通常形式： 
try{
调用可能产生异常的方法及其它java语句；
}
catch(异常类名1 异常对象名e){
异常处理语句块；
}
catch(异常类名2 异常对象名e){
异常处理语句块；
}
finally{
最终处理；
}

[例5-3]访问文本文件text.txt，并将其在屏幕上打印出来。
import java.io.*;
class TryCatchFinally
{ 
      public static void main(String args[]){
       try{
        FileInputStream in=new FileInputStream("text.txt");
        int s;
        while((s=in.read())!=-1) System.out.print(s);
        in.close();
       }
       catch(FileNotFoundException e){
          System.out.println(“捕获异常：”+e);   //e会调用toString()方法回显异常信息给程序员
       }
       catch(IOException e){
          System.out.println("捕获异常："+e);
       }
       finally{
       System.out.println("finally块总是执行！");
       } }
}

运行结果：
捕获异常：java.io.FileNotFoundException: text.txt (系统找不到指定的文件。)
finally块总是执行！

try { … }           //…是正常执行的代码, 可能产生异常
       catch (异常类1 e) { … }    //…是异常类1的处理代码
       catch (异常类2 e) { … }    //…是异常类1的处理代码
        ……
      catch (异常类n e) { … }   //…是异常类2的处理代码
      finally { … }                   //…是执行清除工作的语句

例1：调用的方法抛出了异常 
class Test {……
 public String getInput() throws IOException
 {……
    System.in.read();
}
}



例2：检测到了错误并使用throw语句抛出异常
import java.io.*;
 class Test {……
 public String getInput() throws IOException
 {……
     IOException ae =new IOException("buffer is full");
    throw ae; 
}



例3： throws多个异常
class Animation
{                                                   
 public Image loadImage(String s) throws  
                 EOFException, MalformURLException  
 {
  ……
 }
} 

举例
static String getInput() throws IOException{
  char[] buffer =new char[20];
   int counter = 0;
   boolean flag =true;
   while(flag) {
       buffer[counter] =(char)System.in.read(); 
         
      if(buffer[counter]=='\n') flag = false;
      counter++;
      if(counter>=20){
} IOException ae =new IOException("buffer is full"); 
      throw ae; }
    return new String(buffer);
}

 "//IOException ae =new IOException(""buffer is full"");  throw ae;"使用throw