java语言基础--异常

异常的分类

• 一般性异常：出现了这种异常必须在程序里面显示的处理，否则程序无法编译通过
• RuntimeException：此种异常可以不用显示的处理，例如被0除异常，java没有要求我们一定要处理。

JVM处理异常

• main方法自己将该问题处理,然后继续运行

  比如说：打印1/0，这是肯定错的，我可以通过if语句对其处理，如果除数不为零，就让它除，如果除数为零，就让它打印除数不能为零。这个样子。

• 自己没有针对的处理方式,只有交给调用main的jvm来处理，jvm有一个默认的异常处理机制。例如ArithmeticException，jvm在控制台里面打印出来了异常信息。

throws抛出异常

• 将异常抛出，并不是解决问题，而是，把问题交由调用该方法的去处理

try catch处理异常

来个栗子：

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Main {

    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("E:/dss.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            String msg = e.getMessage();
            System.out.println(msg);
        }
        System.out.println("try catch 的后面");
    }
}

注：这两个方法是最常用的

e.printStackTrace();
e.getMessage();

打印结果：

java.io.FileNotFoundException: E:\dss.txt (系统找不到指定的文件。)
    at java.io.FileInputStream.open0(Native Method)
    at java.io.FileInputStream.open(Unknown Source)
    at java.io.FileInputStream.<init>(Unknown Source)
    at java.io.FileInputStream.<init>(Unknown Source)
    at com.dss.main2.Main.main(Main.java:10)
E:\dss.txt (系统找不到指定的文件。)
try catch 的后面

可以catch子类，再catch父类，catch多个；

finally的使用

尤其在io中使用的较多用法是这样的

try{

}catch{

}finally{

}

注：try里面的变量在外面是无法访问的

来个栗子：

public class Main {

    public static void main(String[] args) {

        int result = num();
        System.out.println(result);
        
    }

    public static int num() {
        try {
            int i = 1;
            return i;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("finally中的语句");
        }
        return 10;
    }
}

运行结果：

finally中的语句
1

是不是赶脚着有点怪，先打印了finally中的语句。是这样的，finally这个咚咚有点怪，在执行try catch的时候，会先看一下后面有没有finally这个咚咚，如果有的话，就先执行finally中的内容。

如果要让finally的语句不执行，可以这样做，在try里面执行System.exit(0);这个语句，就可以让JVM停止运行。

final ，finally， finalize这三者的区别：

• final：final可以修饰类，不能被继承；修饰的方法不能被重写；修饰的变量只能赋值一次；
• finally：是try语句中的一个语句体，不能单独使用，语句体中的语句一定会执行；
• finalize：是Object中的一个方法，当没有引用指向这个对象时，有对象的垃圾回收器在回收之前调用此方法。

throw和throws的区别

• throws
  • 用在方法声明后面，跟的是异常类名
  • 可以跟多个异常类名，用逗号隔开
  • 表示抛出异常，由该方法的调用者来处理
• throw
  • 用在方法体内，跟的是异常对象名
  • 只能抛出一个异常对象名
  • 表示抛出异常，由方法体内的语句处理

如何自定义一个异常：

举个栗子：

UserService.java

public class UserService {
        //注册的方法
        public void register(String name) throws IllegalNameException{

            if(name.length()<6){
                //需要在这里面一个抛出非法注册名的异常，不过java里面没有类似的
                //手动抛出异常
                //注意是throw不是throws
                //使用throw在方法体内抛出异常
                throw new IllegalNameException("输入的用户名不合法！");
            }
            //如果代码能执行到此处，证明用户名是合法的.
            System.out.println("注册成功！");
        }
}

IllegalNameException.java

public class IllegalNameException extends Exception { // 编译时异常
//public class IllegalNameException extends RuntimeException{ //运行时异常

    private static final long serialVersionUID = 1L;

    // 定义异常一般提供两个构造方法
    public IllegalNameException() {
    }

    public IllegalNameException(String msg) {
        super(msg);
    }

}

RegisterTest.java

public class RegisterTest {

    public static void main(String[] args) throws IllegalNameException {

        // 假如用户提供的用户名如下
        String username = "mk";

        // 注册
        UserService cs = new UserService();

        try {
            cs.register(username);
        }catch(Exception e){
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
}

执行语句：

com.dss.main3.IllegalNameException: 输入的用户名不合法！
    at com.dss.main3.UserService.register(UserService.java:12)
    at com.dss.main3.RegisterTest.main(RegisterTest.java:14)
输入的用户名不合法！