异常

开发中的错误（语法错误、逻辑错误、异常）
异常（Exception）
- try-catch
- 异常对象的常用方法（getMessage、printStackTrace）
- finally
- 异常的种类（检查型异常、非检查型异常）
- throws（作用、流程、细节）
- throw
- 自定义异常（Exception、RuntimeException）
- 使用异常的好处
try-with-resources 语句
练习 - 编写一个断言类

Java笔记目录可以点这里：Java 强化笔记

开发中的错误（语法错误、逻辑错误、异常）

在开发 Java 程序的过程中，会遇到各种各样的错误：

语法错误
会导致编译失败，程序无法正常运行
逻辑错误
比如需要执行加法操作时，不小心写成了减法操作
运行时错误
在程序运行过程中产生的意外，会导致程序终止运行
在 Java 中也叫做异常

程序产生了异常，一般称之为：抛出了异常

如果没有主动去处理它，会导致程序终止运行

例：如果【代码2】抛出了异常，并且没有主动去处理它，程序就会退出，【代码3】将没有机会执行。

pubilc staic void main(String[] args) {【代码1】【代码2】【代码3】
}

思考：下面代码的打印结果是什么？

public static void main(String[] args) {System.out.println(1);Integer i1 = new Integer("123");System.out.println(2);Integer i2 = new Integer("abc");System.out.println(3);
}

由于 "abc" 无法转换成整数，new Integer("abc") 会抛出一个异常：

异常类型：java.lang.NumberFormatException
由于没有主动去处理这个异常，所以导致程序终止运行

思考：下面代码的打印结果是什么？

public static void main(String[] args) {System.out.println(1);Integer i = new Integer("1234");Object obj = "1/2.34";Double d = (Double)obj;System.out.println(2);
}

由于 "12.34" 无法强转成 Double 类型，(Double)Object 会抛出一个异常

异常类型：java.lang.ClassCastException
由于没有主动去处理这个异常，所以导致程序终止运行

思考：下面代码的打印结果是什么？

public static void main(String[] args) {Integer[] nums = { 11, null, 22 };for (int num : nums) {System.out.println(num);}
}

Integer 在自动拆箱为 int 时，会调用 Integer 对象的 inValue() 方法；
由于 nums[1] 为 null，使用 null 调用方法会抛出一个异常

异常类型：java.lang.NullPointerException
由于没有主动去处理这个异常，所以导致程序终止运行

上面抛出异常的代码建议这么写：

Integer[] nums= { 11, null, 22 };
for (Integer num : nums) {System.out.println(num);
}

打印的细节：
Java 中直接打印 null 会报错；

但是有时候确实可以把 null 打印出来：

public class Dog {@Overridepublic String toString() {return "Dog - 666";}
}

Dog dog = new Dog();
System.out.println(dog); // Doge - 666Dog dog2 = null;
System.out.println(dog2); // null

为什么 null 能被打印出来呢？可以看一下 println 的底层实现：发现调用了 String.valueOf

public void println(Object x) {String s = String.valueOf(x);synchronized (this) {print(s);newLine();}
}

再看看 String.valueOf：可以发现打印出 null 其实是经过处理的。

public static String valueOf(Object obj) {return (obj == null) ? "null" : obj.toString();}

异常（Exception）

Java 中有各种各样的异常

所有的异常最终都继承自 java.lang.Throwable

如何防止程序因为抛出异常导致终止运行？

可以通过 try-catch 来捕捉处理异常

try-catch

思考：下面代码的打印结果是什么？

public static void main(String[] args) {System.out.println(1);try {System.out.println(2);Integer i = new Integer("abc");System.out.println(3);} catch (NumberFormatException e) {System.out.println(4);}System.out.println(5);
}

一个 catch 捕获多种类型的异常：

try {} catch(异常A | 异常B | 异常 C) {// 当抛出【异常A】或【异常B】或【异常C】类型的异常时，会进入这个代码块
}

从 Java 7 开始，单个 catch 可以捕获多种类型的异常
如果并列的几个异常类型之间存在父子关系，保留父类型即可
这里的变量 e 是隐式 final 的

异常对象的常用方法（getMessage、printStackTrace）

try {Integer integer = new Integer("abc");
} catch (NumberFormatException e) {// 异常描述System.out.println(e.getMessage());// 异常名称 + 异常System.out.println(e);// 打印堆栈信息e.printStackTrace();
}

finally

try 或 catch 正常执行完毕后，一定会执行 finally 中的代码：

finally 可以和 try-catch 搭配使用，也可以只和 try 搭配使用
经常会在 finally 中编写一些关闭、释放资源的代码（比如关闭文件）

finally 细节：
如果在执行 try 或 catch 时，JVM 退出或者当前线程被中断、杀死

finally 可能不会执行

如果 try 或 catch 中使用了 return、break、continue 等提前结束语句

finally 会在 return、break、continue 之前执行

