|
目录
1、编译时异常和运行时异常???
1.1 基本概念
1.2 二者区别
1.3 对异常的处理
2、深入try...catch异常
2.1 try...catch的格式
2.2 关于try...catch
2.3 JDK新特性
2.4、上报和捕捉如何选择
3、getMessage()方法和printStackTrace()方法
4、finally子句
5、final、finally和finalize的区别
5.1 final
5.2 finally
5.3 finalize（）
6、自定义异常
6.1 自定义异常的步骤
6.2 栈内存程序的改进
7、子类重写的方法抛出编译异常只能更少/小不能更多
1、编译时异常和运行时异常???
1.1 基本概念
编译时异常和运行时异常都是发生在运行阶段，编译阶段异常不会发生；
编译时异常必须在编译（编写）阶段预先处理，如果不处理编译器报错；
所有异常都是在运行阶段发生的，因为只有程序运行阶段才可以new对象。异常的发生就是new异常对象
1.2 二者区别
编译时异常（受检异常、受控异常）发生概率较高，需要在运行之前对其进行预处理；
运行时异常（未受检异常、非受控异常）发生概率较低，运行之前不需要进行预处理；
1.3 对异常的处理
1）在方法声明的位置上，使用throws关键字；【抛给上一级，谁调用我，我就抛给谁；抛给上一级同样有两种方式】
java中异常发生之后如果一直上抛，最终抛给了main方法，main方法继续向上抛，抛给了调用者JVM，JVM终止程序的执行
2）使用try..cathch语句进行异常的捕捉；【这件事发生了谁也不知道，因为我给抓住了】
public class Sttt{
? ?public static void main(String[] args) {
? ? ? ?System.out.println(100/0);
//程序执行到此发生ArithmeticException异常，底层new了一个ArithmeticException异常对象，然后抛给了main方法，main方法最后无法处理，将异常抛给了JVM，JVM最终终止了程序的执行
? ? ? ?System.out.println("helloworld");
? }
}
//ArithmeticException 继承 RuntimeException，属于运行时异常，在编写程序时不需要对这种异常进行预先处理
public class Sttt{
? ?public static void main(String[] args)throws ClassNotFoundException//处理方式1 {
doSome();//因为doSome方法()的声明位置上有 throws ClassNotFoundException 所以在调用的时候要对这种异常进行预先的处理，不处理，编译器会报错
? ?
? //Alt + 回车 可以生成
?
? try {
? ? ? ? ? ?doSome();
? ? ? } catch (ClassNotFoundException e) {
? ? ? ? ? ?e.printStackTrace();
? ? ? }//处理方式2
? }
}
public static void doSome() throws ClassNotFoundException{
//ClassNotFoundException类没找到异常，父类是Exception，所以属于编译时异常
}
3）在抛出异常时，可以抛出该异常的父对象
throws后面可以写多个异常，并且用逗号隔开;
一般不建议在main方法上使用throws，因为这个异常如果真的发生了，一定会抛给JVM，JVM只能终止
异常处理机制的作用就是提高程序的健壮性，保证程序出现了异常也能执行,所以main方法中的异常建议是使用try...catch进行捕捉。main不要继续上抛了
注意：只要异常没有捕捉，采用上报的方式，此方法的后续代码不会执行，另外需要注意：try语句块的某一行出现异常，改行后面的代码不会执行，try catch后续的代码仍然执行
2、深入try...catch异常
2.1 try...catch的格式
try{
? ?//try尝试
m1();
}catch(FileNotFoudException e){
//catch是捕捉异常之后走的分支
? ?System.out.println("文件不存在，可能路径写错了，也可能该文件被删除了");
}
2.2 关于try...catch
1、catch后面的小括号中的类型可以是具体的异常类型，也可以是该异常类型的父类型
2、catch可以写多个，便于程序的调试，catch写多个的时候从上到下，必须遵守从小到大
2.3 JDK新特性
try{
}catch(FileNotFoundException|ArithmeticException|NullPointerException e){
?
}
2.4、上报和捕捉如何选择
如果希望调用者来处理，则选择throws上报
3、getMessage()方法和printStackTrace()方法
public class Sttt{
? ?public static void main(String[] args) {
? ? ? ?//这里为了测试两个方法，而new的异常对象，但是没有吧异常对象抛出，JVM认为是一个普通的java对象
? ? ? ?NullPointerException e =new NullPointerException("空指针异常！");
? ? ? ?//获取异常简单描述信息：这个信息实际上就是构造方法中的String参数
? ? ? ?String msg = e.getMessage();
? ? ? ?System.out.println(msg);
? ? ? ?e.printStackTrace();//打印异常信息，java后台打印异常堆栈信息的时候采用了异步线程的方式打印的
? }
}
4、finally子句
1）在finally子句中的代码是最后执行的，并且是一定会执行的，即使try语句块的代码出现了异常，
2）finally子句必须和try一起出现，不能单独编写；
3）finally语句通常使用在完成资源的释放/关闭，因为finally语句块中的代码比较有保障，即使try语句块中的代码出现异常，finally中的代码也会正常进行
4）try语句块即使有return，那么finally也会执行，只有当System.exit(0)退出JVM时，才不会执行finally
public class Sttt{
? ?public static void main(String[] args) {
? ? ? ?FileInputStream fis = null;//声明位置放到try外面，这样才能在finally中使用
? ? ? ?try{
? ? ? ? ? ?FileInputStream fis = new FileInputStream("D:\\java\javase");
? ? ? ? ? ? ? ? ? ?//开始读文件
? ? ? ? ? ? ? ? ? ?String s = null;
? ? ? ? ? ? ? ? ? ?//这里空指针异常
? ? ? ? ? ? ? ? ? ?s.toString();
? ? ? ? ? ? ? ? ? ?//流用完需要关闭，因为流是占用资源的
? ? ? ? ? ? ? ? ? ?//即使上面程序出现异常，流也必须关系
? ? ? ? ? ? ? ? ? ?//放在这里有可能关不了
? ? ? }catch (FileNotFoundException e){
? ? ? ? ? ?e.printStackTrace();
? ? ? }catch (IOException e){
? ? ? ? ? ?e.printStackTrace();
? ? ? }catch (NullPointerException e){
? ? ? ? ? ?e.printStackTrace();
? ? ? }finally {
? ? ? ? ? ?//流的关闭放到这里比较保险
? ? ? ? ? ?//finally中的代码是一定会执行的
? ? ? ? ? ?//即使try中出现了异常
? ? ? ? ? ?if(fis != null)//避免空指针异常
? ? ? ? ? ? ? ?try{
? ? ? ? ? ? ? ? ? ?//close()方法有异常，采用捕捉的方式
? ? ? ? ? ? ? ? ? ?fis.close();
? ? ? ? ? ? ? } catch(IOException e){
? ? ? ? ? ? ? ? ? ?e.printStackTrace();
? ? ? ? ? ? ? }
? ? ? }
? }
}
5）面试题
java的语法规则：
方法体中的代码必须遵循自上而下顺序依次逐行执行（亘古不变的语法）
return语句一旦执行，整个方法必须结束
public class Sttt{
? ?public static void main(String[] args) {
?
? ? ? ?System.out.println(m());//结果是100
? }
? ?public static int m(){
? ? ? ?int i= 100;
? ? ? ?try{
? ? ? ? ? ?//这行代码出现在 int i = 100;的下面，所以最终结果必须是返回100
? ? ? ? ? ?//return 语句还必须保证是最后执行的，一旦执行，整个方法结束
? ? ? ? ? ?return i;
//这里可以理解为自上而下i已经传入了return中但是还没有执行，所以后面的finally无论在return前怎么改变i的值，return i都不会改变
? ? ? }finally{
? ? ? ? ? ?i++;
? ? ? }
? }
}
反编译的代码
public static int m{
int i = 100;
int j = i;
i++;
return j;
}
5、final、finally和finalize的区别
5.1 final
final是一个关键字。表示最终的、不可变的
final int i = 100；
5.2 finally
finally也是一个关键字。和try连用，使用在异常处理机制当中
finally语句块中的代码一定会执行的
try{
?
}finally{
}
5.3 finalize（）
finalize()是Object类的一个方法，作为方法名出现，所以finalize是标识符
finalize()方法是JVM的GC垃圾回收器负责调用
6、自定义异常
6.1 自定义异常的步骤
第一步：编写一个类继承Exception或者RubtimeException
第二步：写两个构造方法，一个无参构造方法和一个有参构造方法
注意：throw在手动抛异常的时候使用，throws表示上报异常信息给调用者
public class Sttt{
? ?public static void main(String[] args) {
? ? ? ?//new了一个异常对象（没有手动抛出）
MyException e = new MyException("用户名不能为空");
? ? ? ?//打印异常信息
? ? ? ? e.printStackTrace();
? ? ? ?//获取异常简单描述信息
? ? ? ?String msg = e.getMessage();
? ? ? ?System.out.println(msg);
? }
}
?
public class MyException extends Exception{
public MyException(){
}
public MyException(String s){
super(s);
}
}
6.2 栈内存程序的改进
public class Text {
? ?public static void main(String[] args) {
? ? ? ?//创建一个栈对象，初始化容量是10个
? ? ? ?Stack s = new Stack();
? ? ? ?s.push("12345ty");
? ? ? ?s.push(new Object());
? ? ? ?s.push(new Object());
? ? ? ?s.push(new Object());
? ? ? ?s.push(new Object());
? ? ? ?s.pop();
? ? ? ?s.pop();
? ? ? ?s.pop();
? ? ? ?s.pop();
? ? ? ?s.pop();
? ? ? ?s.pop();
? ? ? ?//可以使用for循环进行压栈和弹栈
? }
}
class Stack{
? ?//存储任何引用类型数据的数组
? ?private Object[] elements;
? ?//有参构造方法
? ?public Stack(Object[] elements) {
? ? ? ?this.elements = elements;
? }
? ?//无参构造方法
? ?public Stack() {
? ? ? ?//一维数组动态初始化
? ? ? ?//默认初始化容量为10
? ? ? ?this.elements = new Object[10];
? }
? ?//栈帧（永远指向栈顶元素）
? ?private int index=-1;
//压栈方法
public void push(Object obj) throws MystackQperationException{
? ?
? ?
? ? ? ? ? ? ? ? ? ? ?//重点！！！！！！！！！！！！！
? ?if(this.index >= this.elements.length-1){
? ? ? ?throw new MystackQperationException("栈内存已满，压栈失败");
? ? ? ?//不要进行try...catch，自己new自己抓的操作，必须抛给调用者
? }//这里进行了改进
? ? ? ? ? ? ? ? ? ? ?//重点！！！！！！！！！！！！！
? ?
? ?
? ?index++;
? ?elements[index] = obj;
? ?System.out.println(obj + "元素，压栈成功，栈帧指向" + index);
}
?
//弹栈方法
public void pop() throws MystackQperationException{
? ?
? ?
? ? ? ? ? ? ? ? ? ?//重点！！！！！！！！！！！！！
? ?if(this.index <= -1) {
? ? ? ?//System.out.println("栈内存已空，弹栈栈失败");
? ? ? ?throw new MystackQperationException("栈内存已空，弹栈栈失败"); ?
? }
? ? ? ? ? ? ? ? ? ?//重点！！！！！！！！！！！！！
? ?
? ?
? ?else
? ? ? ?System.out.println(elements[index] + "元素，弹栈成功,栈帧指向" + --index);
}
//自定义栈操作异常
public class MystackQperationException{
? ?public MystackQperationException{
? ? ? ?
? }
? ?public MystackQperationException(String s){
? ? ? ?super(s);
? }
}
//static实例变量的get方法
public Object[] getElements() {
? ?return elements;
}
//static实例变量的set方法
public void setElements(Object[] elements) {
? ?this.elements = elements;
}
//实例变量栈帧的get方法
public int getIndex() {
? ?return index;
}
//实例变量栈帧的set方法
public void setIndex(int index) {
? ?this.index = index;
}
}
7、子类重写的方法抛出编译异常只能更少/小不能更多
class Animal{
public void doSome(){
}
public void doOther() throws Exception{
}
}
class Cat extends Animal{
public void doSome() throws Exception{
//编译报错
}
? ?public void doOther() throws Exception{
//编译正常
}
? ?public void doOther(){
//编译正常
}
? ?public void doOther() throws NullPointerException{
//编译正常
}
? ?public void doSome() throws RuntimeException{
//运行编译子类可以正常抛出更多，而编译异常不行
}
}
|