Java新手入门/基础之异常Exception

异常

1.异常的概念：

• 广义：一切不正常情况
• 狭义：程序在运行时，出现的不正常情况，经过异常处理机制 后，程序可以继续向下运行。

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

• **Error：**Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。
• **Exception：**其它因编程错误或偶然的外在因素导致的一般性问题，可以使用正对性的代码进行处理。

2.常见的五个异常：

1)数组索引异常:ArrayIndexOutOfBoundsException

   int[] arr = new int[7];
   arr[7]=3;//索引为负数或大于或等于数组的大小

2)空指针异常NullPointerException

当应用程序尝试在需要对象的情况下使用null时抛出。

这些包括：

①调用一个null对象的实例方法.

②访问或修改null对象的字段.

③取null的长度，好像是一个数组.

④ 访问或修改的时隙null就好像它是一个数组.

⑤投掷null好像是一个Throwable价值.

String s =null;
s.length();

3)类型转换异常ClassCastException:抛出表示代码尝试将对象转换为不属于实例的子类.

Object obj = "abc";
Integer i =(Integer)obj;

4)数字格式化异常java.lang.NumberFormatException

new Integer("abc")

5)算数异常 java.lang.ArithmeticException:

int a = 10;
        int b = 0;
        System.out.println(a/b);// 异常by zero

        //异常处理机制,有的异常不强制处理,有的需要强制处理
        /*try {
            String e = "utf-8";
            byte [] b =  "abc".getBytes(e);
        } catch (UnsupportedEncodingException e) {
            System.out.println("编码不对");
        }*/

         System.out.println("剩余的代码");

3.异常的体系

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

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

异常分为:运行期异常和编译期异常。

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

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

4.异常的处理

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

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

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块中可以再放try-catch组合块，也可以只放try块，把catch块放到自己的catch块后。
*/
	try{           
           int[] c = {1,2,3};
           c[3] = 4;//数组索引越界
          /* try{
               String s = null;
               s.length();
           }catch(NullPointerException n){
               System.out.println("空指针异常");
           }*/

           int a = 10;
           int b = 0;
           System.out.println(a/b);//除数不能为0
           System.out.println("aaaaaaaaaaaaaaa");//上一步异常 因此不执行
       }catch(ArithmeticException a ){
           System.out.println("算数异常");//异常的处理
       }catch (ArrayIndexOutOfBoundsException a){
           System.out.println("数组索引越界");
       }catch (Exception e){
           System.out.println("存在异常，请处理！");
       }
     //try块中可以跟多个catch块，且这些catch块中catch后的要捕获的异常类型中，要按照从小到大的顺序，即从子类到父类的顺序写，否则会编译错误。
       
        System.out.println("hello world!");//由于异常被catch块捕获，因此该语句会执行

格式二:

/*
  try{
      可能会发生异常的代码
  }catch(异常类型（只捕获指定异常的类型） 引用名){
      异常的处理的代码
  }finally{//无论是否发生异常，finally块中的代码都会执行
      必须执行的代码
  }
*/
try{
    int[] c = {1,2,3};
    c[3] = 4;//数组索引越界
    System.out.println("aaaaaaaaaaaaaaa");//上一步异常 因此不执行;
}catch (Exception e){
   System.out.println("存在异常，请处理！");//处理1：对用户进行提示
}finally {  //无论是否发生异常，finally块中的代码都会执行
    System.out.println("hello world");
}

格式三

/*
try{
      可能会发生异常的代码
  }finally{//无论是否发生异常，finally块中的代码都会执行
      必须执行的代码
  }
注：catch语句必须紧跟着try语句之后，且一个try后面可以写多个catch
try+finally组合,若try块中没有异常处理,try一旦出现问题,会先执行fianlly类,后程序终止
*/
try{
     int[] c = {1,2,3};
     c[3] = 4;//数组索引越界
     System.out.println("aaaaaaaaaaaaaaa");//上一步异常 因此不执行;
}finally {  
    //try + finally组合，此处没有异常处理，try块中一旦出现异常，执行finally块，程序终止
    System.out.println("hello world");
}

finally与catch执行顺序

1.当catch中没有return语句时,执行顺序为try-catch-finally

2.当catch中有return语句而finally没有return语句,执行try代码块-执行catch中return之前的代码-finally中的代码块-最后执行catch中的return

3.当catch和finally中都用return语句,时执行顺序为try-catch-finally,但最后finally中的return语句会覆盖catch中的return语句,返回的是finally中的return语句.

throw-throws关键字

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

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

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

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

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

自定义异常

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

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

public class ExceptionDemo8 {
    public static void main(String[] args) {
        ExceptionDemo8 d8 =new ExceptionDemo8();
         //使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch,要么继续使用throws声明。
        try {
            d8.checkScore(101);
        } catch (ScoreException e) {
            e.getMessage();
            System.out.println(e.getMessage());
            e.printStackTrace();
        }

    }
/*
    throws, 定义一个方法的时候，可以使用throws关键字声明方法中可能会出现的异常，可以同时声明多个可能会出现的异常
            表示此方法不处理异常，交给方法调用处处理异常
            一般多为编译期异常（检查异常）
*/
    public String checkScore(int score) throws ScoreException{
        if(score<0 ||score>100){
        //ScoreException 为自定义的异常类    
        throw new ScoreException("成绩不合法");//当不满足某种条件时，在方法中显式的抛出一个异常对象，程序终止
        //System.out.println();//delete unreachable statement
        }
        if(score>=90){
            return "优秀";
        }else {
            return "不优秀";
        }
    }
}

怎么样?你学会了吗?学会了点个赞❥(^_-)