既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上大数据知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
⑥ ClassCastException【RuntimeException】
ClassCastException : 类型转换异常
public class UncheckException {
public static void main(String[] args) {
Object o = 3.14F;
// ClassCastException 类型转换异常
int i = (int) o;
}
}
三、try-catch 处理异常
📜 程序产生了异常,有个专业的术语:抛出了异常
📜 无论是检查型异常,还是非检查型异常,只要开发者没有主动去处理它,都会导致 Java 程序终止运行
📜 处理异常有2种方式:
✒️ ①
try-catch
【捕获异常】
✒️ ②throws
【往上抛异常】
(1) try-catch
📜 可能抛出异常的代码放try
代码块中
📜 catch
代码块用于捕获不同类型的异常,并对异常做出处理
🌼
catch
代码块中的代码不一定执行,除非抛出了与之相应的(相匹配的)异常
📜 父类型异常必须写在子类型异常的后面(否则会报错)
try-catch 处理异常的格式:
public class TryCatch {
public static void main(String[] args) {
System.out.println("不可能抛异常的代码1");
try {
// try 代码块中放可能抛异常的代码
System.out.println("该行代码可能抛异常, 如果抛出了异常, 下面的一行代码不会被执行");
System.out.println("如果上面的代码抛出了异常, 本行代码不执行");
} catch (NullPointerException e) {
// 当抛出【空指针异常】的时候会来到该代码块
System.out.println("抛出了【空指针异常】");
} catch (ClassCastException e) {
// 当没有抛出【空指针异常】
// 但抛出【类转换异常】的时候会来到该代码块
System.out.println("抛出了【类转换异常】");
} catch (ArrayIndexOutOfBoundsException e) {
// 当没有抛出【空指针异常】和【类转换异常】
// 但抛出【数组下标越界异常】的时候会来到该代码块
System.out.println("抛出了【数组下标越界异常】");
} catch (Throwable t) { // Throwable 是所有异常的父类, 只能放子异常的后面
// 上面的异常没有抛出
// 且的确抛出了异常, 会来到该代码块
System.out.println("抛出了异常");
}
System.out.println("不可能抛异常的代码2");
}
}
(2) Throwable 常用方法
看下面代码,思考打印结果:
public class TryCatch {
public static void main(String[] args) {
try {
long[] longs = new long[10\_0000\_0000];
} catch (OutOfMemoryError e) {
// output: java.lang.OutOfMemoryError: Java heap space
System.out.println("\n" + e);
// output: Java heap space
System.out.println(e.getMessage());
// 红色字体, 带异常行定位(控制台输出堆栈信息)
e.printStackTrace();
}
}
}
🌼 直接打印异常对象【e】:异常类型(
java.lang.OutOfMemoryError
)和异常信息(Java heap space
)
🌼 打印异常对象【e】的 getMessage() 方法的返回值:异常信息(Java heap space
)
🌼 直接调用异常对象【e】的 printStackTrace() 方法 【常用】
🌼 有红色打印信息不代表程序退出了
(3) 一个 catch 捕获多种类型的异常
🌼 从 Java7 开始,当个
catch
可以捕获多种类型的异常
🌼 如果并列的几个异常类型之间存在父子关系,保留父类型即可
🌼 此时异常对象【e】是隐式 final 的
public class TryCatch {
public static void main(String[] args) {
try {
System.out.println("啦啦啦");
// 可能产生异常的代码
} catch (OutOfMemoryError | NullPointerException | IndexOutOfBoundsException e) {
// 产生 OutOfMemoryError 异常、NullPointerException 异常
// 或 IndexOutOfBoundsException 异常的时候都会来到该代码块
if (e instanceof OutOfMemoryError) {
System.out.println(e);
} else if (e instanceof NullPointerException) {
System.out.println(e.getMessage());
} else { // 是 IndexOutOfBoundsException 异常的时候
e.printStackTrace();
}
}
}
}
(4) Exercise
① 第1题
思考下面的代码的打印结果是什么:
public class Exercise {
public static void main(String[] args) {
System.out.println(1);
Integer integer = new Integer("啦啦啦");
// 上一行代码抛异常了, 程序终止, 下面的代码不会执行
System.out.println(2);
}
}
② 第2题
思考下面的代码的打印结果是什么:
public class Exercise {
public static void main(String[] args) {
int n = 6;
try {
// 6
System.out.println(n++);
Double d = new Double("哈哈哈");
System.out.println(++n);
System.out.println(d);
} catch (NumberFormatException e) {
e.printStackTrace();
// 7
System.out.println(n++);
}
// 8
System.out.println(n);
}
}
③ 第3题
思考下面的代码的打印结果是什么:
public class Exercise {
public static void main(String[] args) {
int num = 1;
Integer integer1 = new Integer("111");
// 111
System.out.println(num++ + --integer1);
Integer integer2 = new Integer("嘻嘻嘻");
System.out.println(integer1 + integer2);
}
}
④ 第4题
思考下面的代码的打印结果是什么:
public class Exercise {
public static void main(String[] args) {
Integer[] ints = {111, null, 222};
for (int integer : ints) {
// 自动拆箱
// ints[n].intValue();
// 当 ints[n] 为 null 的时候就抛 NullPointerException 异常
System.out.println(integer);
}
// output: 111
}
}
(5) finally
✏️ try
或catch
代码块中的代码执行完毕后,一定会执行finally
代码块中的代码
✏️ finally
可以和try-catch
搭配使用,也可以和try
搭配使用
✏️ 作用:在finally
中编写关闭、释放资源的代码(如:关闭文件)
finally 使用格式1:
public class FinallyTest {
public static void main(String[] args) {
try {
System.out.println(1);
} catch (NullPointerException e) {
System.out.println(11);
} finally {
System.out.println(111);
}
/\*
output:
1
111
\*/
}
}
finally 使用格式2:
public class FinallyTest {
public static void main(String[] args) {
try {
System.out.println(222);
} finally {
System.out.println(555);
}
/\*
output:
222
555
\*/
}
}
往文件写数据的案例:
public class FinallyTest {
public static void main(String[] args) {
String file = "C:\\Users\\34657\\Desktop\\fileTest.txt";
PrintWriter pw = null;
try {
// 创建打印写入器(类似打开文件)
pw = new PrintWriter(file);
// 往文件中写入内容【愿你万事顺心!】
pw.write("愿你万事顺心!");
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
// 关闭文件资源
assert pw != null;
pw.close();
}
}
}
(6) finally 细节
✏️ 如果在执行 try 或 catch 的时候,JVM 退出或当前线程被中断(杀死),finally 代码块不会执行
✏️ 如果在 try 或 catch 中使用了 return、break、continue 等提前结束的语句的话,finally 会在 return、break、continue 之前执行
思考下面代码的执行结果:
public class FinallyTest {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
try {
System.out.println(i + "\_try\_1");
// continue: 终止此次循环, 继续下次循环
if (i == 2) continue;
System.out.println(i + "\_try\_2");
} finally {
System.out.println(i + "\_finally");
}
}
}
}
思考下面代码的执行结果:
public class FinallyTest {
public static void main(String[] args) {
// 3
// 77
// 11
System.out.println(t());
}
private static int t() {
try {
new Integer("好");
System.out.println(1);
return 2;
} catch (Exception e) {
System.out.println(3);
return 11;
} finally {
System.out.println(77);
}
}
}
四、throws 处理异常
(1) throws
✒️ throws
:将异常抛给上层方法
✒️ main 方法通过 throws 把异常抛给 JVM 后,程序会终止运行
✒️ 如果 throws 后面的异常类型存在父子关系,保留父类型即可
✒️ 可以一部分异常通过 try-catch 处理,一部分异常通过 throws 处理
public class ThrowsTest {
public static void main(String[] args) throws ClassNotFoundException {
// 通过 throws 把异常抛给 JVM
m1();
}
private static void m1() throws ClassNotFoundException {
// 通过 throws 把异常抛给上层方法
m2();
}
private static void m2() throws ClassNotFoundException {
// 通过 throws 把异常抛给上层方法
m3();
}
private static void m3() throws ClassNotFoundException {
// 通过 throws 把异常抛给上层方法
Class.forName("com.oracle.gq.Hello.java");
}
}
(2) throws 细节
✒️ 有继承关系的时候,子类重写父类的方法抛出的异常不能大于父类方法抛出的异常(必须是父类方法抛出的异常的子类型)
✒️ 父类方法 throws 了异常,子类重写父类的方法可以不 throws 异常
✒️ 父类方法没有 throws 异常,则子类重写父类的方法一定不能 throws 异常
public class Person {
public void test1() {
}
public void test2() throws IOException {
}
public void test3() throws IOException {
}
public void test4() throws IOException {
}
}
class Student extends Person {
// 父类的 test1 没有 throws 异常, 则子类重写父类的 test1 也不能 throws 异常
@Override
public void test1() {
}
// 父类的 test2 有 throws 异常, 但子类重写父类的 test2 可以不 throws 异常
@Override
public void test2() {
}
// 父类的 test3 抛出了 IOException 异常, 子类重写父类的 test3 可以抛出和父类一样的异常
@Override
public void test3() throws IOException {
}
// 父类的 test4 抛出了 IOException 异常, 子类重写父类的 test4 可以抛出父类异常的子异常
@Override
public void test4() throws FileNotFoundException {
}
}
五、throw 主动抛出异常
📜 使用throw
可以抛出一个新建的异常
🌼 问题比较严重的时候抛出检查型异常
🌼 问题不哪么严重的时候抛出非检查型异常
public class Person {
public Person(String name) throws Exception {
if (name == null || "".equals(name))
// Exception 是检查型异常
throw new Exception("name must not be empty.");
}
}
class Student {
public Student(String name) {
if (name == null || name.length() == 0)
// IllegalArgumentException 是非检查型异常
throw new IllegalArgumentException("name must not be empty");
}
}
六、自定义异常
(1) 自定义检查型异常
📖 若希望开发者重视这个异常、认真处理这个异常,则自定义检查型异常
📖 创建一个类(异常类),并继承 Exception
即可创建一个自定义的检查型异常
📖 检查型异常使用起来比较麻烦(相对非检查型异常来说)
/\*\*
\* @author 庆医
\* @describe 自定义检查型异常
\*/
public class EmptyNameException extends Exception {
public EmptyNameException() {
super("name must not be empty!");
}
}
(2) 自定义非检查型异常
📖 若不严格要求开发者去处理这个异常,则定义为非检查型异常
📖 从创建一个类(异常类),并继承 RuntimeException
即可创建一个自定义的非检查型异常
/\*\*
\* @author 庆医
\* @describe 自定义非检查型异常
\*/
public class IllegalAgeException extends RuntimeException {
public IllegalAgeException(int age) {
super("The age you provided is " + age + " [年龄必须大于零]");
}
}
使用自定义异常:
public class Person {
private int age;
private String name;
public Person(String name) throws EmptyNameException {
if (name == null || "".equals(name))
throw new EmptyNameException();
this.name = name;
}
public Person(int age) {
if (age < 1) {
throw new IllegalAgeException(age);
}
this.age = age;
}
}
七、使用异常的好处
🔑 将错误处理代码和普通代码区分开
🔑 可以将错误信息传播到调用堆栈中
🔑 可以对错误类型进行区分和分组
八、案例(编写断言类)
📖 断言(assertion)作用:验证软件开发者对某一功能预期的结果
🌼 当程序执行到断言的位置时,会对软件开发者希望测试的功能进行测试。若断言不为真,程序会中止执行(抛异常);若断言为真,不会抛异常,直接往后执行。
🌼 下面的代码实现了一个简单的计算器类
🌼 用于计算两个数的和,和计算两个数的商
🌼 当计算两个数的商的时候,必须保证第二个参数不为零(在此自定义异常类 DivideException 对第二个参数进行校验)
🌼 考虑到 DivideException 异常类可能只在本类中使用,不会被其他地方复用,所以把它定义为静态嵌套类
🌼 博主认为除法运行的时候第二个参数若为零的话会非常严重,所以把 DivideException 定义为了检查型异常
/\*\*
\* @author 庆医
\* @describe 简单计算器(用于测试断言类、静态嵌套类、自定义异常)
\*/
public class SimpleCalculator {
private static int sum(int n1, int n2) {
return n1 + n2;
}
private static double divide(double n1, double n2) throws DivideException {
if (n2 == 0) throw new DivideException();
return n1 / n2;
}
static class DivideException extends Exception {
DivideException() {
super("进行除法运算的时候, 第二个参不能为零");
}
}
}
🌼 如何测试上面的代码的正确性?
🌼 您可能会像下面的代码一样,调用方法并查看计算结果进行测试
🌼 这种测试方式是比较耗时和不高效的
🌼 业内比较专业的测试方式是:使用断言类
🌼 调用断言类中的方法,并输入您预期的结果作为参数。假如符合预期的结果,不会抛异常,代码继续往下走;如果不符合预期的结果,抛异常
🌼 下面就来写一个断言类【Asserts】
public class TestDemo {
public static void main(String[] args) {
// result is 7
System.out.println("result is " + SimpleCalculator.sum(2, 5));
try {
double divResult = SimpleCalculator.divide(10, 2);
// result is 5.0
System.out.println("result is " + divResult);
} catch (SimpleCalculator.DivideException e) {
e.printStackTrace();
}
}
}
(1) 版本1
断言类实现:
/\*\*
![img](https://img-blog.csdnimg.cn/img_convert/2267ed967c67b6cfc2cbebf6ba1cdd9a.png)
![img](https://img-blog.csdnimg.cn/img_convert/c89294222ac62e5f7eb236a9b9da0300.png)
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友,可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**
{
// result is 7
System.out.println("result is " + SimpleCalculator.sum(2, 5));
try {
double divResult = SimpleCalculator.divide(10, 2);
// result is 5.0
System.out.println("result is " + divResult);
} catch (SimpleCalculator.DivideException e) {
e.printStackTrace();
}
}
}
(1) 版本1
断言类实现:
/\*\*
[外链图片转存中...(img-3NlxUonT-1715316899480)]
[外链图片转存中...(img-XYvzTAD5-1715316899481)]
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友,可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**