JavaSE---异常

异常

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

Java程序在执行过程中所发生的异常(运行时一切不正常情况)事件可分为两类：

Error: Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

java.lang.StackOverflowError //程序运行时出现错误，例如内存不够用

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：

访问数组下标越界

int [] a = new int[5];//ArrayIndexOutOfBoundsException
a[5]=10;

空指针异常

String s = null;//NullPointException
s.length();

类型转换异常

Object obj = "abc";//java.lang.ClassCastException
Integer i = (Integer)obj;

数字格式化异常

new Integer("abc");//java.lang.NumberFormatException

算数异常

int a = 10;
int b = 0;
System.out.println(a/b);//java.lang.ArithmeticException:/by zero

对于这些异常，一般有两种解决方法：一是遇到异常就终止程序的运行。

另一种方法是由程序员在编写程序时，就考虑到异常的检测、异常消息的提示，以及异常的处理。

捕获异常最理想的是在编译期间，但有的异常只有在运行时才会发生。比如：除数为0，数组下标越界等

分类：编译时(检查)异常和运行时异常

异常的体系

Throwable类有两个直接子类：Exception类、Error类。Error表示错误，可能是编译期错误或者系统错误，往往

程序中并不处理。Exception表示异常，是所有异常类的父类，是程序员所关心的。

异常分为运行期异常和编译期异常两种

运行期异常：

直接或间接继承RuntimeException，程序运行时抛除的异常，所有RuntimeException的子类都是运行期异常

在编译期间不不强制要求处理

数学异常

空指针异常

数组下标越界

……

**编译期异常(**Checked Exception)：

直接或间接继承Exception，除去运行期的异常都是编译期异常，也称为检测异常

在编译期间强制要求处理，否则不能运行

IOException

SQLException

……

异常处理

java编程语言使用异常处理机制为程序提供了异常处理的能力

程序中预先设置好对付异常的处理办法 ---->程序运行---->异常---->对异常进行处理---->处理完毕，程序继续运行

Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws

try-catch

基本语法
try{
可能会发生异常的代码
}catch(异常类型 引用名){
异常处理代码
}finally{
必须执行代码
}

try:
检测不安全的代码块（发现异常）
try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。

catch:
把抓到的类型匹配的异常捕获，保证程序能继续运行下去
catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误

public static void main(String[] args) {
        /*
        异常处理
        try{
            可能会出现异常的代码
            }catch(异常的类型,只捕获指定类型的异常){

            }
         */
        try{

            int[] c = {1,2,3};
            c[3] = 0;

            String s = null;
            s.length();

            /* try {
                 String s = null;
                 s.length();
             }catch (NullPointerException n){

             }*/

            int a=10;
            int b=2;
            System.out.println(a/b);

            System.out.println("aaaaaaaaaaaaaaa");
        }catch(ArithmeticException a){
            System.out.println("算数异常");//异常的处理
        }catch (NullPointerException n){
            System.out.println("对象为空");
        }catch (Exception e){
            System.out.println("程序忙,请稍后再试!");
        }

        System.out.println("后面的代码");
    }
}

捕获异常的有关信息：
与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。
getMessage() 获取异常信息，返回字符串
printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

public static void main(String[] args) throws FileNotFoundException {
      try{

        int[] c = {1,2,3};
        c[3] = 0;
          System.out.println("aaaaaaaaaaaaaaa");
      }catch (Exception e){
          //处理2：打印输出异常信息，记录日志：异常信息写在文件
          System.out.println(e.getMessage());
          e.printStackTrace();//打印异常信息到控制台，通过一些日志组件
          PrintWriter p = new PrintWriter("C:\\Users\\25919\\Desktop\\log.txt");
          e.printStackTrace(p);
          p.flush();
          p.close();
          System.out.println("程序忙,请稍后再试!");//处理1：用户进行提示
      }

        System.out.println("后面的代码");
    }
}

finally

finally：

