javaSE---异常

目录

异常

空指针异常---NullPointerException

算数异常---ArithmeticException

 数组越界异常---ArrayIndexOutOfBoundsException

 捕获异常

异常体系结构

 自定义异常

---

异常

java异常指的是java程序中的一些错误。是指程序在执行过程中出现的非正常情况，最终导致JVM的非正常停止。异常有许多种，常见的几种将举例说明

空指针异常---NullPointerException

  public static void main(String[] args) {
        String str=null;//str不指向任何对象
        System.out.println(str.length());
    }

算数异常---ArithmeticException

  public static void main(String[] args) {
        System.out.println(10/0);//0作为除数，算数异常
    }

 数组越界异常---ArrayIndexOutOfBoundsException

  public static void main(String[] args) {
        int []arr=new int []{1,2};
        System.out.println(arr[2]);//数组越界
    }

 捕获异常

try{

存放可能发现异常的代码}

catch（存放异常）{

如果发生异常的执行方法}

finally{

}

• 捕获一个异常 

如果不捕捉异常，那么异常报给了JVM,代码就直接结束了

  public static void main(String[] args) {
        int []arr={1,4};
        System.out.println(arr[2]);//这里数组越界异常,异常交给JVM直接结束
        System.out.println("hi");
    }

  public static void main(String[] args) {
        int []arr={1,4};
        try{
            System.out.println(arr[2]);//数组越界异常，被catch捕捉
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();//从栈上获取信息，得到异常的地方
            System.out.println("这是一个异常:ArrayIndexOutOfBoundsException");
        }
  finally{
      System.out.println("hi");//异常被捕捉，可以执行
    }
}

 调用该方法时，try中读取数组时若发生异常，代码会进入 catch 代码块，之后进入 finally 代码块；若读取数组时未发生异常，则会跳过 catch 代码块直接进入 finally 代码块。所以无论代码中是否发生异常，fianlly 中的代码都会执行。

• 捕获多个异常

使用父类或者使用符号|

  public static void main(String[] args) {
        int []arr={1,2};
        try {
            arr=null;
            System.out.println(arr.length);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        int []arr={1,2};
        try {
            arr=null;
            System.out.println(arr.length);
        }catch (ArrayIndexOutOfBoundsException|NullPointerException e){
            e.printStackTrace();
        }
    }

•  finally中含有return 

 public static int fun2() {
        try {
            String s = null;
            System.out.println(s.length());
            return 8;
        } catch (NullPointerException a) {
            a.printStackTrace();
            System.out.println("捕捉到了空指针异常");
            return 0;
        }finally {
            return 9;
        }
    }

    public static void main(String[] args) {
        System.out.println(fun2());
    }

 结果：9，finally的return会覆盖之前的return

异常体系结构

•  Error

Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形，是比较严重的，仅仅靠修改程序本身是无法恢复执行的

• Exception

Exception是异常类，表示程序本身可以处理的错误。java程序开发中进行的异常处理都是针对Exception类和其子类的。

它下面很多派生类,其中它的派生类也分两种, 一种是RuntimeException(运行时异常), 其他的都是编译时异常。

• 运行时异常 ---非受查异常

RuntimeException类和子类属于运行时异常，这种异常在程序运行时由JVM自动捕捉，没有try-catch捕获或者throws声明抛出，程序也可以编译通过，只是可能在运行过程中可能报错

• 编译时异常---受查异常

Exception类中除了RuntimeException类下的都是编译时异常。编译时异常的特点是在程序中，Java编译器会对代码进行检查，如果异常不解决，编译期间就会报错

解决异常的方法：

1、使用try---catch语句捕获异常

2、使用throws关键字抛出异常，让调用者对其处理

Error和RuntimeException类都属于非受查异常，Exception类除RuntimeException类的其他类都属于受查异常

 clone方法属于受查异常

try-catch捕获异常

class Person implements Cloneable{
    int age=9;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Text {

    public static void fun4()  {
        Person person = new Person();
        try {
            Person p = (Person) person.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        System.out.println(person.age);
    }
    public static void main(String[] args)  {
        fun4();
    }
}

throws声明异常 

class Person implements Cloneable{
    int age=9;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Text {

    public static void fun4() throws CloneNotSupportedException {
        Person person = new Person();
            Person p = (Person) person.clone();
        System.out.println(person.age);
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        fun4();
    }
}

 自定义异常

class NameException extends RuntimeException{//非受查异常

    public NameException(String message) {
        super(message);
    }
}
class PasswordException extends RuntimeException{

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

public class Text {
    private  static final String name="李四";
    private  static final String password="123456";
    public static void loadin(String name,String passord){
        if (!Text.name.equals(name)) {
            throw new NameException("姓名异常");
            //抛出异常
        }
        if (!Text.password.equals(passord)) {
            throw new PasswordException("密码异常");
        }
        System.out.println("登录成功");
    }
    public static void main(String[] args)  {
        loadin("李四", "123456");
    }
}

class NameException extends Exception{//受查异常

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

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

public class Text {
    private  static final String name="李四";
    private  static final String password="123456";
    public static void loadin(String name,String passord) throws NameException, PasswordException {
        if (!Text.name.equals(name)) {
            throw new NameException("姓名异常");
            //抛出异常
        }
        if (!Text.password.equals(passord)) {
            throw new PasswordException("密码异常");
        }
        System.out.println("登录成功");
    }
    public static void main(String[] args) throws PasswordException, NameException {
        loadin("李四", "123456");
    }
}