java异常

异常

广义: 一切不正常情况

错误:程序运行时的,但是不是程序能够处理的,例如 虚拟机内存不够用.

狭义异常:程序在运行时出现的不正常情况,经过异常处理机制后,程序可以继续向下执行.

package com.ff.javaException;

import java.io.UnsupportedEncodingException;

public class Demo1 {
    /*
    异常
    广义 一切不正常的情况
    狭义:程序在运行时出现的不正常的情况 经过异常处理机制后 程序可以继续向下执行

    错误:程序运行时的 但是 不是程序自身可以处理的
     */

    public static void main(String[] args) {
        //1.数组越界异常 ArrayIndexOutOfBoundsException
//        int []a=new int[5];
//        a[5]=10;

        //2.空指针异常 NullPointerException
//        String s=null;
//        String a=new String(s);
//        System.out.println(a);
        //3. 类型转换异常 ClassCastException
//        Object o="abc";
//        Integer i= (Integer) o;
       //4.算数异常 ArithmeticException
//        int a=10;
//        int b=0;
//        int c=a/b;
        //5.数字格式化异常 NumberFormatException
       // Integer a=new Integer("1a1");
        //异常处理机制  有的异常不强制处理  有的需要强制处理

        try {
            String a="utf-800";
            byte[]b="abc".getBytes(a);
        } catch (UnsupportedEncodingException e) {
            System.out.println("编码错误");
        }
        System.out.println("后面的代码");
    }
}

异常的体系

Throwable有两个直接子类Exception类、Error类

​ Exception 异常 重点

​ 运行时异常:

​ 直接或者间接继承RuntimeException

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

​ 编译时(检查)异常:

​ 直接或间接继承Exception,与RuntimeException没有关系

​ 在编译期间强制要求处理,否则不能编译.

异常处理

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

try

检测不安全的代码块
try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将跳转到catch块。

因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。

catch

把抓到的类型匹配的异常捕获，保证程序能继续运行下去
catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，

一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误

public class Demo2 {
      /*
        异常处理
        try{
            可能会出现异常的代码
        }catch(异常类型 只会捕获指定类型的异常){
             处理异常的代码
        }

      */
      public static void main(String[] args) {
          try {
//              int a[] = {1, 2, 3};
//              a[3] = 0;

              String s = null;
              s.length();

              int b=10;
              int c=0;
              int d=b/c;
              System.out.println(d);
          }
          catch (ArrayIndexOutOfBoundsException n){
              System.out.println("越界异常");
          }
          catch (ArithmeticException a){
              System.out.println("算数异常");
          }
          catch (NullPointerException m){
              System.out.println("对象为空");
          }
          catch (Exception e){
              System.out.println("程序忙 请稍后再试");
          }
          System.out.println("后面的代码");
      }
}

getMessage()

获取异常信息，返回字符串

printStackTrace()

获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

 public static void main(String[] args) {
        try {
            int a[] = {1, 2, 3,4};
            a[4] = 0;


        }
        catch (Exception e){
            System.out.println(e.getMessage());//打印输出异常的消息 不太明显 记录日志 异常信息写在文件中
            e.printStackTrace();//将异常的信息打印到控制台
            System.out.println("程序忙 请稍后再试");
        }
        System.out.println("后面的代码");
    }

finally

finally该内容总是会执行的，只能有一个finally语句
finally{
必须执行的逻辑
}

 public static void main(String[] args) {
        try {
            int a[] = {1, 2, 3,4};
            a[4] = 0;

        }
        /*
        finally 无论是否发生异常 finally代码块都会执行
        不能单独使用finally
        只能通过try 代码块 +catch代码块+finally代码块
        要么 try代码块 +finally代码块 如果try代码块代码出现异常 只会执行finally代码块中的代码 程序终止
         */
        finally {
            System.out.println("xxxxx");
        }
        System.out.println("后面的代码");
    }

try代码块+catch代码块+finally代码块的好处

 public static void main(String[] args) {
      Demo5 d=new Demo5();
        System.out.println(d.test(10,2));
    }
    /*
    try代码块+catch代码块+finally代码块
    如果 try catch 都有return 即使出现异常 也会执行finally中的代码
    而且运行结果是先输出finally后输出return的结果
     */
    public int test(int a,int b){
        try{
            return a/b;
        }
        catch (Exception e){
            return -1;
        }
        finally {
            System.out.println("xxxx");
        }

    }

throws

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

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

子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常

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

/*
 throws作为方法声明 表示此方法不处理异常  谁调用这个方法谁处理异常 main方法不能throws;
 */
public class Demo6 {
    public static void main(String[] args) {
        Demo6 d=new Demo6();
        try {
            d.method1();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
    public  void method1() throws UnsupportedEncodingException {
        method2();
    }
   //声明此方法可能会出现异常 可以声明多个 一般为编译期异常
    public  void method2() throws UnsupportedEncodingException {
       "".getBytes("utf-8");
    }
}

throw

用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象.
在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。

public static void someMethod() {
if (条件) {
    throw new RuntimeException("错误原因");
}
}

自定义异常

就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类
作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆

 public static  void main(String[] args) {
        Demo8 d=new Demo8();
        try {
            d.testScore(101);
        } catch (ScoreException e) {
          e.getMessage();
            e.printStackTrace();
        }
    }
    public String testScore(int score) throws ScoreException {
        if (score>100||score<0){
            throw  new ScoreException("成绩不合法");//自定义异常
        }
        else if (score>70){
            return "优秀";
        }
        else {
            return "不优秀";
        }

    }
}