java异常

Java异常

异常的概念

• 异常通常可以分为广义的异常与狭义的异常。

• 从广义上来说，程序中的任何不正常都可以称为异常。

• 从狭义上来说，程序在运行时出现的不正常情况，可以使用异常处理机制处理。

异常的体系

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

为两类（Throwable为异常体系中的超类）：

1.Error错误，程序无法处理→StackOverflowError栈溢出错误

一般在程序中不做处理，是编译期间的错误

2.Exception异常

①（直接继承Exception称为编译期异常）UnsupportedEncodingException

②Ioexception

③RuntimeException（运行期间异常，编写代码时可以不应处理）

⑴ArrayIndexOutOfBoundsException

⑵NullpointerException

运行期常见异常

1. 递归调用过多
2. 栈的内存不够
3. 数组越界异常
4. 算数异常
5. 类型转换异常
6. 空指针异常
7. 内存不够用，程序自身无法处理

部分异常代码实现

package com.ffyc.javaexception;

public class Demo1 {

    /*public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
               demo1.sum(10);
    }
    public int sum(int num){
        return num+sum(num-1);
    }*/

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

        /* 算术异常*/
        /*int a = 10;
        int b = 0;
        System.out.println(a/b);*/

        /*
          类型转换异常
         */
        /*Object obj = "abc";
        Integer i1 = (Integer) obj;
        System.out.println("aaaaaaaaaaa");*/

        /*
          空指针异常  使用的对象值为null关键字  NullPointerException
         */
        /*String  s = null;
                  s.length();*/
    }


}

异常处理

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

try-catch处理机制

基本语法

try{

​ 可能会发生异常的代码

}catch(异常类型 引用名){

​ 异常处理代码 提示 做其他操作

}

try-catch-finally

在发生异常后，finally关键字提供给了程序最后一次说明机会，可以再finally中进行程序的异常说明

try-catch-finally代码实现

package lessonAPI.ExceptionDemo;

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


//        System.out.println(Test());
//        try {
//            int a = 10;
//            int b = 1;
//            int c = a/b;
//            System.out.println(c);
//            int  [] d=new int[5];
//            int e = d[6];
//        }catch (ArithmeticException x){
//            System.out.println("除数为0");
//        }catch (ArrayIndexOutOfBoundsException Arr){
//            System.out.println("yuejie");
//        }
/
       /* try { // try catch
            String s = null;
            System.out.println(s.length());
        }finally {
            System.out.println("chucuole");
        }*/
//
        try {
            int d [] = {1,2,3,4};
            String s = "qwe";


            System.out.println(s.charAt(4));
        }catch (Exception n){
            System.out.println("qwe");
        }finally {
            System.out.println("执行final");
        }
//
//    }
//    public static int Test(){
//        try {
//            int a=5;
//            int b=0;
//            System.out.println(a/b);
//            return 1;
//
//        }catch (ArithmeticException A){
//            System.out.println(1);
//
//return 0;
//        }
//
    }
//
}

一般情况下，当有多个catch时，父类类型的异常需要放在代码最下方

throw与throws

这两个关键字虽然差别不大，但具体用法有所差别

throws：声明在此方法中可能会出现某种异常，表示不处理异常抛出

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

么继续使用throws声明。

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

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

译期异常)。

throws +UnsupportedEncodingException（编译器异常）提示方法调用的地方在编译期要做出处理

偏底层的方法，一般不会try-catch，继续声明此方法可能会出现异常，作为方法的声明（定义），继续上抛，在最顶层进行try-catch

package lessonAPI.ExceptionDemo;

import java.io.UnsupportedEncodingException;

//public class ThrowsDemo {
//    public static void main(String[] args) {
//        try {
//            ThrowsDemo.test2();
//        } catch (UnsupportedEncodingException e) {
//            System.out.println("德玛西亚!");
//        }
//    }
//    public static  void test1() throws UnsupportedEncodingException {
//        String s = "ads";
//
//        System.out.println(s.getBytes("utf-81"));
//    }
//    public static void test2() throws UnsupportedEncodingException {
//        ThrowsDemo.test1();
//    }
//}

throw：在方法中显示抛出一个异常的对象，表示此处实际发生异常，new+有参构造方法（描述异常原因）

throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，

要么使用try catch捕获异常，要么使用throws声明异常 throws+NullPointerException（运行期异常）在编译期间不提醒

package lessonAPI.ExceptionDemo;

public class ThrowDemo {
    public static void main(String[] args) {
        try {
            System.out.println(Test(10));
        }catch (Exception exception){
            exception.PrintStackTrace();//在开发期间调试代码使用，在控制台打印出异常详细信息	
            System.out.println(exception.getMessage());

        }
    }
    public static String Test(int t) throws UnsupportedOperationException{
        if(t<0||t>100){
            throw new UnsupportedOperationException("能不能看清楚再输入？");

        }
        else if (t>90&&t<=100)return "a";
        else if (t<90&&t>=0)return "b";
        return "";
    }

}

自定义异常

根据实际业务来定义某一种情况的异常表示一种业务的需求

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

package lessonAPI.ExceptionDemo;

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

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