异常简单理解1

异常

1.了解异常

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

2.广义:一切不正常的情况

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

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

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

2.常见异常

        //1.数组索引越界 ArrayIndexOutOfBoundsException
        int []a=new int[5];
        a[5]=10;

        //2.空指针异常 NullPointerException
        String s=null;
        s.getBytes();

        //3.类型转换异常 ClassCastException
        Object obj="abc";
        Integer i=(Integer)obj;

        //4.数字格式化异常 NumberFormatException
        new Integer("abc");

        //5.除数不能为0(算数异常) ArithmeticException
        int c=10;
        System.out.println(c/0);

3.异常分类

通过API查询我们了解到java.lang.Throwable类有两个直接子类，Exception类、Error类。Error表示错误，可能是编译期错误或者系统错误，往往程序中并不处理。Exception表示异常，是所有异常类的父类。

• Throwable类是Java语言中所有错误和异常的Throwable类。

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

• 运行期异常：程序运行时抛出的异常，所有RuntimeException的子类（直接或间接继承RuntimeException）都是运行期异常，在编译期间不强制要求处理。

• 编译期异常：除去运行期的异常都是编译期异常，也称为检测/检查异常，直接或间接继承Exception，与RuntimeException没有关系，在编译期间需要强制处理。

4.异常处理

java异常处理是通过5个关键字来实现的:try,catch, finally,throw,throws

1.try-catch-finally

**try：**try是检测不安全的代码块。即try块中放的是可能会发生异常的代码。try中的任何一条语句发生了try中的任何一条语句发生了异常，下面的代码都将不会执行，程序将跳转到异常处理代码块中，即catch块。

**catch：**捕获try块中出现的类型匹配的异常，保证程序能继续运行下去。catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数。一个try后面可以写多个catch，分别捕获不同类型的异常，这些catch后的要捕获的异常类型中，要按照从小到大的顺序，即从子类到父类的顺序写，否则会编译错误。

catch中提供方法捕获异常的有关信息：与其他对象一样，可以访问一个异常对象的成员变量或调用它的方法。

• getMessage() 获取异常信息，返回字符串
• printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。

**finally：**无论是否发生异常，finally块中的代码都会执行，且只能一个finally语句。

//格式一
try{
	    可能会发生异常的代码
    }catch(异常类型 引用名){
	      异常处理代码
    }
//格式二
try{
      可能会发生异常的代码
  }catch(异常类型（只捕获指定异常的类型） 引用名){
      异常的处理的代码
  }finally{//无论是否发生异常，finally块中的代码都会执行
      必须执行的代码
  }
//格式三
 try{
      可能会发生异常的代码
  }finally{//无论是否发生异常，finally块中的代码都会执行
      必须执行的代码
  }
  
//注：catch语句必须紧跟着try语句之后，且一个try后面可以写多个catch。若不知道异常类型 可直接在catch中写 (Exception e)

下面通过几个示例处理异常:

public class DealExceptionDemo {
    public static void main(String[] args) throws FileNotFoundException {
        try{
            int []a=new int[5];
            a[5]=0;

            String s=null;
            s.length();

            /*Object obj="abc";
            Integer c=(Integer)obj;*/
        /*
         将可能发生异常的代码放在一个try中,
         后面可以跟多个catch处理不同代码的异常
         若不知道异常类型,可写catch(Exception e)
         一次处理所有异常
         */
        }catch(ArrayIndexOutOfBoundsException a){
            System.out.println(a.getMessage());
            a.printStackTrace();
            System.out.println("数组越界");
        }catch(NullPointerException n){
            System.out.println("空指针异常");
        }catch(Exception e){//不知道异常类型时使用
            PrintWriter s=new PrintWriter("E:\\Exception.text");
            System.out.println("就异常了");
        }
    }
}

示例二:

package javaexception;

public class DealExceptionDemo2 {
    public static void main(String[] args) {

        DealExceptionDemo2 d=new DealExceptionDemo2();
        System.out.println(d.test(10,0));
    }
    public int test(int a,int b){
        try{
            return a/b;
        }catch(Exception e){
            return -1;
        }finally{
            System.out.println("asd");
            //在出现异常时 先输出finally内的数据 在执行catch的return -1
        }
    }

2.throws和throw

throw：throw关键字用于显示**抛出异常，**抛出的时候是抛出的是一个异常类的实例化对象。在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。

throws：定义一个方法的时候，可以使用throws关键字声明方法中可能会出现的异常(可以同时声明多个可能会出现的异常) 表示此方法不处理异常，交给方法调用处处理异常， 一般多为编译期异常（检查异常）。

• 任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
• 子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常（针对编译期异常）。
• 使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明

package javaexception;

import java.io.FileNotFoundException;
import java.io.UnsupportedEncodingException;

public class ThrowsDemo {
    public static void main(String[] args) {
        ThrowsDemo t=new ThrowsDemo();
        try{
            t.method1();
        }catch (UnsupportedEncodingException u){
            u.printStackTrace();
        }catch (FileNotFoundException f){
            f.printStackTrace();
        }
    }
    public void method1() throws UnsupportedEncodingException,FileNotFoundException,ArithmeticException{
        method2();
    }
    /*
    throws 抛出 定义一个方法的时候可以使用,表明此方法不处理异常
    而是交给方法调用处进行处理
     */
    public void method2()throws UnsupportedEncodingException, FileNotFoundException,ArithmeticException {
        "abc".getBytes("utf-8");
    }
}

自定义异常

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

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

package javaexception;

public class ThrowDemo {
    public static void main(String[] args) {
        ThrowDemo t=new ThrowDemo();
        try {
            t.checkScore(101);
        } catch (ScoreException e) {
//            e.getMessage();
            System.out.println(e.getMessage());
//            e.printStackTrace();
        }

    }

    public String checkScore(int score) throws ScoreException{
        if(score<0 ||score>100){
            throw new ScoreException("成绩不合法");
            //当不满足某种条件时，在方法中显式的抛出一个异常对象，程序终止
        }
        if(score>=90){
            return "优秀";
        }else {
            return "不优秀";
        }
    }

}

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

package javaexception;

public class ScoreException extends Exception {
    public ScoreException(){
        super();
    }
    public ScoreException(String message){
        super(message);
    }
}

创作不易，大佬们留步… 动起可爱的双手，来个赞再走呗 (๑◕ܫ￩๑)