Java异常教程_java 异常 -1005-CSDN博客

本文链接：https://blog.csdn.net/qq_36545519/article/details/145472267

异常

学习网站：
https://www.bilibili.com/video/BV1GU4y1A7J4/?p=7&spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=3529d60bf9f6a997966da275bb45f972

/0异常

空字符串空指针异常

异常：程序运行过程发生不正常的事件中断运行的程序

程序不正常事件对不正常事件进行描述的对象

常见异常

除数不能为0
空指针异常()
数据下标越界()
类型转换异常（ClassCastException）

3.异常的分类

出门前天气燃气卡

出门后：等公交

坐公交

编译 Exception
1. 程序编译异常
运行
1. 运行时候出现异常
错误
1. java虚拟机抛出的异常如栈溢出

二、异常处理

程序出现异常 java虚拟机帮我们处理他会直接结束程序执行

1.自己处理

通过try catch 语句块

1.1单个异常

try{
//可能异常语句
}catch(要捕获的异常类型  起个异常名称){
//
}finally{
//释放资源  最后一定执行
}

如果catch捕获异常不匹配则异常给java虚拟机输出

分别捕获

ArithmeticException e 可以

NullPointerExceptrion e 

Exception e 可以

RuntimeException e 可以

因为ArithmeticException异常父类可以接受子类

1.2 多个异常处理

多个异常try？

只要看到一个异常后面就不再执行

子类异常在前父类异常在后保证小范围异常捕获不到最后父类异常保底

捕获空指针异常输出堆栈错误信息

什么异常

红色：什么类声明方法出现异常

除0 运行异常

java.lang.ArithmeticException
这个类异常

这个类异常

捕获一下：

2.将异常抛出

what：

自己处理不了丢到上层

上层来处理：try catch finally

抛出多个异常

throws 后面语句都不在处理

所以主方法一般都不抛出而是直接处理

接口向外声明要抛出异常实现时候可以缩小异常范围

三、throw关键字

throws throw throwable区别

throws：

what：

函数的异常抛出

throw：

what：

动词抛出异常对象内部处理/抛给外部

且返回上一级

throw throws区别：

throw抛出的异常

内部处理

我们可以在方法体内部设置好“接球手”！这些“接球手”就是 try-catch 块。当 throw 把“山芋”扔出来后，如果在同一方法体内存在相应的 catch 块，那么这位“接球手”就能稳稳地接住它，并按照预设的方式进行处理。这样，不仅避免了程序直接崩溃，还能优雅地解决这个问题，让程序继续平稳运行下去。

thorws抛给外部

运行时异常：

what：

运行时候检查出来异常

how：

编译时候检查不出来所以不用抛出异常

函数体抛出异常主方法要接收处理然后继续主方法

how use：

内部处理 / 抛给外部

编译异常：

what：

编译不通过有异常

example：

1.throw new ParseException(“解析错误”,1)

throw new ParseException("解析错误",1)

2.sdf.parse(str)

public static void show() throws ParseException{
    String str = "2020-01-05";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    sdf.parse(str); //出现异常
    
}

solve：

在编译时候就要抛出 / 处理

fact1: 运行异常

/*
    what:
        运行异常
     */
    public static void exceptionThrowDispose(){
        int i = 100;
        try {
            System.out.println( i / 0);
        }catch(Exception e){
            System.out.println("运行异常 除0异常。。");
            e.printStackTrace();
        }
    }

e.printStackTrace();

返回异常种类 java.lang.ArithmeticException: / by zero

异常来自哪个类哪个方法多个函数一层一层输出调用关系

at throwsKeyWord.exceptionThrowDispose(throwsKeyWord.java:35)
at throwsKeyWord.main(throwsKeyWord.java:12)

what:

throw 隐式抛到主函数外部无法识别

public static double exceptionThrowDispose(){
        int a = 100;
        int b = 0;
        if(b == 0){
            throw new ArithmeticException("除0异常....");
        }
        return a / b;
    }

throw 显式抛出异常对象

/*
    what:
        throw 显式 抛出给主函数
     */
    public static double exceptionThrowDispose2() throws ArithmeticException{
        int a = 100;
        int b = 0;
        if(b == 0){
            throw new ArithmeticException("除0异常....");
        }
        return a / b;
    }

arithmeticException() 函数对象构造函数

fact2: 编译异常

处理：

try {
            exceptionThrowDispose3();
        }catch(Exception e) {
            System.out.println("编译异常处理。。。。。");
        }

