IO流（异常的处理）

IO流

概述

IO流，又叫输入输出流，当我们将内存中的数据写到硬盘上时，这个过程叫输出流（Output),当我们将硬盘上的数据读取到内存中时，叫做输入流（Input）。流本身是一个抽象概念，是 对数据传输的总称，也就是说，数据在设备键的传输，叫做流

重点：

明确操作是读还是写

使用何种类型的流

铺垫技术：

学习IO流之前，我们需要学习两个铺垫技术：一个是异常，一个是File类

**异常：**因为在介质传输数据会有很多问题，比如：找不到文件，文件格式错误，读写错误，我们需要知道当进入到这些问题时，如何去处理

**File：**流的操作会涉及很多的文件操作，所以我们也要学习与文件相关的类—File类

异常：

**概述：**程序出现 不正常的情况

分类：

程序异常：Throwable Throwable 类是 Java 语言中所有错误或异常的父类

严重问题----Error：我们不去处理，因为处理不了，比如：内存溢出问题

一般问题----Exception：

​ 编译时异常:除了RuntimeException的异常都是编译时异常，这种异常必须在程序执行前进行处理。

​ 运行时异常：RuntimeException，这个问题我们也不做处理。因为造成的原因多数是我们的逻辑不够严谨，需要我们去修改代码
案例：

public class ExceptionDemo {
public static void main(String[] args) {
//第一模块
int a = 10;
int b = 0;
System.out.println(a / b);
System.out.println("我是第二模块");
}
}

分析：

程序出现问题后，控制台打印错误信息：包括Exception包名+类名，错误的描述，错误出现的位置。这些对于异常的操作我们并没有做，而是JVM替我们做的。

所以，当我们不做任何异常处理时，我们的JVM会对异常执行一个默认的操作

异常处理：

方式：

try…catch…finally

throws

try…catch…finally

格式：

try{
//可能出现问题的代码
}catch(异常类名 变量名){
//针对异常的处理
}finally{
//释放资源
//它不是必须
}

**注意：

1.try里面包裹的代码越少越好，因为被try包裹的代码在执行时需要走异常处理机制，需要JVM给该机制分配额外的资源去管理代码，所以包裹越少，越节省资源

2.catch中必须有对异常的处理，哪怕时一句输出语句也可以，因为不做任何处理的话，相当于把异常隐藏了，而不是处理了

3.try结构中的语句，一但捕获到异常，剩下的代码不再执行，直接执行catch的代码

示例:

/**
* 多个异常的处理
*/
public class ExceptionDemo2 {
public static void main(String[] args) {
method();
System.out.println("程序执行完毕");
}
private static void method() {
int a = 10;
int b = 0;
try {
//System.out.println(a / b);
int[] c = {1, 2, 3};
System.out.println(c[4]);
} catch (ArithmeticException arithmeticException) {
System.out.println("除数不能为0");
// arithmeticException.printStackTrace();
} catch (ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException) {
System.out.println("数组越界了" );
}
}
}

/**
* 多个异常的处理
*/
public class ExceptionA {
public static void main(String[] args) {
method();
System.out.println("程序执行完毕");
}
//多个try...catch
public static void method() {
int a = 10;
int b = 0;
try {
System.out.println(a / b);
} catch (ArithmeticException arithmeticException) {
System.out.println("除数不能为0!");
}
try {
int[] c = {1, 2, 3};
System.out.println(c[4]);
} catch (ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException) {
System.out.println("出错了");
}
}
}

处理方式：

1.一个try，多个catch

​ a.如果异常类在继承体系结构中处于平级关系，他们呢的前后不影响执行结果

​ b.如果异常在继承体系结构中处于父子关系，则父类异常必须写在后面，否则子类异常不会被正常匹配到

2.多个try…catch

3.一个try…catch，catch中的类可以写Exception类，它可以用来匹配所有子类异常

JDK7新特性–异常处理

格式：

try{
//可能出现异常的代码
}catch(异常1 |异常2|...变量名){
//异常处理
}

public class ExceptionDemo3 {
public static void main(String[] args) {
method();
System.out.println("程序结束");
}
private static void method() {
int a = 10;
int b = 0;
int[] c = {1, 2, 3};
try {
System.out.println(a / b);
System.out.println(c[4]);
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println("出错了");
}
}
}

注意：

1.多个异常必须是平级关系

2.针对不同异常，处理方式一致

编译时异常和运行时异常

