一.什么是异常?
1.当程序”运行后”,当jvm遇到一些无法处理的情况,例如:整数/0,这就表示jvm遇到一种”异常情况”.
通常jvm能够识别这些异常并在控制台打印异常信息,并结束程序
2.为了解决这些情况,java提出了”异常处理机制”,这种机制的使用,可以使得我们的代码在遇到异常时,
可以跳过异常的代码,继续健康的执行下去.
二.异常_异常的产生过程及JVM默认处理异常的方式
1).jvm执行到有异常的代码
2).jvm识别出遇到的异常情况
3).jvm 在类库中寻找描述这种异常的异常类,并创建对象
4).jvm 要看我们的代码中是否希望”捕获”这种异常
是:就执行相应的catch语句
否:在控制台打印异常信息,并结束程序
案例图片:
三.异常_Java的异常体系结构及分类
1).Throwable(类):Java中所有“异常”的顶层类；
|--Error(错误):不希望程序捕获并处理的错误情况。异常类名都是以：XxxxError结尾的。
|--Exception(异常):希望程序捕获并处理的异常情况。异常类名都是以：XxxxException结尾的。
|--RuntimeException(运行时异常):
|--除RuntimeException以外的其它异常(编译期异常):
--------------------------------------------------------------------------
四.异常的处理_try_catch语句及操作异常对象
1).格式：
try{
//可能出现异常的代码
}catch(异常类名 变量名){
//如果try中出现了与"异常类名"相同的异常情况，
//JVM将会执行这个catch，以挽救程序。
3).操作异常对象：
1).getMessage():获取异常信息；
2).toString():异常类名 + 异常信息
3).printStackTrace()：打印异常详细信息；【常用：在调试时】
五.第二章：异常的处理_try_catch_catch语句
1).格式：
try{
//可能出现异常的代码
//多行代码...
}catch(异常类名1 变量名){
}catch(异常类名2 变量名){
}
2).示例代码：
public static void main(String[] args) {
int a = 10;
int b = 10;
int[] arr = new int[0];
try {
System.out.println("除法：" + (a / b));//算数运算异常
System.out.println("数组长度：" + arr.length);//空指针异常
System.out.println("数组的第一个元素：" + arr[0]);//数组索引越界异常
} catch (ArithmeticException e) {
System.out.println("算数运算异常！！");
} catch (NullPointerException e) {
System.out.println("空指针异常！！");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组索引越界异常！！");
} catch (Exception e) {
System.out.println("系统出现了未知异常，请联系系统管理员！");
}
System.out.println("后续代码...");
}
注意：
1).在try中如果某行出现异常，try中的后续代码将不会被执行；
2).在多个catch中的“异常类名”绝对不能重复；
3).在多个catch中的“异常类名”通常是“同级”关系；也可以是“子父类”关系，如果是子父类关系，“父类的异常类名”一定要写在多catch的最后。
六.第二章：异常的处理_try_catch_finally语句
1).格式：
try{
//可能出现异常的代码
}catch(异常类名 变量名){
//如果try中出现了与“异常类名”相同的异常，
//将会执行这里
}finally{
//无论是否出现异常，都会被执行
//通常用在try和catch中有"return"语句的情况。
//finally中的代码会保证在try或者catch的return之前被执行。
}
七.第二章：异常的处理_抛出异常_throw语句
1).格式：
方法声明(){
if(....){//判断
throw new 异常对象("异常信息");//此异常对象，会抛给"调用的代码"，由调用的代码处理；
}
}
2).示例代码：
public class Demo {
public static void main(String[] args) {
try {
getMax(null);
} catch (NullPointerException e) {
System.out.println(e.getMessage());
}
try {
int[] arr = new int[0];
getMax(arr);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
}
//编写方法，可以求一个数组中所有元素最大值
public static int getMax(int[] arr) {
if (arr == null) {
//为什么要“抛出一个异常对象”？
//为了告诉调用的代码：我这个方法中出现了异常，没有正常秩序完毕！
throw new NullPointerException("哥们，别给我传空指针啊！揍你啊！！");
}
if (arr.length == 0) {
throw new ArrayIndexOutOfBoundsException("哥们，别给我传0长度数组！削你啊！！");
}
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
max = arr[i] > max ? arr[i] : max;
}
return max;
}
}
八.异常的处理_抛出异常_throws语句
1).格式：
方法声明() throws 异常类名1,异常类名2...{
//正常写代码即可
//如果方法中出现了声明的“异常类名1”，“异常类名2”类型的异常，
//JVM会将这种异常对象抛给调用的代码，由调用的代码处理。
}
2).示例代码：
public class Demo {
public static void main(String[] args) {
try {
getMax(null);
} catch (NullPointerException e) {
System.out.println(e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
try {
int[] arr = new int[0];
getMax(arr);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
}
//编写方法，可以求一个数组中所有元素最大值
//throws:表示：声明抛出
public static int getMax(int[] arr) throws NullPointerException,
ArrayIndexOutOfBoundsException{
//方法中正常写代码即可。
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
max = arr[i] > max ? arr[i] : max;
}
return max;
}
}
3).注意事项：
1).如果throws声明抛出的是：运行时异常(RuntimeException及其子类)，调用处可以不处理，编译通过。
但运行时，如果真的出现异常，仍然停掉程序。
2).如果throws声明抛出的是：编译期异常(除RuntimeException以外的异常)，调用处必须处理，
要么try...catch...，要么继续抛出，否则编译错误。
throw和throws的区别：
1).throw:(抛出)
1).用在方法中;
2).throw后面是：new 异常对象();而且只能有一个；
3).表示：立即抛出一个异常对象给方法的调用处；
2).throws:(声明抛出)【常用】
1).用在方法的声明处；
2).throws后面是：“异常类名”,可以有多个。
3).表示：告诉JVM，此方法内部“可能会出现某种异常”，如果运行时，真的出现异常，JVM
要将这个异常对象抛给调用处。
九.异常的处理_注意事项
1).子类重写父类方法时，throws的写法：
class Fu{
public void show1(){}
public void show2() throws NullPointerException{}//空指针异常--运行时异常
public void show3() throws IOException{}//编译期异常
}
class Zi extends Fu{
public void show1() throws Exception{}
public void show2() throws ArrayIndexOutOfBoundsException{}
public void show3() throws IOException,ParseException{}
}
2).当子类重写父类方法时，throws方面总体遵循以下三条规则：
1).无论父类方法是否抛出异常，子类方法都可以：不抛出任何异常；
2).无论父类方法是否抛出异常，子类方法都可以：抛出任何的“运行时异常”；
3).无论父类方法是否抛出异常，子类方法可以抛出跟父类相同的“编译期异常(或者子类异常)”,
不能抛出比父类更多的编译期异常。
3).示例代码：
class Fu{
public void show1() {}
public void show2() throws NullPointerException{}//空指针异常--运行时异常
public void show3() throws IOException {}//编译期异常
}
//1.都可以不抛出任何异常；
class Zi1 extends Fu{
@Override
public void show1() {
super.show1();
}
@Override
public void show2() {
super.show2();
}
@Override
public void show3() {
}
}
//2.都可以抛出任何的运行时异常
class Zi2 extends Fu{
@Override
public void show1() throws NullPointerException {
}
@Override
public void show2() throws NullPointerException {
}
@Override
public void show3() throws NullPointerException {
super.show1();
}
}
//3.只能抛出跟父类相同的“编译期异常（或者子类）”，不能抛出父类没有的编译器异常。
class Zi3 extends Fu{
@Override
public void show1() {
}
@Override
public void show2() {
}
@Override
public void show3() throws ChangedCharSetException,ActivationException {//错误
}
}
十.异常_自定义异常
1).有些时候，根据自身的业务逻辑，需要某种异常类，但类库中没有提供这种异常类，这时我们可以自定义自己的异常类。
class Student{
private int age;
public void setAge(int age){
if(age < 15 || age > 50){
//抛出异常
throw new 自定义异常对象();
}
this.age = age;
}
}
2).定义异常类：
class Throwable{
private String detailMessage;
public String getMessage(){
this.detailMessage;
}
}
class Exception extends Throwable{
public Excepton(String msg){
super(msg);
}
}
class RuntimeException extends Exception{
public RuntimeException (String msg){
super(msg);
}
}
//自定义异常类，可以继承自任意的Exception类及其子类。
class AgeException extends RuntimeException{
public AgeException (String msg){
super(msg);
}
}
public class Student{
private int age;
public void setAge(int age){
if(age < 15 || age > 50){
//抛出异常
throw new AgeException("年龄非法，必须在15到50之间！！");
}
this.age = age;
}
}
public class Demo {
public static void main(String[] args) {
Student stu = new Student();
try {
stu.setAge(10);
} catch (NullPointerException e) {
System.out.println("异常了：");
System.out.println(e.getMessage());
}
}
}