2022-07-29 第四组 王佳齐 学习笔记

异常处理

 

 

学习笔记：

异常处理

1.下标越界

2.空指针

3.类型转换异常

4.数学格式化

5.算数异常

编程界严重事故

1.除数为零

2.io流 没有关闭

3.停电

 

当一个程序抛出异常时，抛异常后面的语句不再执行，类似return的作用，终止方法的执行

 

处理异常：

try {
    //把有可能抛异常的代码放到try语句
    System.out.println(n/n1);
    
}catch (Exception e){//e是属性
    System.out.println("除数不能为0");
    //打印异常
    e.printStackTrace();
}

 

此时的drrrd不会被打印，因为try语句中一旦判定该语句出现异常，就会跳出并执行catch语句

try {
    //把有可能抛异常的代码放到try语句
    System.out.println(n/n1);
    System.out.println("drrrd");
}catch (Exception e){//e是属性
    System.out.println("除数不能为0");
    //打印异常
    e.printStackTrace();
}

 

 

异常的继承体系结构

最顶级的Throwable：错误，异常

Error：正常情况下，不太可能出现的。绝大部分的错误都会导致程序处于一个非正常的状态下，很

难恢复。外力的作用下，不考虑。

• Error是Throwable的子类，它是在Java程序处理范围之外的

Exception：在Java语言中，将程序执行中发生的不正常的情况称为异常

• 编译期异常：写代码的时候，抛异常。如果编译期不解决，会编译不通过，一直报红。
• 运行期异常：RunTimeException.运行时会抛异常，平时没事*

自定义异常：Java中异常机制很完善，但是结合实际业务还是不够用。

怎么自定义异常：

1.所有异常必须是Throwable的子类，（大材小用，没必要）

2.如果要定义一个编译期异常，需要继承Exception类

3.如果要继承一个运行期异常，需要继承RunTimeException类

package morining;
/*
* 在一个语句块中如果使用throw抛出一个编译期异常，必须在方法的声明处使用throws关键字来标记异常，还有一种处理方式就是直接try catch处理掉*/
public class Ch03 {
    public static void fun(int i,int j) throws MyException{
        if (j==0){
            throw new MyException("除数不为零");
        }
        System.out.println(i/j);
        }


    public static void main(String[] args) {
        fun(1,0);
    }
}
 

 

package morining;
/*
* 在一个语句块中如果使用throw抛出一个编译期异常，必须在方法的声明处使用throws关键字来标记异常，还有一种处理方式就是直接try catch处理掉*/
public class Ch03 {
    public static void fun(int i,int j) throws MyException{
        if (j==0){
            throw new MyException("除数不为零");
        }
        System.out.println(i/j);
        }


    public static void main(String[] args) {
            try {
                fun(1,0);
            }catch (MyException e){
                //打印异常信息
                e.printStackTrace();
            }
    }
}
 

 

package morining;


public class Ch03 {
    public static void fun(int i,int j){
        if (j==0){
            throw new MyRunTimeException("除数不为零");
        }
        System.out.println(i/j);
        }


    public static void main(String[] args) {
        fun(1,0);
    }
 

 

package morining;
/*自定义异常
* */


public class SE extends RuntimeException{
    //错误码
    private Integer code;
    //异常信息
    private String message;


    public SE() {
    }


    public SE(Integer code, String message) {
        this.code = code;
        this.message = message;
    }


    public Integer getCode() {
        return code;
    }


    public void setCode(Integer code) {
        this.code = code;
    }


    @Override
    public String getMessage() {
        return message;
    }


    public void setMessage(String message) {
        this.message = message;

 

 

我们为什么要手动抛异常？

因为要配合全局异常机制来处理问题。

throw语句可以当作方法的返回值的

在一个有返回值的方法中，如果有多个条件分支，必须保证每个分支都有返回值，哪怕是抛异常，开发中大部分情况下使用的都是运行期异常

 

 

异常链

一个异常被抛出去之后会继续被调用这个方法的方法捕获或抛出，异常会扩散

 

package morining;
/*
* 异常链
    一个异常被抛出去之后会继续被调用这个方法的方法捕获或抛出，异常会扩散*/
class A{
    public void a(){
        throw new SE(201,"业务异常");
    }
}
class B{
    public void b(){
        A aa = new A();
        aa.a();
    }
}
class C{
    public void c(){
        B bb = new B();
        bb.b();
    }
}
public class Ch04 {
    public static void main(String[] args) {
        C c = new C();
        c.c();
    }
}
 

 

package morining;
/*
* 如果一个方法没有捕获一个编译期异常，该方法必须使用throws来声明*/
public class Ch05 {
    public void show() throws RuntimeException{
        
    }
    public void info(){
        show();
    }
    public static void main(String[] args){
        new Ch05().info();
    }
}

 

 

如果一个方法没有捕获一个编译期异常，该方法必须使用throws来声明

package morining;
/*
* 如果一个方法没有捕获一个编译期异常，该方法必须使用throws来声明
* 
* throws并不是真正解决了异常，只是把异常抛给了下一个调用者
* 
* */
public class Ch05 {
    public void show() throws Exception{


    }
    public void info() throws Exception {
        show();
    }
    //最终抛给JVM
    public static void main(String[] args) throws Exception {
        new Ch05().info();
    }
}

 

 

面试题throw和throws的区别！！！throws出现在什么地方？方法的声明处，抛出多个异常，用 ， 隔开

 

finally关键字

 

finally用来创建在try代码块后面执行的代码块

无论是否发生异常finally代码块的代码一定会执行

一般finally中的代码都是用来释放空间的 除了让所有的程序强制退出的System.exits(-1)的语句

 

 

package morining;
/*finally关键字
finally用来创建在try代码块后面执行的代码块
无论是否发生异常finally代码块的代码一定会执行
        一般finally中的代码都是用来释放空间的
除了让所有的程序强制退出的System.exits(-1)的语句*/
public class Ch06 {
    public static void main(String[] args) {
        int n = 1;
        int n1 = 0;
        try {
            System.out.println(n/n1);
        }catch (Exception e){//e是属性
            e.printStackTrace();
        } finally {//放入必须要执行的语句，无论前面怎么错这里面的命令都会执行
            System.out.println("finally...");
        }


    }
}
 

catch多写：

注意，写多个catch时，需要把小的写在前面，也就是我们能够确定的小的范围异常，后面再补上一个最大的异常

 

package morining;
/*
* 注意，写多个catch时，需要把小的写在前面，也就是我们能够确定的小的范围异常，后面再补上一个最大的异常*/
public class Ch07 {
    public static void main(String[] args) {
        int a= 10;
        int b= 0;
        try {
            System.out.println(a/b);
            //从开发角度来说，应该写指定的
        }catch (ArithmeticException e){
            e.printStackTrace();
            System.out.println("除数不能为零");
        }catch (Exception e) {
            System.out.println("未知错误");
        }
    }
}

 

 

 

重写

重写的方法不能抛出比被重写的方法更大的异常

 

package morining;
/*重写的方法不能抛出比被重写的方法更大的异常*/
interface Inter01 {
    void show() throws SE;
}
public class Ch08 implements Inter01{




    @Override
    public void show() throws Exception //这里会标红{
        
    }

 

 

学习心得：

今天学习了异常处理，抛出异常，自定义异常，还有一点异常的方法，今天是学的没那么吃力的一天。