思考：下面代码的打印结果是什么？

for (int i = 1; i <= 3; i++) {try{System.out.println(i + "_try_1");if (i == 2) continue;System.out.println(i + "_try_2");} finally {System.out.println(i + "_finally");}
}

1_try_1
1_try_2
1_finally
2_try_1
2_finally
3_try_1
3_try_2
3_finally

for (int i = 1; i <= 3; i++) {try{System.out.println(i + "_try_1");if (i == 2) break;System.out.println(i + "_try_2");} finally {System.out.println(i + "_finally");}
}

1_try_1
1_try_2
1_finally
2_try_1
2_finally

public static void main(String[] args) {System.out.println(get());
}static int get() {try {new Integer("abc");System.out.println(1);return 2;} catch (Exception e) {System.out.println(3);return 4;} finally {System.out.println(5);}
}

3
5
4

异常的种类（检查型异常、非检查型异常）

检查型异常（Checked Exception）

这类异常一般难以避免，编译器会进行检查
如果开发者没有处理这类异常，编译器将会报错
哪些异常是检查型异常？
除 Error、RuntimeException 以外的异常

非检查型异常（Unchecked Exception）

这类异常一般可以避免，编译器不会进行检查
如果开发者没有处理这类异常，编译器将不会报错
哪些异常是非检查型异常？
Error、RuntimeException

常见的检查型异常：

常见的非检查型异常 – Error

常见的非检查型异常 – RuntimeException

throws（作用、流程、细节）

throws 的作用：将异常抛给上层方法

void test() throws FileNotFoundException, ClassNotFoundException {PrintWriter out = new PrintWriter("F:/mj/520it.txt");Class cls = Class.forName("Dog");
}

如果 throws 后面的异常类型存在父子关系，保留父类型即可

void test() throws Exception {PrintWriter out = new PrintWriter("F:/mj/520it.txt");Class cls = Class.forName("Dog");
}

void test() throws Throwable {PrintWriter out = new PrintWriter("F:/mj/520it.txt");Class cls = Class.forName("Dog");
}

可以一部分异常使用 try-catch 处理，另一部分异常使用 throws 处理：

void test() throws FileNotFoundException {PrintWriter out = new PrintWriter("F:/mj/520it.txt");try {Class cls = Class.forName("Dog");} catch (ClassNotFoundException e) {e.printStackTrace();}
}

thorws 的流程：

如果异常最终抛给了 JVM，那么整个 Java 程序将终止运行。

下面这个例子中，异常从 method1 开始网上抛，到 method2，再到 method3，最后抛给 main，main 又抛给了 JVM；

public static void main(String[] args) throws ClassNotFoundException {method1(); // 正常来说, 这里必须处理异常了, 否则出异常后Java程序会终止运行
}
static void method1() throws ClassNotFoundException {method2(); // 这里可以处理异常
}
static void method2() throws ClassNotFoundException {method3(); // 这里可以处理异常
}
static void method3() throws ClassNotFoundException{Class clazz = Class.forName("Dog"); // 这里可以处理异常
}

所以如果一直不处理异常，只往上抛最终会导致程序停止运行，一定要在某个地方处理异常。

throws 的细节
当父类的方法没有 throws 异常：子类的重写方法也不能 throws 异常
当父类的方法有 throws 异常，子类的重写方法可以：

不 throws 异常
throws 跟父类一样的异常
throws 父类异常的子类型

public class Person {public void test1() {}public void test2() throws IOException {}public void test3() throws IOException {}public void test4() throws IOException {}public void test5() throws IOException {}
}

public class Student extends Person {@Overridepublic void test1() {}@Overridepublic void test2() {}@Overridepublic void test3() throws IOException {}@Overridepublic void test4() throws FileNotFoundException {}// 只能抛出父类异常的子类, 或者不抛// public void test5() throws Exception {} // 抛出子类异常的父类异常, 会报错
}

throw

使用 throw 可以抛出一个新建的异常

