Throwable是Error和Exception的父类,在开发中只关注Exception

Exception可分为编译期异常(受检异常)和运行期异常(非受检异常)

异常会导致程序中断,无法继续执行。处理异常可以让程序保持运行状态

在开发中常把 try 将可能出现异常的代码块包裹起来。使用 catch 捕捉异常,catch可以有多个,异常子类放前面,异常父类放后面。

 

异常处理过程分析:

  (1)一旦产生异常,则系统会自动生成一个异常类的实例化对象

  (2)如果异常发生在try语句块内,系统会自动寻找匹配的catch代码块执行。若异常产生之后没有异常处理语句,则程序就会退出,并报告异常错误

 

 

代码示例:

public class TestException {
    public static void main(String[] args) {
        
        /*
         * 值得注意的是:在try代码块中,若某行代码发生异常,那么程序立即跳转至处理异常的代码块(比如catch代码块)
         * 发生异常所在行后面的代码将无法正常执行
         * finally代码块无论是否发生异常,都会执行
         */
        try {
            int a=6;
            int b=2;
            int c= a/b;
            int [] arr = {1,2,3,4};
            System.out.println(arr.length);
            System.out.println(arr[3]);
            arr = null;
            System.out.println(arr[3]);
        }
        catch(ArithmeticException e) {
            System.out.println("发生算数异常");
        }
        catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("发生数组越界异常");
        }
        catch(NullPointerException e) {
            System.out.println("发生空指针异常");
        }
        catch(Exception e) {
       e.printStackTrace(); System.out.println(
"程序发生异常"); } finally { System.out.println("程序运行完毕"); } } }

 

throw与throws关键字(抛出异常,并不是处理异常)

  (1)throws关键字用在方法的声明表示方法中并不处理异常,而交给调用方法处进行处理。对于Java程序而言,如果没有加入任何的异常处理,发生的异常则由JVM处理(不处理,显示报错)

  (2)throw表示在方法中手动抛出一个异常。从异常处理的机制来看,所有的异常一经产生,系统实际上抛出的是一个异常类的实例化对象,那么此对象也可以由throw直接抛出

public class TestThrows {

    public static void main(String[] args) {
        try{
            divide(6,0);
        }
        catch(ArithmeticException e) {
            System.out.println("发生了算术异常");
        }
    }
    
    //throws和throw 常搭配使用
    public static int divide(int a,int b) throws ArithmeticException{
        
        try{
            int c = a/b;
            return c;
        }
        catch(ArithmeticException e) {
            throw new ArithmeticException("发生了算术异常");
        }        
    }
}

 

 自定义异常

  自定义异常通常是继承一个异常类(Throwable、Exception、RuntimeException)来实现。

  自定义异常,使用提供构造方法来实现。

  异常对象本身没有实际功能,仅是一个具有特殊意义的标识

 

public class TestMyexception2 {
    public static void main(String[] args) {
        UserService1 us1 = new UserService1();
        try {
            us1.login("", "");
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

//自定义异常,继承异常类
class MyException extends Exception{
    
    public MyException() {
        super();
    }
    
    public MyException(String message) {
        super(message);
    }
}

class UserService1{
    public User login(String username,String password) throws MyException{
        
        if(!"admin".equals(username)) {
            throw new MyException("用户名错误");
        }
        if(!"123".equals(password)) {
            throw new MyException("密码错误");
        }
        return new User(username,password,18);
    }
}


class User{
    private String username;
    private String password;
    private int age;
    public User() {
        super();
    }
    public User(String username, String password, int age) {
        super();
        this.username = username;
        this.password = password;
        this.age = age;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
        
}

 

受检异常:Exception

  在定义方法时,必须声明出所有可能抛出的Exception;

  调用该方法时,必须捕获它的checked exception,不然就得把exception传递下去

  exception是从 java.lang.Exception中衍生出来的。例如:IOException 、SQLException等等

 

非受检异常:RuntimeException

  在定义方法时不需要声明会抛出runtime exception;

  在调用这个方法时不需要捕获这个runtime exception;

  runtime exception是从 java.lang.RuntimeException 或 java.lang.Error中衍生出来的。例如:NullPointerException 、ArrayIndexOutOfBoundsException等等