目录
1、IO流概述及其前奏
IO流概述
IO流用来处理设备之间的数据传输
上传文件和下载文件，复制文件
IO流前奏
讲解IO流之前为什么先讲解异常和File类呢?
因为File表示的是IO流将来要操作的文件，所以我们需要学习File类。
而常见操作文件无非就是上传文件和下载文件，在这个操作的过程中可能出现问题，
出现问题后，我们需要对对应的代码进行处理。所以我们需要学习异常。
2、异常的概述和分类
异常的概述: 异常就是Java程序在运行过程中出现的错误
异常的继承体系
异常的基类: Throwable
严重问题: Error，不予处理,因为这种问题一般是很严重的问题,比如: 内存溢出
非严重问题: Exception，这个由我们自己来处理
异常分为：编译期异常和运行期异常。
编译时异常: 非RuntimeException
编译期异常,发生在编译期间，必须解决，不解决程序无法运行 非 RuntimeException 类，及其子类
运行时异常: RuntimeException
运行期异常，发生在运行期间，你可以解决，也可以不解决 untimeException 类，及其子类
3、JVM默认是如何处理异常的
JVM默认是如何处理异常的
main函数收到这个问题时,有两种处理方式:
a:自己将该问题处理,然后继续运行
b:自己没有针对的处理方式,只有交给调用main的jvm来处理
jvm有一个默认的异常处理机制,就将该异常进行处理.
并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上,同时将程序停止运行
4、try...catch的方式处理异常---1
异常处理的两种方式
a: try…catch…finally
b: throws
try...catch处理异常的基本格式
try {
可能出现问题的代码 ;
}catch(异常名 变量名){
针对问题的处理 ;
}finally{
释放资源;
}变形格式:
try {
可能出现问题的代码 ;
}catch(异常名 变量名){
针对问题的处理 ;
}多个异常处理：
try {
可能出现问题的代码 ;
}catch(异常名1 变量名1){
对异常的处理方式 ;
}catch (异常名2 变量名2){
对异常的处理方式 ;
}....
注意事项:
a: try中的代码越少越好
b: catch中要做处理,哪怕是一条输出语句也可以.(不能将异常信息隐藏)
c: finally{}中不管try有没有遇到异常，finally里面的代码都会执行。我们可有一些善后工作在这里面处理
d: 能明确的尽量明确，不要用大的来处理。
e: 平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面
package org.westos.demo;
public class MyTest1 {
public static void main(String[] args) {
/*
* 如果有多个可能出现的异常，你就使用多个 catch来进行捕获
* 到最后，再用一个大异常捕获
* 也就是说能明确的异常，尽量明确，不要只用一个大的异常一捕了之
* 1:能明确的尽量明确，不要用大的来处理。
* 2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。
* try里面尽量只放，有可能出现问题的代码
* */
int a=10;
int b=0;
int[] arr={1,2,3};
int[] arr2=null;
//自己捕获异常来处理
//try{里面放的是，有可能会出现异常的代码}catch(异常类 名字){处理异常代码}
//一旦我们try 里面代码出现了我们所捕获的异常，catch就会执行。
try{
System.out.println(a/b);//ArithmeticException
System.out.println(arr[5]);//ArrayIndexOutOfBoundsException
System.out.println(arr2[0]);//NullPointerException
}catch (ArithmeticException e){
System.out.println("除数为0了");
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("角标越界了");
}catch (NullPointerException e){
System.out.println("对象为null了");
}catch (Exception e){//出现了子父关系，父必须在后面
System.out.println("其他异常");
}
}
}
5、JDK7针对多个异常的处理方案
JDK1.7中对多个catch的变形格式
try {
可能出现问题的代码 ;
}catch(异常名1 | 异常名2 | .... 变量名){
对异常的处理方案 ;
}
好处: 就是简化了代码
弊端: 对多个异常的处理方式是一致的
注意事项:
a: 多个异常之间只能是平级的关系,不能出现子父类的继承关系
b: 处理方式是一致的。(实际开发中，好多时候可能就是针对同类型的问题，给出同一个处理)
package org.westos.demo;
public class MyTest2 {
public static void main(String[] args) {
int a=10;
int b=2;
int[] arr={1,2,3};
int[] arr2=null;
try{
System.out.println(a/b);//ArithmeticException
System.out.println(arr[5]);//ArrayIndexOutOfBoundsException
System.out.println(arr2[0]);//NullPointerException
}catch (ArithmeticException | ArrayIndexOutOfBoundsException| NullPointerException e){
if(e instanceof ArrayIndexOutOfBoundsException){
System.out.println("角标越界了");
}
//System.out.println("异常");
}
}
}
6、编译期异常和运行期异常的区别
编译期异常和运行期异常的区别
Java中的异常被分为两大类：编译时异常和运行时异常。
所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常
编译时异常: Java程序必须显示处理，否则程序就会发生错误，无法通过编译
运行时异常: 无需显示处理，也可以和编译时异常一样处理
7、Throwable的几个常见方法
Throwable的几个常见方法
a:getMessage(): 获取异常信息，返回字符串。
b:toString(): 获取异常类名和异常信息，返回字符串。
c:printStackTrace(): 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void
public class MyTest2 {
public static void main(String[] args) {
int i=10;
int j=0;
try {
System.out.println(i / j);
}catch (Exception e) {
//在处理逻辑里面不要空处理，哪怕你只打印一句话
e.printStackTrace(); //打印异常的详细信息
System.out.println(e.getMessage());
System.out.println(e.toString());
}
System.out.println("下面的代码");
}
}8、throws的方式处理异常
throws的方式处理异常
定义功能方法时，需要把出现的问题暴露出来让调用者去处理。
那么就通过throws在方法上标识。
public class MyTest {
public static void main(String[] args) {
try {
test();
}catch (ParseException e) {
System.out.println("解析失败");
}
System.out.println("下面的代码");
System.out.println("下面的代码");
System.out.println("下面的代码");
}
public static void test() throws ParseException{
//编译期异常：发生在编译期间， 非 RuntimeException及其子类，编译期异常必须处理
String str = "2020-10=10";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = simpleDateFormat.parse(str);
//对于编译期异常我们有两种处理方式：1.将异常抛出，谁调用谁处理，俗称甩锅。
//2.自己捕获处理，一般你抛出到main就不要抛出了，自己捕获处理
}
}9、throw的概述以及和throws的区别
throw的概述:
在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出
throws和throw的区别
a:throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
b:throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
这个异常对象可以是编译期异常对象,可以是运行期异常对象
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常
10、finally关键字的特点及作用
finally的特点
被finally控制的语句体一定会执行(前提 jvm没有停止)
特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
finally的作用: 用于释放资源，在IO流操作和数据库操作中会见到
public class MyTest2 {
public static void main(String[] args) {
int a = 10;
int b = 0;
Scanner scanner =null;
try {
//System.out.println(a / b);
scanner = new Scanner(System.in);
System.out.println("请录入一个整数");
int i = scanner.nextInt();
} catch (ArithmeticException e) {
e.printStackTrace();
}catch(InputMismatchException e){
e.printStackTrace();
} finally {
System.out.println("不管你try有没有遇到异常，finally里面的代码都会执行。我们可有一些善后工作在这里面处理");
if (scanner != null) {
scanner.close(); //释放资源
}
}
}
}final,finally和finalize的区别
* final: 是一个状态修饰符, 可以用来修饰类 , 变量 , 成员方法.
被修饰的类不能被子类继承, 修饰的变量其实是一个常量不能被再次赋值
* 修饰的方法不能被子类重写
* finally:用在try...catch...语句中 , 作用: 释放资源 . 特点: 始终被执行(JVM不能退出)
* finalize: Obejct类中的一个方法,用来回收垃圾
11、自定义异常概述和基本使用
为什么需要自定义异常:
因为在以后的开发过程中,我们可能会遇到各种问题,
而Jdk不可能针对每一种问题都给出具体的异常类与之对应.
为了满足需求,我们就需要自定义异常.
举例：考试成绩必须在0-100之间，不满足就产生异常。
自定义异常类：
package org.westos.demo2;
public class ScoreExcption extends RuntimeException {
//自定义异常类，把他纳入到Java异常体系中
public ScoreExcption(String message) {
super(message);
}
}
测试代码：
package org.westos.demo2;
import java.util.Scanner;
public class MyTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的成绩0--100");
int score = sc.nextInt();
int i = intputScore(score);
System.out.println(i);
}
private static int intputScore(int score) {
if(score>=0&&score<=100){
return score;
}else{
//一旦遇到此种情况，可以抛出我自定义的异常
throw new ScoreExcption("成绩不合法");
}
}
}
输出结果：
12、异常的注意事项及如何使用异常处理
A:异常注意事项(针对编译期异常)
a:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类，或者子类不抛出异常也是可以的。(父亲坏了,儿子不能比父亲更坏)
b:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常，或者子类不抛出异常也是可以的。
c:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
B:如何使用异常处理
原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
区别:
后续程序需要继续运行就try
后续程序不需要继续运行就throws
如果JDK没有提供对应的异常，需要自定义异常。