Throwable
Throwable 类是 Java 语言中所有错误或异常的超类。
成员方法
public String getMessage()：返回此 throwable 的详细消息字符串
public String toString()：获取异常类名和异常信息。
public void printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置。
public void printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。
/*
* Thowable类讲解
* Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，
* 才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。
*
* 成员方法
public String getMessage()：返回此 throwable 的详细消息字符串
public String toString()：获取异常类名和异常信息。
public void printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置。
public void printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。
观察Throwable的源码
class ArithmeticException extends RuntimeException{
// "除数不能为0"
public ArithmeticException(String s) {
super(s);
}
}
class RuntimeException extends Exception{
public RuntimeException(String message) {
// "除数不能为0"
super(message);
}
}
class Exception extends Throwable{
public Exception(String message) {
super(message);
}
}
class Throwable{
// "除数不能为0"
private String detailMessage;
// // "除数不能为0"
public Throwable(String message) {
fillInStackTrace();
detailMessage = message;
}
public String getMessage() {
return detailMessage;
}
public String toString() {
String s = getClass().getName(); java.lang.ArithmeticException
String message = getLocalizedMessage(); "除数不能为0"
return (message != null) ? (s + ": " + message) : s; java.lang.ArithmeticException:除数不能为0
}
public String getLocalizedMessage() {
return getMessage();
}
}
*/
public class ExceptionDemo03 {
public static void main(String[] args) throws FileNotFoundException {
// Throwable throwable = new NullPointerException();
Throwable throwable = new ArithmeticException("除数不能为0");
String message = throwable.getMessage();
// System.out.println(message);
// System.out.println(throwable.toString()); // java.lang.ArithmeticException: 除数不能为0
// public void printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置。
// throwable.printStackTrace();
// public void printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。
// throwable.printStackTrace(new PrintWriter("a.txt"));
StackTraceElement[] stackTrace = throwable.getStackTrace();
for (int i = 0; i < stackTrace.length; i++) {
System.out.println(stackTrace[i].getMethodName() + "|" + stackTrace[i].getClassName() + "|" + stackTrace[i].getLineNumber() + "|" + stackTrace[i].getFileName()) ;
}
}
}
throws关键字
throws关键字概述
在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用者进行处理。
throws使用格式
[修饰符] 返回值类型 方法名(参数列表) [throws 异常类1,异常类2....]{
}
注意:
1、如果一个方法声明的是编译时期异常，则在调用这个方法之处必须处置这个异常（谁调用谁处理）。
2、重写一个方法时，它所声明的异常范围不能被扩大。
代码演示一个方法抛出编译时期异常和运行时期异常。
public class ExceptionDemo06 {
public static void main(String[] args) {
// try {
// calc();
// } catch (Exception e) {
// e.printStackTrace();
// }
try {
method();
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("00000000000000000");
}
public static int calc() throws ArithmeticException{
int a = 10;
int b = 0;
int result = a/b;
return result;
}
public static void method() throws ParseException{
String s = "2018-04-28";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM/dd");
sdf.parse(s);
}
}
class Father{
public void show() throws Exception{
}
}
class Son extends Father{
@Override
public void show() throws NullPointerException,ArithmeticException,ClassCastException {
}
}
throw
throw和throws的区别
/*
* throw关键字讲解
*
* throw和throws的区别
*
* throws用在方法声明后面，跟的是异常类名，throw用在方法体内，跟的是异常对象名。
throws可以跟多个异常类名，用逗号隔开，throw只能抛出一个异常对象名。
throws表示抛出异常，由该方法的调用者来处理，throw表示抛出异常，由方法体内的语句处理。
throws表示出现异常的一种可能性，并不一定会发生这些异常，throw则是抛出了异常，执行throw则一定抛出了某种异常。
*/
public class ExceptionDemo07 {
public static void main(String[] args) throws ParseException {
method();
try {
method2();
}catch (NullPointerException e) {
e.printStackTrace();
} catch (ArithmeticException e) {
e.printStackTrace();
// Exception e = new ArithmeticException("除数为0了哈啊哈哈！！");
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("9999999999");
}
public static void method() throws ParseException {
String s = "2018-04-28";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date d = sdf.parse(s);
System.out.println(d);
}
public static void method2() throws ArithmeticException {
int a = 10;
int b = 0;
if (b == 0) {
throw new ArithmeticException("除数为0了哈啊哈哈！！");
}
System.out.println(a/b);
}
}
finally
finally修饰的代码块一定会被执行，除非在执行到finally之前程序异常退出或者调用了系统退出的方法。
finally用于释放资源，在IO流操作和数据库操作中会见到。
finally相关的面试题
简述final,finally和finalize的区别。
/*
* finally碰到return
* finally一定会执行
* 执行顺序?
*
* 在try语句中，在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了。
在转去之前，try中先把要返回的结果存放到不同于x的局部变量中去，执行完finally之后，在从中取出返回结果，
因此，即使finally中对变量x进行了改变，但是不会影响返回结果。它应该使用栈保存返回值。
*/
public class FinallyTest {
public static void main(String[] args) {
System.out.println(test());
}
public static int test() {
int x = 1;
try {
x++;
return x;
} finally {
++x;
System.out.println(x);
}
}
}
自定义异常
*
* 编写一个分数必须在0-100分之间的异常
* 并且使用这个异常
*
* 步骤:
* 定义一个异常继承Throwable或者Exception或者RuntimeException
* 编写构造方法
* 带参
* 无参
*/
public class ExceptionDemo09 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个分数:");
double score = input.nextDouble();
Teacher teacher = new Teacher();
try {
System.out.println(teacher.isBetween0To100(score) ? "分数合法" : "分数不合法");
} catch (ScoreException e) {
// e.printStackTrace();
System.err.println(e.getMessage());
} catch (Exception e) {
e.printStackTrace();
} finally {
input.close();
}
System.out.println("分数批改完毕!");
}
}
class ScoreException extends Exception{
public ScoreException(){}
public ScoreException(String message) {
super(message);
}
}
class Teacher{
public boolean isBetween0To100(double score) throws ScoreException{
if (score > 100 || score < 0) {
throw new ScoreException("分数必须在0-100分之间！！！");
}
return true;
}
}
