宁波怎么做网站排名优化网站标识

一、 异常的概念与体系结构

1.1 异常的概念

异常：程序运行过程中，产生的一种“出错”的情况。

此处区别 —— 运行 / 编译：
（1）编译错误

（2）异常：是运行过程中出现的情况。

a. 异常实例1 ：0作为除数，出现算数异常

b. 异常实例2：0.0 作为除数，不报错

c. 数组越界异常

d. 空指针异常

1.2 异常的体系结构

异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：

Error：属于JVM内部使用的，程序员写代码，一般用不上Error。
Exception：包含很多的异常类。

总结：

1. 整个Java标准库提供了很多现成的异常。
2. 整个异常体系中分成两个大类，Error（JVM用）、Exception（程序员用）。

1.3 异常的分类

异常可能在编译时发生，也可能在程序运行时发生，根据发生的时机不同，可以将异常分为（Exception 类型里面，又分成两种异常）：

1. 受查异常：写代码的时候，这样的异常必须要显式处理。
2. 非受查异常：写代码的时候，异常可以不显式处理。

受查异常 实例：

非受查异常 实例 ：

二、 异常的处理

2.1 防御式编程

错误在代码中是客观存在的，因此我们要让程序出现问题的时候及时通知程序猿。

主要的方式：

1. 事前防御型 LBYL: Look Before You Leap. 在操作之前就做充分的检查.

• 事前防御型 伪代码举例：
  先判定上一步是否成功，成功了再下一步，不成功进行错误处理。

• 缺陷：正常的流程和错误处理流程代码混在一起, 代码整体显的比较混乱。

2. 事后认错型 EAFP: It’s Easier to Ask Forgiveness than Permission.
   “事后获取原谅比事前获取许可更容易”. 也就是先操作, 遇到问题再处理.

• 事后认错型 伪代码举例：
  任何一个环节，出现问题，都会出现“异常 ”，异常可以有很多种不同的类型。

• 优势：
  正常流程和错误流程是分离开的, 程序员更关注正常流程，代码更清晰，容易理解代码 。
  异常处理的核心思想就是 EAFP。

在Java中，异常处理主要的5个关键字：throw、try、catch、final、throws。

2.2 异常的抛出

在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。
具体语法如下：

throw new XXXException("异常产生的原因");

异常抛出实例：

