一，异常的概述
1，异常是什么？
A，异常模拟的是现实世界中华“不正常的”事件。
B，java中采用“类”去模拟异常。
C，类是可以创建对象的。
NullPointerException e=0x0012;
e 是引用类型， e中保存的是内存地址指向堆中的“对象”。
这个对象一定是NullPointerException类型。
这个对象就表示真实存在的异常事件，NullPointerException是一类异常。
2，异常机制的作用？
java语言为我们提供一种完善的异常处理机制。
作用是：程序发生异常事件之后，为我们输出详细的信息，程序员通过这个信息，可以
对程序进行一些处理。使程序更加健壮。
public class ExceptionTest{
public static void main(String[] args){
int a=10;
int b=0;
int c=a/b; //ArithMeticException 异常
//上面代码出现异常“没有处理”，下面的代码不会执行，直接退出JVM。
System.out.println("test语句");
/*
以上程序编译通过，但是运行时会出现异常，表示发生某个异常事件。
异常本质：程序执行过程中发生了算数异常这个事件，JVM为我们创建了一个
ArithMeticException类型对象。并且这个对象中包含了详细的异常信息，并且
JVM将这个对象中的信息输出到控制台。
*/
//异常处理机制使程序更加健壮
int a=10;
int b=0;
if(b!=a){
int c=a/b;
System.out.println(a+"/"+b+"="+c);
}else{
System.out.println("除数不能为0");
}
}
}
二，异常继承图
三，throws关键字声明异常
处理异常有两种方式：
1，声明抛出：throws
2，捕捉：try……catch……
以下演示是第一种方式：声明抛出，在方法声明的位置上使用throws关键字向上抛出异常。
public class Exceptiontest01{
public static void main(String[] args) throws FileNotFoundException{
//public static void main(String[] args) throws IoException//这三种都可以
//public static void main(String[] args) throws Exception
//创建文件输入流，读取文件
//java编译器是如何知道这个异常发生的概率比较高呢？
//因为FileIuputStream这个构造方法在声明的位置上使用了throws FileNotFoundException
FileIuputStream fis=new FileIuputStream("c : /ab.test");
以上程序没有使用throws抛出时，编译不能通过。
}
}
3，throws关键字深入
public class ExceptionTest02{
public static void main(String[] args) throws FileNotFoundException{
//m1();
//使用throws处理异常不是真正处理异常而是推卸责任，谁调用的就抛给谁。
//真正处理
try{
m1();
}catch(FileNotFoundException e){}
System.out.println("HelloWorld");
}
public static void m1() thorws FileNotFoundException{
m2();
}
public static void m2() thorws FileNotFoundException{
m3();
}
public static void m3() thorws FileNotFoundException{
new FileIuputStream("c : /ab.test");
//FileIuputStream构造方法声明位置上使用throws（向上抛）。
}
}
四，使用try……catch捕捉异常
语法：
try{
可能出现异常的代码
}catch(异常类型1 变量){
处理异常的代码
}catch(异常类型2 变量){
处理异常的代码
}…………
1，catch语句块可以写多个。
2，但是从上到下catch，必须从小类型异常到大类型异常进行捕捉。
3，try……catch……中最多执行一个catch语句块。执行结束之后try……catch……就结束了。
public class Exceptiontest03{
public static void main(String[] args){
/*
//以下代码编译不通过，因为FileNotFoundException没有处理
try{
//这里应该捕捉FileNotFoundException异常，但是捕捉了算数异常。
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
}catch(ArithmeticException e){
//捕捉的异常是算数异常
}
*/
//编译通过
/*
try{
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
}catch(FileNotFoundException e){}
*/
//以下程序编译无法通过，因为还有更多IOException没有处理
/*
try{
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
fis.read();
}catch(FileNotFoundException e){}
*/
//编译通过
/*
try{
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
fis.read();
}catch(FileNotFoundException e){
}catch(IOException e){}
*/
//编译通过
/*
try{
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
fis.read();
}catch(IOException e){}
*/
//编译无法通过
/*
//catch可以写多个，但是必须从上到下，从小到大捕捉
try{
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
fis.read();
}catch(IOException e){
}catch(FileNotFoundException e){}
*/
}
}
public class ExceptionTest04{
//编译无法通过，IOException没有处理
/*
public static void main(String[] args) throw FileNotFoundException{
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
fis.read();
}
*/
//编译通过
/*
public static void main(String[] args) throw FileNotFoundException{
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
fis.read();
}
*/
public static void main(String[] args){
try{
//程序执行到此处发生了FileNotFoundException类型对象，JVM会自动创建一个
//FileNotFoundException类型的对象，将该对象的内存地址赋值给catch语句块中的 e 变量
FileIuputStream fis=new FileIuputStream("abc")；
//上面的代码出现异常，try语句块的代码不执行，直接进入catch语句块中执行。
fis.read();
}catch(FileNotFoundException E){
//e内存地址指向堆中的那个对象是"FileNotFoundException类型的"事件。
System.out.println(e);//abc（系统找不到指定文件）
}catch(IOException e){
System.out.println("其他IO异常");
}
System.out.println("ABC");
}
}
五，关于getMessage和printStackTrace方法的应用
public class ExceptionTest05{
public static void main(String[] args){
try{
FileIuputStream fis=new FileIuputStream("c : /ab.txt")；
}catch(FileNotFoundException e){
//e.printStackTream();//打印异常堆栈信息
//一般情况下都是这个方法区调试程序，打印信息比下面的方法更详细。
String mag=e.getMessage();//打印异常描述信息
System.out.println(mag);//（系统找不到指定文件）
}
System.out.println("ABC");
}
}
六，关于finally语句块
1，finally语句块可以直接和try语句块联用。try……finally……
2，try……catch……finally也可以
3，在finally语句块中的代码是一定会执行的。
public class ExceptionTest06{
public static void main(String[] args) throws Exception{
/*
try{
System.out.println("ABC");
return;
}finally{
System.out.println("test");
}
*/
try{
FileIuputStream fis=new FileIuputStream("Test.java")；
//不会执行
System.out.println("tttttt");
}finally{
//会执行
System.out.println("finally语句块");
}
try{
//退出JVM，只有这种情况finally语句块才不会执行
System.exit(o);
}finally{
System.out.println(finally语句);
}
//只要在执行finally语句块之前退出JVM，否则finally语句块不会执行。
}
}
public class ExceptionTest07{
public static void main(String[] args){
int i=m1();
System.out.println(i);// 10
}
public static int m1(){
int i=10;
try{
return i;
}finally{
i++;
System.out.println("m1="+i);
}
//以上代码执行原理
/*
int i=10;
try{
int temp=i;
return temp;
}finally{
i++;
System.ot.println("m1="+i);
}
*/
}
}
finally语句块是一定会执行的，所以通常在程序中为了保证某资源一定会释放，
所以一般在finally语句块中释放资源。
public class ExceptionTest08{
public static void main(String[] args){
//必须在外边声明
FileIuputStream fis=null；
try{
fis=new FileIuputStream("ExceptionTest08")；
}catch(FileNotFoundException E){
e.printStackTrace();
}finally{
//为了保证某资源一定释放
if(fis!=null){
try{
fis.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
}
}
七，手动使用throws抛出异常
自定义“无效名字异常”。
1，编译时异常，直接继承Exception
2，运行时异常，直接继承RuntimeException
（1）
//编译时异常
public class IllegalNameException extends Exception{
//public class IllegalNameException extends RuntimeException{// 运行时异常}
//定义异常一般提供两个构造方法
public IllegalNameException(){}
public IllegalNameException(String msg){
super(msg);
}
}
(2)
//顾客相关业务
public class CustomerSercice{
//对外提供一个注册的方法
public void register(String name) throws IllegalNameException{
//完成注册
if(name.length()<6){
//异常
//创建异常对象
//IllegalNameException e=new IllegalNameException("用户名长度不能少于6位")；
//手动抛出异常
//throw e；
throw new IllegalNameException("用户名不能少于6位");
}
//如果代码能执行到此处，证明用户名是合法的。
System.out.println("注册成功");
}
}
（3）
//模拟注册
public class Test{
public static void main(String[] args){
//假如用户提供的用户名如下
String username="khsadkhk";
//注册
CustomerSercice cs=new CustomerSercice();
try{
cs.register(username)；
}catch(IllegalNameException e){
System.out.println(e.getMessage());
}
}
}
这（1）（2）（3）一起使用，创建在同一个包里面。
八，方法覆盖，方法重写的异常
class A{
public void m1(){}
}
class B extends A{
public void m2() throws Exception{}
//子类无法抛出比父类更多的异常
}
class A{
public void m1() throws IOException{}
}
class B extends A{
public void m1() throws FileNotFoundException
}
