初始Java JavaSE 异常 认识异常

public static void main(String[] args) {

int[] nums = {1,2,3,4};

try {

nums = null;

System.out.println(“hehe”);

System.out.println(nums[5]);

System.out.println(“heihei”);

}catch (ArrayIndexOutOfBoundsException e){

e.printStackTrace();// 打印出现异常的调用栈

System.out.println(“数组越界异常”);

}catch (NullPointerException e){

e.printStackTrace();

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

}finally {

System.out.println(“finally”);

}

}

运行结果:

结论: 无论是否存在异常, finally 中的代码一定都会执行到.

代码示例5: finall 保证会执行到 Scanner 的 close 方法

---

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

try{

int n = sc.nextInt();

System.out.println(10 / n);

}catch (InputMismatchException e){

e.printStackTrace();

System.out.println(“输入错误”);

}catch (ArithmeticException e){

e.printStackTrace();

System.out.println(“算术异常,可能0作为了除数”);

}finally {

sc.close();

System.out.println(“finally执行了”);

}

运行结果:

代码示例6:使用 try 负责回收资源

---

public static void main(String[] args) {

try(Scanner sc = new Scanner(System.in)){

int n = sc.nextInt();

System.out.println(10 / n);

}catch (InputMismatchException e){

e.printStackTrace();

System.out.println(“输入错误”);

}catch (ArithmeticException e){

e.printStackTrace();

System.out.println(“算术异常,可能0作为了除数”);

}finally {

System.out.println(“finally执行了”);

}

}

运行结果:

代码示例7:如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递

---

public static void func(int n) {

System.out.println(10 / n);

}

public static void main(String[] args) {

try {

func(0);

} catch (ArithmeticException e) {

e.printStackTrace();

}

System.out.println(“1234455”);

}

运行结果:

代码示例8: 如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM 处理, 程序就会异常终止(和我们最开始 未使用 try catch 时是一样的).

---

public static void func(int n) {

System.out.println(10 / n);

System.out.println(“!23ggggg”);

}

public static void main(String[] args) {

func(0);

System.out.println(“!234”);

}

运行结果:

代码示例9:尽量避免在finally当中写return

---

public static int func1() {

int a = 10;

try {

return a;

}catch (ArithmeticException e){

e.printStackTrace();

}finally {

return 20;

}

}

public static void main(String[] args) {

int a = func1();

System.out.println(a);

}

运行结果:

异常处理流程

---

• 程序先执行 try 中的代码

• 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.

• 如果找到匹配的异常类型, 就会执行 catch 中的代码

• 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.

• 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).

• 如果上层调用者也没有处理的了异常, 就继续向上传递.

• 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.

抛出异常

---

除了 Java 内置的类会抛出一些异常之外, 程序猿也可以手动抛出某个异常. 使用 throw 关键字完成这个操作.

public static int func2(int x) throws RuntimeException{

if(x==0){

throw new ArithmeticException(“/ by 0”);

}

return x/10;

}

public static void main(String[] args) {

int x = func2(0);

System.out.println(x);

}

3.Java 异常体系

===========

• 顶层类Throwable派生出两个重要的子类,Error和Exception

• 其中Error指的是Java运行时内部错误和资源耗尽错误.应用程序不抛出此类异常.这种内部错误一旦出现,除了告知用户并使程序终止之外,再无能为力.这种情况很少出现.

• Exception是我们程序猿所使用的异常类的父类.

• 其中Exception有一个子类称为RuntimeException,这里面又派生出很多我们常见的异常类NullPointerException,IndexOutOfBoundsException等.

Java语言规范将派生于 Error 类或 RuntimeException 类的所有异常称为 非受查异常, 所有的其他异常称为 受查异常.

如果一段代码可能抛出受查异常.那么必须显示进行处理.

如代码:

import java.io.File;

import java.util.Scanner;

public class Test2 {

public static String readFile(){

File file = new File(“d:/test.txt”);

Scanner sc = new Scanner(file);

return sc.nextLine();

}

public static void main(String[] args) {

System.out.println(readFile());

}

}

显示处理的方法有两种:

---

① 使用 try catch 包裹起来

import java.io.File;

import java.io.FileNotFoundException;

import java.util.Scanner;

public class Test2 {

public static String readFile(){

File file = new File(“d:/test.txt”);

Scanner sc = null;

try {

sc = new Scanner(file);

} catch (FileNotFoundException e) {

e.printStackTrace();

}

return sc.nextLine();

}

public static void main(String[] args) {

System.out.println(readFile());

}

}

② 在方法上加上异常说明, 相当于将处理动作交给上级调用者

import java.io.File;

import java.io.FileNotFoundException;

import java.util.Scanner;

public class Test2 {

public static String readFile() throws FileNotFoundException {

File file = new File(“d:/test.txt”);

Scanner sc = new Scanner(file);

return sc.nextLine();

}

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

System.out.println(readFile());

}

}

注 : 可以使用IDEA的alt + enter 快速修正代码.

4.自定义异常类

========

例如: 实现一个简单的用户登录功能

---

class NameError extends Exception{

public NameError(String message) {

super(message);

}

}

class PasswordError extends Exception{

public PasswordError(String message) {

super(message);

}

}

public class Test {

private static String name = “wangzhi”;

private static String password = “123456”;

public static void login(String name , String password) throws NameError, PasswordError {

if (!Test.name.equals(name)){

throw new NameError(“用户名输入错误”);

}

if (!Test.password.equals(password) ){

throw new PasswordError(“密码输入错误”);

总目录展示

该笔记共八个节点（由浅入深），分为三大模块。

高性能。 秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。

一致性。 秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。因此，将用一个节点来专门讲解如何设计秒杀减库存方案。

高可用。 虽然介绍了很多极致的优化思路，但现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，还要设计一个PlanB来兜底，以便在最坏情况发生时仍然能够从容应对。笔记的最后，将带你思考可以从哪些环节来设计兜底方案。

---

篇幅有限，无法一个模块一个模块详细的展示（这些要点都收集在了这份《高并发秒杀顶级教程》里），麻烦各位转发一下（可以帮助更多的人看到哟！）

由于内容太多，这里只截取部分的内容。

该笔记共八个节点（由浅入深），分为三大模块。

高性能。 秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。

一致性。 秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。因此，将用一个节点来专门讲解如何设计秒杀减库存方案。

高可用。 虽然介绍了很多极致的优化思路，但现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，还要设计一个PlanB来兜底，以便在最坏情况发生时仍然能够从容应对。笔记的最后，将带你思考可以从哪些环节来设计兜底方案。

---

篇幅有限，无法一个模块一个模块详细的展示（这些要点都收集在了这份《高并发秒杀顶级教程》里），麻烦各位转发一下（可以帮助更多的人看到哟！）

[外链图片转存中…(img-NlkrYSgr-1714188251424)]

[外链图片转存中…(img-jrIq9RAt-1714188251425)]

由于内容太多，这里只截取部分的内容。

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录