本文参加了思否技术征文，欢送正在浏览的你也退出。
异样
异样的概述
- 异样就是不失常的意思，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.javapackage 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("产生异样的成果");}@Overridepublic 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("完结");}@Overridepublic 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则肯定抛出了某种异样