java 异常处理

• 异常体系
• 常见异常
• 异常的处理自定义异
• 常类及使用常见的异常Exception：被0除，空指针，索引越界等等

异常的体系

Throwable(类-超类)

• Error（子类）

　　　　通常出现重大问题如：虚拟机崩溃或者内存溢出等
　　　　这些异常不用处理，也处理不了

• Exception （子类）

　　　　在运行时（编译+运行）出现的异常情况，可以通过

1. 1. try catch finally处理
   2. throw处理

　　Exception和Error的子类名都是以父类名作为后缀

                   

 异常处理方式之一：捕获：

1.try，catch，finally不能单独出现
2.try必须和catch或者finally配合使用（两者可以出现一个或者都有）
3.catch可以有多个，但是finally只能有一个
4.finally代码块只有一种情况不会被执行，就是在之前执行了System.exit(0)

 

由于捕获的异常都是Throwable类的子类对象，所以完全可以调用Throwable中定义的方法
getMessage()
获取异常信息，返回字符串。
toString()
获取异常类名和异常信息，返回字符串。
printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
printStackTrace(PrintStream s)
通常用该方法将异常内容保存在日志文件中

 

public class FinallyTest {
        public static void main(String[] args){
            int res = test();
            System.out.println("test方法的返回值是："+res);
        }    
        @SuppressWarnings("finally")
        public static int test(){
            try{
                System.out.println("进入test方法");
                int i = 10 / 0;
                return 1;
            }catch(Exception e){
                System.out.println("发生异常");
                return 2;
            }finally{
                System.out.println("finally里的语句");
                return 3;
            }
        }
    }

异常处理方式之二：声明抛出

 

 

自定义异常类：

自定义异常类：自定义类继承Exception或者其子类。
通过构造方法定义异常信息。

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

通过throw抛出自定义的异常对象
异常细节：

• RuntimeException以及其子类如果在方法中被throw抛出，可以不用在方法上声明
• 一个方法被重写时（子类与父类）

1. 重写方法可以不抛出任何异常(运行时和非运行时)
2. 重写方法可以抛出和父类方法相同的异常(常用)
3. 重写方法可以抛出比父类方法多的异常，但都必须是父类方法异常的子类
4. 编译期异常不能比父类多

　　总结重写方法是最好就是和父类保持一致

/*
    编写程序用于计算两个正数的加减乘除结果
自定义一个异常类：MyException,当输入的数含有负数的时候,抛出自定义异常对象,并捕获处理
*/

import java.util.Scanner;

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

public class ExceptionDemo4{
    public static void main(String[] args){
        try{
            test();
        }catch(MyException e){
            System.out.println(e.getMessage());
        }
        catch(ArithmeticException e){
            e.printStackTrace();
        }
        catch(Exception e){
            System.out.println("发生未知异常");
        }
    }
    
    //
    public static void test() throws MyException,ArithmeticException{
        Scanner s = new Scanner(System.in);
        System.out.print("输入第一个正数:");
        int a = s.nextInt();
        System.out.print("输入第二个正数:");
        int b = s.nextInt();

        if(a < 0 || b < 0){
            throw new MyException("你输入的数包含负数");
        }
        
        System.out.println("加法: " + (a + b));
        System.out.println("减法: " + (a - b));
        System.out.println("乘法: " + (a * b));
        System.out.println("除法: " + (a / b));//可能抛算术异常
    } 
    
}

异常细节：

 

主要考虑编译时期Javac报异常 ,运行时不trycatch最终还是会报异常

import java.sql.SQLException;
import java.sql.SQLClientInfoException;
import javax.sql.rowset.serial.SerialException;
import javax.xml.soap.SOAPException;

class Father{
    
    
    
    public void test() throws SQLException{
        System.out.println("father.test()..");
    }
}

class Son extends Father{
    //子类可以抛出比父类多的异常,都必须是父类异常的子类
    public void test() throws SQLException,SerialException,SQLClientInfoException{
        System.out.println("son.test()..");
    }
}



public class ExceptionDemo5{
    public static void main(String[] args){
        Father f = new Son();
        try{
            f.test();
        }
        catch(Exception e){
            
        }
        
    }
    
    //方法内不想处理的异常是运行时异常,可以省略声明抛出
    public static void test() throws SQLException{
        // int a = 2 / 0;
        throw new SQLException();
    }
    
    
}