public class Person {public Person(String name) throws Exception { // 抛出异常if (name == null || name.length() == 0) {// 检查型异常必须处理或者往上抛throw new Exception("name must not be empty.");}}
}

public class Person {public Person(String name)  {if (name == null || name.length() == 0) {// 非检查型异常可以不处理throw new IllegalArgumentException("name must not be empty.");}}
}

自定义异常（Exception、RuntimeException）

开发中自定义的异常类型，基本都是以下 2 种做法：

继承自 Exception
使用起来代码会稍微复杂
希望开发者重视这个异常、认真处理这个异常（该异常无法从代码层面去避免，必须引起重视）
继承自 RuntimeException
使用起来代码会更加简洁
不严格要求开发者去处理这个异常（因为规范的代码可以避免该异常）

示例：
自定义两种异常：EmptyNameException、WrongAgeException

public class EmptyNameException extends RuntimeException {public EmptyNameException() {super("name must not be empty");}
}

public class WrongAgeException extends RuntimeException {private int age;public WrongAgeException(int age) {super("wrong age:" + age + ", age must be > 0");}
}

在 Person 类中使用自定义的异常：

public class Person {private String name;private int age;public Person(String name, int age) {if (name == null || name.length() == 0) {throw new EmptyNameException();}if (age <= 0) {throw new WrongAgeException(age);}this.name = name;this.age = age;}
}

使用 Person 类有几率抛出异常：

public static void main(String[] args) {//WrongAgeException: wrong age:-10, age must be > 0Person person = new Person("Jack", -10);// 这句代码不会执行System.out.println(1);
}

使用异常的好处

将错误处理代码与普通代码区分开
能将错误信息传播到调用堆栈中
能对错误类型进行区分和分组

try-with-resources 语句

具体见：File、字符集、字节流、字符流、缓冲流、数据流、对象流、序列化、try-with-resources语句

从Java7开始推出的try-with-resources语句（可以没有catch、finally）

try(资源1; 资源2; ...) {} catch (Exception e) {} finally {}

可以在try后面的小括号中声明一个或多个资源（resource）

实现了 java.lang.AutoCloseable 接口的实例，都可以称之为是资源

不管try中的语句是正常还是意外结束

最终都会自动按顺序调用每一个资源的 close 方法（close 方法的调用顺序与资源的声明顺序相反）
调用完所有资源的 close 方法后，再执行 finally 中的语句

练习 - 编写一个断言类

/** 断言类*/
public class Asserts {public static void test(boolean v) {if (v) return;// throw new RuntimeException();System.err.println(new RuntimeException().getStackTrace()[1]);}
}

public class Main {public static void main(String[] args) throws ClassNotFoundException {// int age = 10;// Asserts.test(age > 0);// String name = "";// Asserts.test(name != null && name.length() != 0);Asserts.test(add(10, 20) == 30);Asserts.test(sub(20, 10) == 20);  }static int add(int num1, int num2) {return num1 + num2;}static int sub(int num1, int num2) {return num1 - num2;}
}

【Java 异常】try-catch、finally、异常的种类、throws、thorw、自定义异常、断言类相关推荐

多态的概念、对象上下转型、多态的应用、异常（异常概念、异常分类、java异常处理机制、try...catch...finally、throw和throws、自定义异常）
多态的概念: 多态性是指同一个操作作用于某一类对象,可以有不同的解释,产生不同的执行结果. 多态存在的三个必要条件: ① 需要存在继承或实现关系 ② 同样的方法调用而执行不同的操作.运行不同代码(重写 ...
java 必须try catch的异常_【java基础之异常】死了都要try，不淋漓尽致地catch我不痛快！...
@ 1.异常 1.1 异常概念异常 :简单说就是不正常运行,最终导致JVM的非正常停止. 在Java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建异常对象并抛出了一个异常对象.Java处 ...
java中try...catch处理异常
public class TryCatchStu { /*try catch:自己处理异常 *try{ * 可能出现异常的代码 *}catch(异常类名A e){ * 如果出现了异常 ...
Java面向对象之异常处理机制（try-catch-finally、throws、自定义异常）
文章目录一.异常与异常分类二.异常处理机制 1.try-catch处理 2.try-catch-finally处理 3.throws可能抛异常(少用) 4.throw抛出异常(少用) 三.自定义异 ...
JAVA入门级教学之（异常的处理try...catch）
* 处理异常的第二种方式:捕捉 try{}catch(){} * * 语法: * try{ * 可能出现异常的代码; * ...
java异常没有catch住_今天才真正了解Java的异常处理
异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的. 异常发生的原因有很多,通常包含以下几大类: 1.用户输入了非法数据. 2.要打开的文件不存在. 3.网络通信时连接中断 ...
JAVA 语言如何进行异常处理，关键字： throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？...
Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类, 并提供了良好的接口. 在 Java中,每个异常都是一个对象,它是 Throwable 类或其它子类的实例.当一个方 ...
java catch后面_java 异常被catch后将会继续执行的操作
我就废话不多说了,大家还是直接看代码吧~ import java.util.UUID; public class Test { public static void main(String[] arg ...
Java——异常(try...catch...finally)
public class Demo5_Throwable {public static void main(String[] args) {try{System.out.println(1/0);}c ...

【Java 异常】try-catch、finally、异常的种类、throws、thorw、自定义异常、断言类

异常

开发中的错误（语法错误、逻辑错误、异常）

异常（Exception）

try-catch

异常对象的常用方法（getMessage、printStackTrace）

finally

异常的种类（检查型异常、非检查型异常）

throws（作用、流程、细节）

throw

自定义异常（Exception、RuntimeException）

使用异常的好处

try-with-resources 语句

练习 - 编写一个断言类

【Java 异常】try-catch、finally、异常的种类、throws、thorw、自定义异常、断言类相关推荐

最新文章

热门文章