**编译时异常：**我们在执行程序，必须处理掉的异常，如果不处理，程序将不能编译正常

**运行时异常：**不需要我们显示处理，但是我们也可以使用try…catch处理

案例：

/**
* 编译时异常:必须通过异常处理，代码才能通过编译
*/
public class ExceptionDemo4 {
public static void main(String[] args) {
String day = "2020-11-29";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM--dd");
try {
Date date = sdf.parse(day);
} catch (ParseException e) {
e.printStackTrace();
}
}
}

Throwable

常用方法：

/**
* Throwable:
* public String getMessage():返回此 throwable 的详细消息字符串。
* public String toString():返回此 throwable 的简短描述。
*
组成：
*
此异常类的全路径类名
*
":"
*
调用此对象 getLocalizedMessage() 方法的结果
*
如果 getLocalizedMessage 返回 null，则只返回类名称。
* public void printStackTrace():获取异常类名和异常信息描述以及错误出现的位置
* public void printStackTrace(PrintStream s)：将此 throwable 及其追踪输出到指定的输出流。
*/

throws

在开发中，如果去调用别人写的代码，我们很难判断调用方法时是否会发生异常。针对这种情况，java允许在方法后面使用throws关键字对外声明该方法在使用过程中可能发生的异常，这样调用者在调用方法时，就明确知道该方法有异常，并必须处理掉异常，否则代码将无法通过编译。

格式

方法()throws 异常类名1，异常类名2，...

注意：

我们在调用方法时，如果不做异常处理，我们可以选择抛出（throws），直到main方法抛给JVM为止，这种情况，JVM就会采取默认处理方式处理异常，尽量不要在主方法抛出。

案例：

/**
* throws 演示案例
*/
public class ThrowsDemo {
public static void main(String[] args)
{
// method();
try {
method2();
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println("程序结束");
}
//
private static void method()throws ArithmeticException {
//
int a = 10;
//
int b = 0;
//
System.out.println(a / b);
//
}
private static void method2() throws ParseException {
String day = "2020-11-29";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM--dd");
Date date = sdf.parse(day);
}
}

根据演示案例，我们知道

​ 编译时异常抛出：调用者必须处理

​ 运行时异常抛出：调用者可以不处理

throws 和 throw

案例

/**
* throws 演示案例
*/
public class ThrowsDemo {
public static void main(String[] args)
{
// method();
method3();
//
try {
//
method2();
//
} catch (ParseException e) {
//
e.printStackTrace();
//
}
System.out.println("程序结束");
}
//
private static void method()throws ArithmeticException {
//
int a = 10;
//
int b = 0;
//
System.out.println(a / b);
//
}
private static void method2() throws ParseException {
String day = "2020-11-29";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM--dd");
Date date = sdf.parse(day);
}
private static void method3()throws ArithmeticException {
int a = 10;
int b = 1;
if (b == 0) {
throw new ArithmeticException();
} else {
System.out.println(a / b);
}
}
}

总结：

throw：

​ 1.方法体内，后面跟异常对象

​ 2.只能抛一个异常

​ 3.执行throw，表示一定有异常抛出

throws：

​ 1.方法声明上，后面跟异常类名

​ 2.可以抛多个异常，用，隔开

​ 3.throws，表示可能有异常抛出

finally

概述：

被finally包裹的代码一定会被执行，但是，JVM退出

面试题

1.final，finally，finalize的区别？

final：它表示最终的，可以 类，成员变量，成员方法

​ 类：表示最终类，不能被继承

​ 成员变量：常量，不能被赋值

​ 成员方法：最终方法，不能被重写

finally:它是 异常处理中try…catch…finally结构的一部分，这部分代码最终都会被执行，除了JVM退出。它一般用于释放资源

自定义异常：

注意事项：

1.自定义异常类必须继承Exception或RUntimeException

2.在其有参构造中，一定要指定访问父类的有参构造，这样才能把异常信息打印到控制台上

异常注意事项：

1.子类在重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类异常

2.如果父类抛出多个异常，子类重写父类方法时，只能抛出相同的异常或父类异常的子集，并且子类不能抛出父类中没有抛出的异常

3.如果被重写的方法没有抛出编译时异常，那么子类绝对不能抛出任何编译时异常，如果重写方法中有异常需要处理，只能选择try-catch，不能throws

最后

以上就是合适石头为你收集整理的IO流（异常的处理）的全部内容，希望文章能够帮你解决IO流（异常的处理）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。