public static void exceptionThrowDispose3() throws Exception{
        int a = 100;
        if(a == 100){
            throw new ParseException("解析错误", 1);
        }
    }

编译异常2：

what：

如果不抛出/处理转化错误抛出异常就会出现编译异常

public static void exceptionThrowDispose4()  {
    String str = "2020---10112-051";
    /*
    what:
        设置简单数据格式的格式
     */
    SimpleDateFormat  sdf = new SimpleDateFormat("yyyy-MM-dd");
    //转化成parse对象
    /*
    why:
        有时候字符串无法与parse格式对应 会抛出异常
        如果你不考虑这种异常那么就会编译异常
     */
    sdf.parse(str);
}

四、finally关键字

public class finallyKeyWord {


    public static void main(String[] args) {



//        finallyShow3();
        System.out.println(returnFinallyCombine());
    }


    /*
    finally
        what:
            配合try catch  一般用于资源释放 只要进入try(除非exit退出 但是return后还是会执行finally)那么一定会执行finally
         how show:
            try 分别进入/不进入catch finally
         */
    public static void finallyShow1(){
        int a = 100;
        int b = 10;

        try{
            if( a == 100){
                System.out.println("进入try....");
            }
        }catch(Exception e){
            System.out.println("进入catch....");
            e.printStackTrace();
        }finally{
            System.out.println("finally....");
        }
    }
    public static void finallyShow2(){
        int a = 100;
        int b = 0;

        try{
            System.out.println(a / b);
        }catch(Exception e){
            System.out.println("进入catch....");

        }finally{
            System.out.println("finally....");
        }
    }
    /*
    what:
        try中exit finall不再执行
         return 退出  finally依旧执行 甚至进入catch return 优先级就这么低吗？
     */
    public static void finallyShow3(){
        int a = 100;
        int b = 0;

        try{
            System.out.println(a / b);
//            return;
            System.exit(1);
        }catch(Exception e){
            System.out.println("进入catch....");

        }finally{
            System.out.println("finally....");
        }
    }
    /*
    what:
        面试题try中 return返回值在try 与 finally中
        answer： return后 返回值藏在一个地方保存下来 finally操作x不影响保存的值
            如果try与finally同时return  try先修改局部值 finally 再次修改局部值 最后按照finally确定返回值
     */
    public static int returnFinallyCombine(){
        int x = 1;
        try{
            x++;
            return x;

        }catch(Exception e){
            System.out.println("进入catch...");
        }finally{
            ++x;
            System.out.println(x);
//            return x;
        }
        return x;
    }
}

面试题2：

final finally finalize三者区别

final: 修饰类能被继承修饰方法不能被重写修饰变量变常量
finally是try catch 一部分只要进入try 就会进入finally return 无法中断finally执行
finalize：object中的方法，在垃圾回收的时候会用的方法

五、自定义异常

1.继承于父亲接收父亲的全部操作属性

故可以设置message 当作异常抛出

public class defineException {

    public static void main(String[] args) {

        /*
        what:
            处理分数异常
         */
        try{
            System.out.println(getSorce());
        }catch(sorceException e){
            e.printStackTrace();
        }

        System.out.println("********");
    }

    /*
    what：
        返回分数
     */
    public static double getSorce() throws sorceException{
        double sorce = 999;
        /*
        分数不合法
         */
        if(sorce < 0 || sorce > 100){
            throw new sorceException("分数不合法");
        }

        return sorce;
    }

}
/*
what：
    自定义异常类之分数异常类 继承exception异常
how extend：
    无参 有参构造
    继承了exception所有属性可以抛出 可以有异常信息
 */

class sorceException extends Exception{
    /*
    what:
        无参构造
     */
    sorceException(){}
    /*
    what:
        携带信息构造 放入栈中
     */
    sorceException(String message){
        super(message);

    }
}
``
 throws sorceException{
        double sorce = 999;
        /*
        分数不合法
         */
        if(sorce < 0 || sorce > 100){
            throw new sorceException("分数不合法");
        }

        return sorce;
    }

}
/*
what：
    自定义异常类之分数异常类 继承exception异常
how extend：
    无参 有参构造
    继承了exception所有属性可以抛出 可以有异常信息
 */

class sorceException extends Exception{
    /*
    what:
        无参构造
     */
    sorceException(){}
    /*
    what:
        携带信息构造 放入栈中
     */
    sorceException(String message){
        super(message);

    }
}