无论是否出现异常，该内容总是会执行的，只能有一个finally语句
finally{
必须执行的逻辑
}

 public static void main(String[] args) {
         /*
        异常处理
        try{
            可能会出现异常的代码
            }catch(异常的类型,只捕获指定类型的异常){
            处理异常的代码
            }finally{
            无论是否出现异常，finally块中的代码都会执行
            }

            try{

            }finally{
                    try+finally,此处没有异常处理，如果try中出现问题，执行finally，程序终止
            }
         */
       /* try{
            System.out.println(10/0);
            System.out.println("aaaaaaaaaaaaaaa");

        }catch (Exception e){
            System.out.println("程序忙,请稍后再试!");

        }finally {
            System.out.println("xxxxxx");
        }*/
       Demo4 d4 = new Demo4();
        System.out.println(d4.test(10,0));
    }

    public int test(int a,int b){
        try {
            return a/b;
        }catch (Exception e){
            return -1;
        }finally {    //即使try,catch中出现异常,也有return,也会先执行finally中的代码
            System.out.println("xxxxxxxxxxxx");
        }

throws

throws,定义一个方法的时候可以使用throws关键字声明,表示此方法不处理异常，而交给方法调用处进行处理。

例如:

​ public void test throws 异常1，异常2，异常3{

​ }

任何方法都可以使用throws关键字声明异常类型，包括抽象方法。

子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常(针对编译期异常)。

public abstract class Demo6 {
    public abstract void test()throws UnsupportedEncodingException;
}
public class Demo6Test extends Demo6{
    /*
    在子类中重写父类方法，声明异常类型小于等于父类异常类型
     */

    @Override
    public void test() throws UnsupportedEncodingException {

    }
}

使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明。

port java.io.UnsupportedEncodingException;
public class Demo5 {
    /*
    throws:作为方法的声明，声明此方法中可能会出现某种异常，调用时，就需要注意了
     */


    public static void main(String[] args) {//main方法里不用抛出异常，用try-catch
        Demo5 d5 = new Demo5();
        try {
            d5.m1();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }catch (FileNotFoundException e){
            e.printStackTrace();

        }

    }

    public void  m1() throws UnsupportedEncodingException, FileNotFoundException {
        this.m2();
    }
    //声明此方法可能会出现异常,可以声明多个,一般多为编译期(检查异常)异常
    public void  m2() throws UnsupportedEncodingException , FileNotFoundException,ArithmeticException {
            "abc".getBytes("utf-8");
    }
}

throw

throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象.

在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。

语法：throw throw new 异常类构造方法

如： throw new RunTimeException()

 public static void main(String[] args) {
        Demo7 d7 = new Demo7();
        try {
            d7.checkScore(101);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public String checkScore(int score)throws Exception{
        if(score<0||score>100){
            throw new RuntimeException();//当不满足某种条件时，在方法中显示的抛出一个异常对象 ,程序终止
        }
        if(score>=90){
            return "优秀";
        }else{
            return "不优秀";
        }
    }

throw和throws

throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，要么使用try catch捕获异常，要么使用

throws声明异常

throws用于方法声明处，用来声明该方法可能发生的异常类型，可以是多个异常类型，用来强制调用该方法时处

理这些异常

抽象方法也可以使用throws

自定义异常

自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类

作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆

自定义异常类

基本语法

public class 异常类名 extends Exception/RuntimeException{

​ public 异常类名(String msg){

​ super(msg);

​ }

}

自定义异常类中往往不写其他方法，只重载需要使用的构造方法

继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或throws抛出

public class Demo7 {
    public static void main(String[] args) {
        Demo7 d7 = new Demo7();
        try {
            d7.checkScore(101);
        } catch (Exception e) {
            e.getMessage();
            e.printStackTrace();
        }
    }
    public String checkScore(int score)throws Exception{
        if(score<0||score>100){
            throw new Demo8("成绩不合法");//当不满足某种条件时，在方法中显示的抛出一个异常对象 ,程序终止
        }
        if(score>=90){
            return "优秀";
        }else{
            return "不优秀";
        }
    }
}

public class Demo8 extends Exception {
    /*
    自定义异常
    成绩不合法时抛出此异常对象
     */
    
    public Demo8(){
        super();
    }

    public Demo8(String message) {
        super(message);
    }

    public static void main(String[] args) {

    }
}