乐趣区

关于思否技术征文:大话Java异常

jiezi

本文参加了思否技术征文，欢送正在浏览的你也退出。

异样

异样的概述

  • 异样就是不失常的意思，Java 语言中次要是指程序在运行阶段产生的谬误

  • Throwable(可抛出的，可扔出的)

    • java.lang.Throwable 类是 Java 程序所有谬误或异样的超类

    • 次要有两个字类

      • Error

        • Error 次要形容比较严重的谬误
        • 无奈通过编程来解决的重大的谬误

      • Exception

        • Exception 次要 m 形容比拟轻量级的谬误
        • 能够通过编程来解决

Exception 类的次要分类

RuntimeException -> 运行时异样，也叫非检测性异样类

  • 非检测性异样类就是指 b 编译阶段无奈被编译器检测进去的异样

  • 次要子类

    • ArithmeticException -> 算数异样类
    • ArrayIndexOutOfBoundsException（间接子类）-> 数组下标异样类
    • NullPointerException -> 空指针异样
    • ClassCastException -> 类型转换异样
    • NumberFormatException（间接子类）-> 数字格局异样

  • 留神

    • 当程序的执行过程中产生异样，若没有手动进行解决，则由 Java 虚拟机采纳默认的形式进行解决，默认形式是打印异样名称、异样起因以及异样产生的地位并终止程序，后序代码无奈被执行

IOException 和其余异样类 -> 其余异样类，也叫做非检测性异样

案例

TestRuntimeException.java

package demo1;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/*
 *         ArithmeticException -> 算数异样类
        ArrayIndexOutOfBoundsException（间接子类）-> 数组下标异样类
        NullPointerException -> 空指针异样
        ClassCastException -> 类型转换异样
        NumberFormatException（间接子类）-> 数字格局异样
 */

public class TestRuntimeException {public static void main(String[] args) {
        
        
        // 察看检测性异样
        // FileInputStream fis = new FileInputStream("c:/a.txt");
    
        // java.lang.ArithmeticException 算数异样
        int a = 10; 
        int b = 0;
        if (b != 0) {System.out.println(a/b);
        }

        // java.lang.ArrayIndexOutOfBoundsException 数组下标越界异样

        int[] arr = new int[3];
        int num = 3;
        if (num >= 0 && num < arr.length) {System.out.println(arr[num]);
        }
 

        // java.lang.NullPointerException

        String str = null; 
        if (str != null) {System.out.println(str.length());
        }

        // java.lang.ClassCastException

        Exception ex = new Exception(); 
        if (ex instanceof IOException) {IOException ie = (IOException) ex;
        }

        // java.lang.NumberFormatException

        String s = "12be"; 
        if (s.matches("\\d+")) {System.out.println(Integer.parseInt(s));
        }
        System.out.println("运行程序完结");

    }
}

异样解决

运行时异样的解决形式

  • 对于绝大数运行时异样来说，都能够通过条件判断防止异样的产生

异样的捕捉

  • 语法格局

      try{可能产生异样对象的语句块}catch(异样类型 援用名){针对以后异样类型对象的解决语句块}
  .... (能够写多个 catch)
  finally{无论是否产生异样，都应该执行的语句块}

  • 注意事项

    • 当捕捉的构造中有多个 catch 分支时，切记小范畴的异样类型放在大范畴的异样类型下面
    • 懒人写法：
      catch(Exception e) {….}
  • 执行流程
    try {
        a;
        b;  // 可能产生异样的语句
        c;
    } catch (Exception e) {e;} finally {f;}
    
- 当没有产生异样的时候，程序的执行流程是：a b c f 
- 当产生异样时，程序的执行流程是: a b e f

  • 案例

    • TestExceptionCatch.java

      package demo2;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

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

    // 申明援用指向本类的对象，用于读取文件中的内容
    FileInputStream fis = null;
    try {// 随时可能产生文件找不到 y 异样对象，new FileNotFoundException()
        fis = new FileInputStream("d:/a.txt");
    } catch (FileNotFoundException e) {
        // 打印异样的名称、异样起因、异样的地位等信息
        e.printStackTrace();}
    
    try {fis.close();
    } catch (IOException e) {e.printStackTrace();
    } catch (NullPointerException e) {// System.out.println("输入");
        e.printStackTrace();}
}
}

    • TestFinally.java

      package demo3;

public class TestFinally {public static void main(String[] args) {
    int a = 10;
    int b = 0;
    
    try {System.out.println(a/b);
    } catch (Exception e) {e.printStackTrace();
        return ;
    } finally {System.out.println("无论是否产生异样都会执行");
    }
    System.out.println("程序完结");
}
}

      java.lang.ArithmeticException: / by zero
      无论是否产生异样都会执行
      at demo3.TestFinally.main(TestFinally.java:9)

