异常的讲解 （1）
目录
异常入门的案例
异常介绍 基本概念
异常的小结
常见的运行时异常
1.NullPointerException空指针异常
2.ArithmeticException数学运算异常
3.ArraylndexOutOfBoundsException数组下标越界异常
4.ClassCastException类型转换异常
5.NumberFormatException数字格式不正确异常
编译异常
基本介绍
常见的编译异常
异常处理
异常的练习
try-catch异常处理
try-catch方式异常处理注意事项
try-catch异常处理习题
第一题
第二题
第三题
第四题
try-catch-finally执行顺序小结
异常入门的案例
在下面的代码中我们在执行到 int res = num1/num2; 的时候就会报错，如果我们没有使用try - catch 那么程序就会直接奔溃
代码演示：
package idea.chapter12.exception_;
public class Exception01 {
public static void main(String[] args) {
int num1 = 10;
int num2 = 0;//Scanner();
//1. num1 / num2 => 10 / 0
//2. 当执行到 num1 / num2 因为 num2 = 0, 程序就会出现(抛出)异常 ArithmeticException
//3. 当抛出异常后，程序就退出，崩溃了 , 下面的代码就不在执行
//4. 这种情况非常的不好，不应该出现了一个不算致命的问题，就导致整个系统崩溃
//5. 因此有一个异常处理机制来解决该问题
// int res = num1 / num2;
//如果我们觉得，认为一段代码可能出现异常/问题，可以使用try-catch异常处理机制来解决
//从而保证程序的发生了错误但是不会直接崩溃
//将该代码块->选中->快捷键 ctrl + alt + t -> 选中 try-catch
//6. 如果进行异常处理，那么即使出现了异常，程序可以继续执行
try {
int res = num1 / num2;
} catch (Exception e) {
e.printStackTrace();
//System.out.println("出现异常的原因=" + e.getMessage());//输出异常信息
}
//从运行结果中我们可以看到，程序还是出错了，但是没有直接奔溃，而且将代码执行完毕在退出
System.out.println("程序继续运行");
}
}异常介绍 基本概念
Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)
执行过程中所发生的异常事件可分为两大类
1)Error(错误)：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError[栈溢出]和OOM(out of memory)[内存耗尽]，Error是严重错误，程序会崩溃。
2.Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，Exception分为两大类：运行时异常[程序运行时，发生的异常]和编译时异常[编程时，编译器检查出的异常]。
异常的小结
1.异常分为两大类，运行时异常和编译时异常.
2.运行时异常，编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常
3.对于运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
4.编译时异常，是编译器要求必须处置的异常
常见的运行时异常
1.NullPointerException空指针异常
当应用程序试图在需要对象的地方使用null时，抛出该异常
代码演示：
package idea.chapter12.exception_;
/**
* 演示空指针异常
*/
public class NullPointerException_ {
public static void main(String[] args) {
String name = null;
System.out.println(name.length());
}
}
2.ArithmeticException数学运算异常
当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例，
代码演示：
package idea.chapter12.exception_;
/**
* 演示数学运算异常
*/
public class ArithmeticException_ {
public static void main(String[] args) {
int num1 = 10;
int num2 = 0;//Scanner();
System.out.println(num1/num2);
}
}
3.ArraylndexOutOfBoundsException数组下标越界异常
数组下标越界异常用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引
代码演示：
package idea.chapter12.exception_;
/**
* 演示数组下标异常
*/
public class ArrayIndexOutOfBoundsException_ {
public static void main(String[] args) {
int[] arr = {1, 2, 4};
for (int i = 0; i <= arr.length; i++) {
System.out.println(arr[i]);
}
}
}
4.ClassCastException类型转换异常
类型转换异常当试图将对象强制转换为不是实例的子类时，抛出该异常。例如，以下代码将生成一个ClassCastException
代码演示：
package idea.chapter12.exception_;
/**
* 演示类型转换异常
*/
public class ClassCastException_ {
public static void main(String[] args) {
A b = new B(); //向上转型
B b2 = (B) b;//向下转型，这里是OK
//多态的向下转型**
//1)语法：子类类型 引用名= （子类类型)父类引用；
//2)只能强转父类的引用，不能强转父类的对象
//3)要求父类的引用必须指向的是当前目标类型的对象
//4)当向下转型后，可以调用子类类型中所有的成员
//这里c2的类型是B 和C没有任何关系所以报错
C c2 = (C) b;//这里抛出ClassCastException
}
}
class A {
}
class B extends A {
}
class C extends A {
}
5.NumberFormatException数字格式不正确异常
数字格式不正确异常当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常 使用异常我们可以确保输入是满足条件数字.
代码演示：
package idea.chapter12.exception_;
/**
* 演示类型转换异常
*/
public class NumberFormatException_ {
public static void main(String[] args) {
String name = "你好";
//将String 转成 int
int num = Integer.parseInt(name);//抛出NumberFormatException
System.out.println(num);//1234
}
}
编译异常
基本介绍
编译异常是指在编译期间，就必须处理的异常，否则代码不能通过编译。
常见的编译异常
SQLException//操作数据库时，查询表可能发生异常
IOException//操作文件时，发生的异常
FileNotFoundException//当操作一个不存在的文件时，发生异常
ClassNotFoundException//加载类，而该类不存在时，异常
EOFException//操作文件，到文件末尾，发生异常
IllegalArguementException//参数异常
异常处理
基本介绍
异常处理就是当异常发生时，对异常处理的方式。
异常处理的方式
1)try-catch-finally 程序员在代码中捕获发生的异常，自行处理
2.throws 将发生的异常抛出，交给调用者(方法)来处理
异常的练习
代码演示：
public class AAA{
int x; //默认 0
public static void main(String[] args){
int y;
AAA a=new AAA();
y=3/a.x;//==>3/0
System.out.println("program ends ok!);
//出现ArithmeticException
}
}
Cat c=new Cat();
I cat=null;
System.out.println(cat.name);
出现NullPointerException
class Person{
public static void main(String[] args){
Object obj = new Date();
Person person;
person=(Person)obj;
System.out.println(person);
//出现ClassCastException
}
}try-catch异常处理
1.Java提供try和catch块来处理异常。try块用于包含可能出错的代码。catch块用于处理try块中发生的异常。可以根据需要在程序中有多个try...catch块。
2)基本语法
try {
//可疑代码
//将异常生成对应的异常对象，传递给catch块
}catch(异常)( //对异常的处理
}
//如果没有finally，语法是可以通过
try-catch方式异常处理注意事项
1)如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块.
2)如果异常没有发生，则顺序执行try的代码块，不会进入到catch.
3)如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码-finally{}
代码演示：
package idea.chapter12.try_;
public class TryCatchDetail01 {
public static void main(String[] args) {
/*
1)如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块.
2)如果异常没有发生，则顺序执行try的代码块，不会进入到catch.
3)如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码-finally{}
*/
try {
String str = "你好";
int a = Integer.parseInt(str);
//1)如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块.
//这里会报出一个classCastException异常，因为尝试将一个字符串，转成一个int
System.out.println("数字：" + a);
} catch (NumberFormatException e) {
//如果程序发生异常，就不会在执行try中的代码块，而是执行catch中的代码块
System.out.println("异常信息=" + e.getMessage());
} finally {
//无论程序是否有异常，finally都会被执行
System.out.println("finally代码块被执行...");
}
System.out.println("程序继续执行");
}
}
4.可以有多个catch语句，捕获不同的异常(进行不同的业务处理)，要求父类异
常在后，子类异常在前，比如(Exception在后，NullPointerException在
前)，如果发生异常，只会匹配一个catch
代码演示：
package idea.chapter12.try_;
public class TryCatchDetail02 {
public static void main(String[] args) {
//1.如果try代码块有可能有多个异常
//2.可以使用多个catch 分别捕获不同的异常，相应处理
//3.要求子类异常写在前面，父类异常写在后面
try {
Person person = new Person();
//person = null;
System.out.println(person.getName());//NullPointerException
int n1 = 10;
int n2 = 0;
int res = n1 / n2;//ArithmeticException
} catch (NullPointerException e) {
System.out.println("空指针异常=" + e.getMessage());
} catch (ArithmeticException e) {
System.out.println("算术异常=" + e.getMessage());
} catch (Exception e) {//因为Exception是他们的父类，所以要写在后面，如果写在前面会报错
System.out.println(e.getMessage());
} finally {
}
}
}
class Person {
private String name = "jack";
public String getName() {
return name;
}
}
5)可以进行try-finally配合使用，这种用法相当于没有捕获异常，因此程序会直接崩掉。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑
·try{ //代码
}
finallyfl {//总是执行
}
代码演示：
package idea.chapter12.try_;
public class TryCatchDetail03 {
public static void main(String[] args) {
/*
可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，
因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，
都必须执行某个业务逻辑
*/
try{
int n1 = 10;
int n2 = 0;
System.out.println(n1 / n2);
}finally {
//及时没有捕获异常，也会执行finally中的代码
System.out.println("执行了finally..");
}
System.out.println("程序继续执行..");
}
}try-catch异常处理习题
第一题
思路分析：
1.首先我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
就会被catch中捕获到，返回3，但是要注意代码中finally存在，因此还要执行finally中的代码，而finally中代码返回的4那么最终的结果返回的也就是4
2.这里不要忘记，finally必须执行
package idea.chapter12.try_;
public class TryCatchExercise01 {
}
/*
思路分析：
1.首先我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
就会被catch中捕获到，返回3，但是要注意代码中finally存在，因此还要执行finally中的代码，而finally中代码返回的4那么最终的结果返回的也就是4
2.这里不要忘记，finally必须执行
*/
class Exception01 {
public static int method() {
try {
String[] names = new String[3];//String[]数组
if (names[1].equals("tom")) {//NullPointerException
System.out.println(names[1]);
} else {
names[3] = "jack";
}
return 1;
} catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {//捕获
return 3;
} finally { //必须执行
return 4; //返回4
}
}
public static void main(String[] args) {
System.out.println(method()); //4
}
}
第二题
思路分析：
1.我们先执行了i++;因此i现在的值就是2
2.我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
就会被异常捕获，因为是空指针异常，所以会执行这句话，return ++i;因为是前++,所以i会先自增后返回，但是要注意的是，还要finally中的代码没有执行
所以会执行finally中的代码，finally中的代码也是return ++i 所以先自增后返回，最后返回的就是4
package idea.chapter12.try_;
public class TryCatchExercise02 {
}
/*
思路分析：
1.我们先执行了i++;因此i现在的值就是2
2.我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
就会被异常捕获，因为是空指针异常，所以会执行这句话，return ++i;因为是前++,所以i会先自增后返回，但是要注意的是，还要finally中的代码没有执行
所以会执行finally中的代码，finally中的代码也是return ++i 所以先自增后返回，最后返回的就是4
*/
class Exception02 {
public static int method() {
int i = 1;
try {
i++; //i = 2
String[] names = new String[3];
if (names[1].equals("tom")) {//空指针
System.out.println(names[1]);
} else {
names[3] = "jack";
}
return 1;
} catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {
return ++i; //i = 3
} finally {//必须执行
return ++i; //i = 4
}
}
public static void main(String[] args) {
System.out.println(method());
}
}第三题
思路分析：
1.我们先执行了i++;因此i现在的值就是2 2.我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常 就会被异常捕获，因为是空指针异常，所以会执行这句话，return ++i;因为是前++,所以i会先自增后返回，此时i自增完之后是3 ，但是要注意的是，还要finally中的代码没有执行 所以不能直接返回，要执行finally中的代码，finally中的代码也是 ++i 导致i变成了4 然后在输出i,那么输出的结果也就是4 3.注意我们在catch中的i还没有返回，因为在执行finally中的代码的时候，会有一个临时变量，暂时保存到i去执行finally代码块之前的值，所以会返回一个3
package idea.chapter12.try_;
public class TryCatchExercise03 {
}
/*
1.我们先执行了i++;因此i现在的值就是2
2.我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
就会被异常捕获，因为是空指针异常，所以会执行这句话，return ++i;因为是前++,所以i会先自增后返回，此时i自增完之后是3 ，但是要注意的是，还要finally中的代码没有执行
所以不能直接返回，要执行finally中的代码，finally中的代码也是 ++i 导致i变成了4 然后在输出i,那么输出的结果也就是4
3.注意我们在catch中的i还没有返回，因为在执行finally中的代码的时候，会有一个临时变量，暂时保存到i去执行finally代码块之前的值，所以会返回一个3
*/
class ExceptionExe01 {
public static int method() {
int i = 1;//i = 1
try {
i++;// i=2
String[] names = new String[3];
if (names[1].equals("tom")) { //空指针
System.out.println(names[1]);
} else {
names[3] = "jack";
}
return 1;
} catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {
return ++i; // i = 3 => 保存临时变量 temp = 3;
//因为必须要执行finally，但是finally没有return语句所以在执行完finally后返回到catch (NullPointerException e)这里，并且会保存一个临时变量，返回的也是临时变量的值
} finally {
++i; //i = 4
System.out.println("i=" + i);// i = 4
}
}
public static void main(String[] args) {
System.out.println(method());// 3
}
}第四题
思路分析：
package idea.chapter12.try_;
import java.util.Scanner;
public class TryCatchExercise04 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);//创建一个scanner
int num = 0;
String key = "";
for (; ; ) {//创建一个无限循化
try {
System.out.println("请输入一个整数");//提示用户输入
key = scanner.next();//接受用户的输入
num = Integer.parseInt(key);
//然后调用包装类 把输入的值转换成一个整数可能会报异常这时候就会执行到catch语句里 ，提示重新输入
//因为是在循化里catch里没有break语句所以会重复执行一直到成功转换没有异常才会执行的try里面的break 跳出循化
//如果没有异常，就不会执行到catch中的代码，直接执行break跳出循环
break;
} catch (Exception e) {
System.out.println("输入错误，重新输入");
}
}
System.out.println("你输入的数为：" + num);
}
}try-catch-finally执行顺序小结
1)如果没有出现异常，则执行try块中所有语句，不执行catch块中语句，如果有finally，最后还需要执行finally里面的语句
2)如果出现异常，则try块中异常发生后，try块剩下的语句不再执行。将执 行catch块中的语句，如果有finally，最后还需要执行finally里面的语句！