《java学习笔记》之异常处理机制

2401_84048149

于 2024-04-04 19:10:07 发布

阅读量1k

点赞数 29

分类专栏：程序员文章标签： java 学习笔记

本文链接：https://blog.csdn.net/2401_84048149/article/details/137380307

版权

程序员专栏收录该内容

458 篇文章 2 订阅

订阅专栏

本文详细介绍了Java中的异常处理机制，包括异常的形式、如何处理异常（如继续上抛和try-catch捕捉）、try-catch的理解，以及如何自定义异常。通过实例演示了如何使用try…catch…finally结构确保资源管理和异常追踪。

摘要由CSDN通过智能技术生成

当程序出现了不正常的情况

java把异常信息打印到了控制台，供程序员参考，程序员看到异常信息后，可以对程序进行修改
让程序更加健壮，不会因为异常就停止

二.异常处理机制的基本语法

2.1 异常的形式

public class Test01 {

public static void main(String[] args) {

//异常在java以类的形式存在

//通过"异常类"实例化"异常对象"

NullPointerException nullPointerException =new NullPointerException(“空指针异常”);

System.out.println(nullPointerException);//java.lang.NullPointerException: 空指针异常

ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException =new ArrayIndexOutOfBoundsException(“数组下标越界异常”);

System.out.println(arrayIndexOutOfBoundsException);//java.lang.ArrayIndexOutOfBoundsException: 数组下标越界异常

//mian方法中调用dosome()方法

//因为dosome()方法上声明有：throws ClassNotFoundException

//我们在调用dosom()方法时必须对这种异常进行预先处理

//如果不处理：编译器报错

//编译器报错信息：Error:(19, 15) java: 未报告的异常错误java.lang.ClassNotFoundException; 必须对其进行捕获或声明以便抛出

//dosome();

dosome();

//有两种方法：

//第一种：继续往上抛，因为是main方法调用的，所以在main方法上声明

//第二种方法：使用try-catch对异常进行捕捉

}

//这个方法抛出了一个异常

dosom方法在方法声明的时候使用了 throws ClassNotFoundException
这个代码表示dosome()方法在执行的时候，有可能出现ClassNotFoundException异常
叫做类没找到异常，这个异常的父类是Exception，所以ClassNotFoundException是编译时异常
*/

public static void dosome() throws ClassNotFoundException{

}

2.2 怎么处理异常

public class Test02 {

//方法一：继续往上抛，谁调用，谁声明，抛给调用者

//一般不建议在main上方上使用throws，因为这个异常一旦发生了，一定会上抛给JVM，JVM只能终止

//异常处理机制的作用就是增强程序的健壮性。做到异常发生了，也不影响程序的执行

//所以建议main方法的异常建议使用try…catch进行捕捉，就不要上抛了

//public static void main(String[] args) throws ClassNotFoundException{

public static void main(String[] args) {

//第二种：try-catch 捕捉

//捕捉等于把异常拦下了，异常真正的解决了(调用者是不知道的)

try {

dosome();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

public static void dosome() throws ClassNotFoundException{

}

2.3 try-catch理解

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.lang.reflect.Field;

public class Test03 {

public static void main(String[] args) {

System.out.println(“main begin”);

//这里使用了try - catch 所以main方法不用再抛异常了

try {

//先执行try，如果有异常就执行 catch

m1();

} catch (Exception e) {//e是一个变量名

//这个分支可以使用e应用，e存储了new出来的异常的内存地址

//catch捕捉后继续的分支

e.printStackTrace();

}

//try…catch 把异常抓住后，这里的代码会继续执行

System.out.println(“main over”);

}

public static void m1() throws Exception {

System.out.println(“m1 begin”);

//这里报错是因为m2抛出了异常，m1调用就要对异常进行处理

m2();

System.out.println(“m1 over”);

}

//抛下面几个异常可以 Exception 是 IOException的父类 IOException是 FileNotFoundException的父类

public static void m2() throws Exception {

//public static void m2() throws IOException {

//public static void m2() throws FileNotFoundException {

System.out.println(“m2 begin”);

//这里报错是因为m3抛了异常，m2调用，要对异常进行处理

m3();

System.out.println(“m2 over”);

}

public static void m3 () throws FileNotFoundException {

System.out.println(“m3 begin”);

new FileInputStream(“D:\day25课堂笔记.txt”);

//如果上面一行代码抛异常了，这里是不会执行的

System.out.println(“m3 over”);

}

异常对象有两个重要的方法：

    String string = exception.getMessage;    获取异常简单描述学习

      exception.printStackTrace               打印异常追踪的堆栈信息

public class Test04 {

public static void main(String[] args) {

//这里只是new了异常对象，没有抛出，JVM只是认为这是一个简单的对象类

NullPointerException nullPointerException1 =new NullPointerException();

NullPointerException nullPointerException2 =new NullPointerException(“空指针异常”);

System.out.println(nullPointerException1.getMessage());//null

System.out.println(nullPointerException2.getMessage());//空指针异常

System.out.println(nullPointerException1);//java.lang.NullPointerException

System.out.println(nullPointerException2);//java.lang.NullPointerException: 空指针异常

//打印异常堆栈信息

//java后台打印异常堆栈信息的时候，采用了异步线程的方式打印的

//java.lang.NullPointerException

// at caopeng.javase.test.Test04.main(Test04.java:10)

nullPointerException1.printStackTrace();

//java.lang.NullPointerException: 空指针异常

// at caopeng.javase.test.Test04.main(Test04.java:11)

nullPointerException2.printStackTrace();//

//这个在异常信息前输出

System.out.println(“hahaha”);

try {

m1();

} catch (FileNotFoundException e) {

//打印异常堆栈信息

//在实际开发当中，建议使用这个

//这行代码要写上，不然出错了都不知道

e.printStackTrace();

//怎么看异常信息，怎么快速调试？

// 从上往下看，SUN写的就不用看了

/*java.io.FileNotFoundException: C:\Users\A556U\Desktop\文\day34-作业.txt (系统找不到指定的路径。)

at java.base/java.io.FileInputStream.open0(Native Method)

at java.base/java.io.FileInputStream.open(FileInputStream.java:219)

at java.base/java.io.FileInputStream.(FileInputStream.java:157)

at java.base/java.io.FileInputStream.(FileInputStream.java:112)

at caopeng.javase.test.Test04.m3(Test04.java:56)

at caopeng.javase.test.Test04.m2(Test04.java:52)

at caopeng.javase.test.Test04.m1(Test04.java:48)

at caopeng.javase.test.Test04.main(Test04.java:40)*/

}

private static void m1() throws FileNotFoundException {

m2();

}

private static void m2() throws FileNotFoundException {

m3();

}

private static void m3() throws FileNotFoundException {

new FileInputStream(“C:\Users\A556U\Desktop\文\day34-作业.txt”);

}

2.4 try…catch…finally

public class Test05 {

public static void main(String[] args){

FileInputStream fileInputStream = null;

//捕捉异常

try {

fileInputStream =new FileInputStream(“D:\day25课堂笔记.txt”);

//开始读文件

System.out.println(“开始读文件”);

String s = null;

//这里肯定会抛空指针异常

s.toString();

//那么这里的流就关闭不了了，这样会占用内存

//fileInputStream.close();

System.out.println(“这里会执行吗”);//不会输出

} catch (FileNotFoundException e) {

e.printStackTrace();

}catch (NullPointerException e){

System.out.println(“空指针异常”);

e.printStackTrace();

}

finally {

//finally字句必须和try一起出现，不能单独编写

//在finally后面的语句块一定会执行，即使try中出现异常也会正常运行

System.out.println(“finally 语句块执行”);

try {

fileInputStream.close();

} catch (IOException e) {

e.printStackTrace();

}

2.5 关于finally

//关于finally

public class Test06 {

public static void main(String[] args) {

//没有catch，只有try 和finally

try{

System.out.println(“try…”);

return;

}finally {

System.out.println(“finally”);

}

//Unreachable statement

//不会执行的语句

//System.out.println(“会执行吗”);

try…

finally

//这表明了finally一定会执行

//顺序应该是先try，然后看到return，就跳到finally，finally执行完再到return

}

三.自定义异常

3.1怎么自定义异常

/*怎么定义异常？

两步：
第一步：编写一个类继承Exception或者RunException
第二步：提供两个构造方法，一个无参的，一个有参的*/

//死记硬背

public class Test07 extends Exception{

//构造方法，无参

public Test07() {

}

//构造方法，有参

public Test07(String message) {

super(message);

}

public class Test08 {

public static void main(String[] args) {

//这里只是尝试new出自定义异常，未抛出

/*Test07 test07 =new Test07();

System.out.println(test07);//caopeng.javase.test.Test07

//打印异常的简单消息

System.out.println(test07.getMessage());//null

//打印异常的堆栈信息

test07.printStackTrace();

//caopeng.javase.test.Test07

// at caopeng.javase.test.Test08.main(Test08.java:6)*/

Test07 test07 =new Test07(“自定义异常”);

System.out.println(test07);//caopeng.javase.test.Test07: 自定义异常

//打印异常的简单消息

System.out.println(test07.getMessage());//自定义异常

//打印异常的堆栈信息

test07.printStackTrace();

//caopeng.javase.test.Test07: 自定义异常

// at caopeng.javase.test.Test08.main(Test08.java:16)

}

3.2 抛自定义异常`

如果不自定义异常

1、这个栈可以存储java中的任何引用类型的数据。

2、在栈中提供push方法模拟压栈。（栈满了，要有提示信息。）

3、在栈中提供pop方法模拟弹栈。（栈空了，也有有提示信息。）

4、编写测试程序，new栈对象，调用push pop方法来模拟压栈弹栈的动作。

5、假设栈的默认容量为10.（注意无参构造方法的编写方式）

public class MyStack {

//这个栈可以存储java中的任何引用类型的数据。

//Object类的数组

//假设栈的默认容量为10

private Object[] objects;

//栈帧

//每添加一个元素就+1

//每弹出一个元素就-1

private int index = -1;//表示栈帧指向了顶部元素，就是多加了一个头指针，让栈不为空，因为没有元素的时候，栈帧指向0是不太恰当的

//构造方法

public MyStack() {

this.objects = new Object[10];

}

public MyStack(Object[] objects) {

this.objects = objects;

}

//set 和 get 方法

public Object[] getObjects() {

return objects;

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

Java高频面试专题合集解析：

阿里Java岗面试百题：Spring 缓存 JVM 微服务数据库 RabbitMQ等

当然在这还有更多整理总结的Java进阶学习笔记和面试题未展示，其中囊括了Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发等架构资料和完整的Java架构学习进阶导图！

阿里Java岗面试百题：Spring 缓存 JVM 微服务数据库 RabbitMQ等

更多Java架构进阶资料展示

阿里Java岗面试百题：Spring 缓存 JVM 微服务数据库 RabbitMQ等

阿里Java岗面试百题：Spring 缓存 JVM 微服务数据库 RabbitMQ等
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！**

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

Java高频面试专题合集解析：

[外链图片转存中…(img-HIo01ezG-1712228995594)]

[外链图片转存中…(img-DQ6S9xkK-1712228995594)]

更多Java架构进阶资料展示

[外链图片转存中…(img-sIfyT1lj-1712228995594)]

[外链图片转存中…(img-AeiyJjSj-1712228995594)]

[外链图片转存中…(img-u8NnzyfR-1712228995595)]
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

2401_84048149

关注

29
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录