public static int getElement(int[] array, int index){if(null == array){throw new NullPointerException("传递的数组为null");}if(index < 0 || index >= array.length){throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");}return array[index];
}
public static void main(String[] args) {int[] array = {1,2,3};getElement(array, 3);
}

【注意事项】

1. throw 必须写在方法体内部
2. 抛出的对象必须是Exception 或者 Exception 的子类对象
3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类（非受查异常），则可以不用处理，直接交给JVM来处理
4. 如果抛出的是编译时异常，用户必须处理（通过 throws 声明），否则无法通过编译
5. 异常一旦抛出，其后的代码就不会执行

2.3 异常的捕获

异常的捕获，也就是异常的具体处理方式，主要有两种：异常声明throws 以及 try-catch捕获处理。

2.3.1 异常声明 throws

处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助throws将异常抛给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。

语法格式：修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...{
}

异常声明 实例：加载指定的配置文件config.ini

throws 和 throw 的区别：

1. throw ：真的抛出一个异常对象
2. throws：只是声明可能抛出一些异常对象（实际抛没抛出？不知道）

【注意事项】

1. throws必须跟在方法的参数列表之后
2. 声明的异常必须是 Exception 或者 Exception 的子类
3. 方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可。

2.3.2 try-catch 捕获并处理

throws对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。
如果真正要对异常进行处理，就需要try-catch。

import java.io.FileNotFoundException;
import java.io.IOException;public class Demo5 {//通过这个方法打开读取 一个配置文件的内容private static void openConfig(String filename) throws IOException {if(!filename.equals("config.txt")){throw new FileNotFoundException("文件不存在");}throw new IOException("文件读取失败");}//从数组中获取一个元素public static int getElem(int[] arr,int index){if(arr == null){//数组为空，抛出空指针异常throw new NullPointerException("数组为空");}if(index < 0 || index >= arr.length){//数组下标越界，抛出另一个异常throw new ArrayIndexOutOfBoundsException("数组索引越界");}return arr[index];}public static void main(String[] args) throws FileNotFoundException {try{openConfig("xxx");System.out.println("执行到这个地方，完成 openConfig方法 的调用");} catch (IOException e) {System.out.println("进入到异常处理逻辑中");//catch 语句中，一般会打印出异常的详细信息//printStackTrace()方法可以打印异常的详细信息，主要就是调用栈e.printStackTrace();}}
}

【注意事项】

（1）try-catch 捕获异常， try 块内抛出异常位置之后的代码将不会被执行

（2）printStackTrace()方法：调用栈，打印异常的详细信息

（3）catch 可以有多个，取决于 try 中可能抛出哪些异常

（4）如果抛出的异常，找到末尾也没有找到匹配的catch；这样的异常就会沿着方法的调用栈，往上层传递。

异常当前方法没有catch到，就会抛给上层调用者，继续处理。

//先是func1()，处理不了；
//交给func2()，也处理不了；
//再交给main()，进行处理（如果main()处理不了，抛给JVM，令程序崩溃）
public class Demo6 {public static void func1(){throw new NullPointerException("空指针异常");}public static void func2(){try{func1();}catch(IndexOutOfBoundsException e){System.out.println("1111111111");}}public static void main(String[] args) {try{func2();}catch(NullPointerException e){System.out.println("2222222222");}}}

（5）try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获

public class Demo8 {public static void main(String[] args) {int[] arr = {1, 2, 3};try {System.out.println("before");// arr = null;System.out.println(arr[100]);System.out.println("after");} catch (ArrayIndexOutOfBoundsException e) {System.out.println("这是个数组下标越界异常");e.printStackTrace();} catch (NullPointerException e) {System.out.println("这是个空指针异常");e.printStackTrace();}System.out.println("after try catch");}
}

• 如果多个异常的处理方式是完全相同, 也可以写成这样：

• catch的时候，抛出子类，catch父类
  
• 如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误：
  
• catch Throwable：虽然可以捕获异常，但是无法区别具体是哪种异常

2.3.3 finally：和 try catch 并列的语句块

1. finally 语法格式：

        try{
// 可能会发生异常的代码}catch(异常类型 e){
// 对捕获到的异常进行处理}finally{
// 此处的语句无论是否发生异常，都会被执行到}
// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

2. 程序释放需要finally3. finally 作用

在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。
另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。

3. try catch finally 的打印顺序和执行顺序不一样

4. finally中的return会覆盖掉 try catch中的 return 结果

【总结】

（1）try catch finally 基本语法结构
（2）异常处理代码的执行顺序：throw 出异常，try 后续的代码不再执行，进入匹配的 catch ,最后在执行 finally。
（3）多个catch 的匹配规则：从上到下，子类异常能够被父类捕获到。

三、 自定义异常类

异常就是类，自己写类，自己的类继承自标准库的异常类（Expetion、RuntimeException…）

自定义异常 实例：

//创建异常类
class UsernameExpection extends Exception{}
class PasswordExpection extends Exception{}//实现登录的过程
class Login{private String username = "admin";private String password = "123456";public void login(String username,String password) throws UsernameExpection, PasswordExpection {/*  //事先防御型if(!username.equals(this.username)){System.out.println("用户名错误！");return;}if(!password.equals(this.password)){System.out.println("密码错误！");return;}System.out.println("登录成功！");*/if(!username.equals(this.username)){throw new UsernameExpection();}if( !password.equals(this.password)){throw new PasswordExpection();}}
}public class Demo13 {public static void main(String[] args) {Login login = new Login();try {login.login("adim", "123456");} catch (UsernameExpection e) {System.out.println("用户名错误！");} catch (PasswordExpection e) {System.out.println("密码错误！");}}
}

引入自定义异常，目的就是为了后续能够快速得找到出现问题的原因。