异样的抛出

  • 基本概念

    • 某些非凡的场合中，当产生异样后却无奈间接解决 / 不想解决时，此时就能够将异样转移给以后办法的调用者，这就叫异样的抛出

  • 语法格局

    • 返回值类型 办法名称(形参列表) throws 异样类型{….}

  • 办法重写的准则

    • 要求办法名雷同、参数列表雷同、返回值类型也雷同，从 jdk1.5 开始容许返回子类类型
    • 范畴权限不能变小，能够雷同或者变大
    • 不能抛出更大的异样

    • 留神

      • 子类中重写当前的办法能够抉择抛出与父类一样的异样、更小的异样、不抛出异样，然而不能抛出更大的异样、不同的异样

      • 案例
        A.java

        package demo4;

import java.io.IOException;

public class A {public void show() throws IOException{System.out.println("A");
    }
}

        SubA.java

        package demo4;

import java.io.IOException;
import java.io.FileNotFoundException;
import javax.print.PrintException;

public class SubA extends A{

    @Override
    // public void show() throws IOException {// public void show() throws FileNotFoundException {// public void show() throws PrintException {// public void show() throws Exception {public void show() {}}

        显然不能抛出更大的异样

自定义异样

  • 自定义异样的由来

    • Java 官网库中尽管提供了大量的异样类，但不足以形容现实生活中所有的异常情况。当呈现官网库中没有 m 形容的异常情况，这个时候就须要程序员自定义异样类加以形容，使得异样信息更加具备针对性和可读性

  • 自定义异样的流程

    • 自定义类继承自 Exception 类或者 Exception 类的子类
    • 提供两个版本的构造方法，一个是无参构造方法，另一个是字符串做参数的构造方法

  • 自定义异样 — > 案例 1

    • Person.java

      package demo5;

public class Person {
private String name;
private int age;



public Person() {super();
}
public Person(String name, int age) throws Exception {super();
    setName(name);
    setAge(age);
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) throws Exception {if(age > 0 && age < 150) {this.age = age;} else {// System.out.println("年龄不合理");
        // 手动产生一个异样对象并抛出
        // throw new Exception();
        throw new AgeException("年龄不合理!");
    }
    System.out.println("产生异样的成果");
}
@Override
public String toString() {return "Person [name=" + name + ", age=" + age + "]";
}


}

    • AgeException.java

      package demo5;

public class AgeException extends Exception {

/**
 * 
 */
private static final long serialVersionUID = 1L;

// 自定义无参的构造方法
public AgeException() {}

// 自定义应用字符串作为参数的构造方法
public AgeException(String msg) {super(msg);
}
}

    • TestPerson.java

      package demo5;

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

    Person p = null;
    try {p = new Person("张三", -12);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();}
    System.out.println(p);
}
}

      demo5.AgeException: 年龄不合理!
      null
      at demo5.Person.setAge(Person.java:33)
      at demo5.Person.<init>(Person.java:15)
      at demo5.TestPerson.main(TestPerson.java:8)

  • 自定义异样 — > 案例 2

    • Student.java

      package demo6;

public class Student {
private String name;
private int id;


public Student() {super();
}
public Student(String name, int id) throws IDException {super();
    setName(name);
    setId(id);
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getId() {return id;}
public void setId(int id) throws IDException {if (id > 0) {this.id = id;} else {// System.out.println("学号不合理");
        throw new IDException("学号不合理");
    }
    System.out.println("完结");
}
@Override
public String toString() {return "Student [name=" + name + ", id=" + id + "]";
}


}

    • IDException.java

      package demo6;

public class IDException extends Exception {

/**
 * 
 */
private static final long serialVersionUID = 1L;

public IDException() {}

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

    • TestStudent.java

      package demo6;

public class TestStudent {public static void main(String[] args) throws IDException {
    
    /*Student stu = null;
    try {stu = new Student("小王", -5);
    } catch (IDException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();}*/ 
    
    Student stu = new Student("小王", -5);
    System.out.println(stu);
}
}

      Exception in thread “main” demo6.IDException: 学号不合理
      at demo6.Student.setId(Student.java:30)
      at demo6.Student.<init>(Student.java:14)
      at demo6.TestStudent.main(TestStudent.java:14)

此处有一点要留神，在案例一的 TestPerson 中，在 main 函数中，咱们应用 try….catch 语句，异样由外部进行解决，会打印前面的语句
而在案例二的 TestStudent 中，咱们将异样间接交给 main 函数解决，也就是交给虚拟机解决，所以并不会执行前面的语句

异样对象的抛出

  • throw new 异样类型()

  • 例如：

    • throw new Exception()

最初简略介绍一下 throws 和 throw 的区别

throws 和 throw 的区别

  • throws

    • 用在办法申明前面，跟的是异样类名
    • 能够跟多个异样类名，用逗号隔开
    • 示意抛出异样，由该办法的调用者来解决
    • throws 示意出现异常的一种可能性，并不一定会产生这些异样

  • throw

    • 用在办法体内，跟的异样对象名
    • 只能抛出一个异样对象名
    • 示意抛出异样，由办法体内的语句实现
    • throw 则是抛出了异样，执行 throw 则肯定抛出了某种异样
退出移动版