异常处理
错误:
1.语法错误:
有语法问题无法编译
2.运行时错误:
可以编译，但执行过程中出错.级别低的就是异常
3.逻辑错误:
运行的顺序，条件或者计算方法出错.能编译能运行，不报错，但结果出错.
Exception异常类型，是错误的子类(Error)
五个关键字处理异常,两种方法(处理和向上抛)
try catch finally throw throws
用法1:作为代码块的一个部份,处理异常
try{
}catch(异常类型 变量){
}finally{
}
用法2:定义方法时定义异常，并抛出异常
public void fun() throws 异常类型{
if(条件)
throw new 异常();
}
=============================================
1.处理异常(捕获异常)
try,catch,finally用法
try{
//可以会发生错误的代码
}catch(异常类型 变量){
//错误的处理代码
}finally{
//始终要执行的代码
//一般情况用于释放资源
}
注意:
1.try必须跟至少一个catch或finally块,try不能单独存在。
2.catch块可以有多个,但是异常类型必须不同(先子类后父类)。
3.所有非RuntimeException类型(及子类)的异常必须处理
异常处理：
1.强置受检
2.可以不受检，RuntimeException及子类可以不处理
try代码是用于监控代码块,可能会发生异常的代码
catch代码块处理异常，如果发生异常就执行匹配类型catch块
finally代码块是无论有没有错误都去执行代码块
======================================
1.处理异常(抛出异常)
throw和throws的用法
Exception ex = new Exception();//创建一个异常对象
throw ex;//抛出异常对象
或
throw new Exception();//抛出一个匿名异常对象
使用throw关键字在代码块中抛出异常
一般用法:
if(条件)
throw ...
注意:
如果抛出异常，可以马上捕获或者向上抛出
示例:声明一个设置年龄的方法,并向上抛出异常
public void setAge(int age) throws RuntimeException{
//参数不为负数
if(age<0)
throw new RuntimeException("年龄不能为负数");
this.age = age;
}
或者
//如果抛出异常，可以马上捕获,不建议使用
public void setAge(int age){
//参数不为负数
try{
if(age<0)
throw new RuntimeException("年龄不能为负数");
}catch(RuntimeException e){
//处理异常的代码;
}
this.age = age;
}
============自定义异常===================
//自定义异常，必须继承Exception类(子类),名称为区别于普通类，一般定义为Exception结尾
class XxxxException extends Exception{
public XxxxException(){}
public XxxxException(String message){super(message)};
}
示例:设置不能为负数的年龄异常
class AgeException extends Exception{
public AgeException(){
super("年龄不能为负数!");
}
public AgeException(String message){
super(message);
}
}
使用异常
class Student{
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(String name){
return name;
}
//定义设置年龄,可能出现异常
public void setAge(int age)
throws AgeException{
if(age<0)
throw new AgeException();//throw抛出一个错误对象
this.age = age;
}
public int getAge(){
return age;
}
public String toString(){
return "姓名:"+name+"年龄:"+age;
}
}
public class Test{
public static void main(String args[]){
Student s1 = new Student();
s1.setName("张三");
try{
s1.setAge(18);//可能发生错误
}catch(AgeException e){
System.out.println("年龄出错:"+e.getMessage());
}
System.out.println(s1);
}
}
Throwable:Throwable 类是 Java 语言中所有错误或异常的超类。
Error:
Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
Exception:
Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
有很多的子类，常见子类
RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
IOException 输入输出异常
1.异常类型
Exception异常根类
常见子类
受检类型（Checked)
IOException:输入输出异常
SQLException:sql异常
ClassNotFoundException:找不类
...
不受检类型(unchecked)
RuntimeException
NullPointerException:引用的对象是null
IndexOutOfBoundsException:下标越界
ArrayIndexOutOfBoundsException
StringIndexOutOfBoundsException
ClassCastException:类型转换出错
...
2.捕获异常
try{
//代码块
}catch(异常类型 ex){
异常处理
}
//JDK1.7+,可以同时匹配多个异常类型
try{
//代码块
}catch(异常类型1|异常类型2|... ex){
异常处理
}
try{
//代码块
}catch(异常类型1 ex){
异常处理
}catch(异常类型2 ex){
异常处理
}catch...
try{
//代码块
}finally{
始终要执行的代码块(释放资源)
}
//JDK1.7+,可以自动释放资源
try(资源){
//代码块
}catch(异常类型 ex){
异常处理
}
try{
//代码块
}catch(异常类型 ex){
异常处理
}finally{
始终要执行的代码块
}
3.抛出异常
在声明方法时，声明异常同时在代码块中抛出异常
public void fun() throws 异常类型1,异常类型2,...{
if(条件)
throw new XxxException1();
try{
...
}catch(XxxException2 ex){
throw ex;
}
}
4.自定义异常类型
1.必须继承Exception或Exception的子类
2.名称建议以Exception结尾，标注是一个异常类型
public X1Exception extends Exception{
public X1Exception(){super("默认的错误提示信息!");}
public X1Exception(String msg){super(msg);}
}
public X2Exception extends RuntimeException{
public X1Exception(){super("默认的错误提示信息!");}
public X1Exception(String msg){super(msg);}
}
void fun1(){
1....
try{
2...
3...
4...
}catch(IOException e){
5...
}catch(RuntimeException e){
6...
}finally{
7...
}
8...
}
如果没有执行时没有异常，执行顺序:
123478
如果执行时2行发现IO异常,执行顺序:
12578
如果执行时3行发现NullPointer异常 ,执行顺序:
123678
如果执行时4行发现ClassNotFound异常,执行顺序:(题有问题,ClassNotFoundException必须处理)
12347
1 ...
2 try{
3 ...
4 ...
5 ...
6 ...
7 }catch(异常类型1 变量){
8 错误的处理代码
9 }catch(异常类型2 变量){
10 错误的处理代码
11 }finally{
12 始终要执行的代码
13 }
14 ...
如果代码没有任何异常,执行顺序
1->3->4->5->6->12->14
如果代码4发生"异常类型1"异常,执行顺序
1->3->8->12->14
如果代码6发生"异常类型2"异常,执行顺序
1->3->4->5->10->12->14
如果代码5发生异常与“异常类型1和类型2”都不匹配,执行顺序
1->3->4->12
throw
