Java异常详解

最新推荐文章于 2024-06-05 10:00:47 发布
最新推荐文章于 2024-06-05 10:00:47 发布
阅读量1k 收藏 6
点赞数
分类专栏： 黑马程序员java学习笔记 文章标签： java异常 throws try..catch 自定义异常
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43836046/article/details/96109173
版权

文章目录

第一章 异常

1.1 异常的概念

**异常：**就是非正常的意思，在java等面向对象的编程语言中，异常本身就是一个类，产生异常就是创建一个异常对象，并把这个异常对象抛出来的过程，java的异常处理机制是中断处理。

1.2 异常体系

异常机制就是帮助我们找到程序中的问题，异常的根类是java.lang.throwable，其下有两个子类，分别是java.lang.Error和java.lang.Exception。平常所说的异常就是java.lang.Exception。
在这里插入图片描述
**异常和错误：**异常是小感冒，在运行过程中出现了异常也能用方法去自动处理，例如try......catch...改不改源码无所谓。但是错误是致命的，像申请一个非常大的数组，导致内存溢出，那就必须改动源码才能跑，所以这个只能在敲代码过程中避免。

1.3 异常分类

  • java中的异常可以分为编译期异常(Exception)和运行期异常(RuntimeException)

    • 通常编译期异常，我们在编辑器中刚敲完代码它就会在对应的代码处出现红色的波浪线，提示你这里的代码有异常，我们就可以进行适当修改。
    • 运行期异常，比如数组越界，在敲完代码时，编译器不会用红色波浪线说这里代码有问题，而是在运行代码时，才打印出红色字体说IndexOutofBoundException。

1.4 异常的产生过程解析

  • 下面这个数组越界的例子属于运行期异常
    在这里插入图片描述

第二章 Java的异常处理

java中异常处理的关键字有5个：try、 catch、 finally、 throw、 throws

2.1 抛出异常throw

throw 关键字

作用：可以使用throw关键字在指定的方法中抛出指定的异常

使用格式：throw new xxxException(“产生异常的原因”);

注意：

​ 1. throw关键字必须写在方法的内部

​ 2. throw关键字后边new的对象必须是Exception或Exception的子类对象

​ throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们 可以不处理，默认交给JVM处理（打印异常对象，终止程序）

​ throw关键字后边创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，要么throws，要么try.....catch

以后，我们首先必须对方法传递过来的参数进行合法性校验，如果参数不合法，那么我们就必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题。

  • 下面演示当出现IndexOutOfBoundsException和NullPoiterException的时候，如何处理

    public class Demo03Throw {
	public static int getElement(int[] arr, int index) {
		/*
		 * 对传进来的数组进行非空校验，如果是null，就抛出异常，并显示：输入的数组为空
		 * 对传进来的index进行越界校验，如果越界了，就抛出异常，并显示：数组越界
		 * 这两个都是运行期异常即RuntimeException，调用者main收到异常后可以throw给JVM处理
		 */
		if(arr == null) {
			throw new NullPointerException("输入的数组为空");
		}
		if(index < 0 || index > arr.length) {
			throw new IndexOutOfBoundsException("数组越界");
		}
		int ele = arr[index];
		return ele;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[] = null;
		int e = getElement(arr, -1);
		System.out.println(e);
	}
}

2.2 Objects非空判断

类Objects是由一些静态使用方法组成，这些方法是null-save (空指针安全)或null-tolerant (容忍空指针的)，那么在它的源码中，对对象的null值肯定进行了抛出异常的操作

  • public static <T> T requireNonNull(T obj) : 查看指定的应用对象是不是null

    源码中的确对为null的进行了抛出异常的操作:

    public static <T> T requireNonNull(T obj){
    if(obj == null){
        throw new NullPointerException();
    }
    return obj;
}

  • 用代码实验一下public static <T> T requireNonNull(T obj) 方法

    import java.util.Objects;

public class Demo04Objects {
	/*
	 * 实验public static <T> T requireNonNull(T obj)方法
	 * 其实这个方法的效果和自己写的：if(obj == null)   throw new NullPointerException("对象为空");差不多
	 * 直接用Objects.requireNonNull(obj);与上面的效果一样
	 * 还有一个重载的方法，Objects.requireNonNull(obj, messageSupplier)可以打印信息
	 */
	public static void method(Object obj) {
		/*
		if(obj == null) {
			throw new NullPointerException("对象为空");
		}
		*/
	//	Objects.requireNonNull(obj);
        Objects.requireNonNull(obj, "对象为空");
	}	
	public static void main(String[] args) {
		method(null);
	}
}

2.3 声明异常throws

throws关键字：异常处理的第一种方式，交给别人处理

作用：

​ 可以使用throws关键字处理异常对象，会把异常对象抛出给方法的调用者处理（自己不处理，让别人去处理），最终交给JVM处理–>中断处理

使用格式：在方法声明时使用

1. 修饰符 返回值类型 方法名 (参数列表) throws AAAException, BBBException....{

	throw new AAAException(“产生原因”);
    
	throw new BBBException(“产生原因”);

	........

}

注意：

  1. throws关键字必须写在方法声明处
  2. throws关键字后边说明的异常必须是Exception或者是Exception的子类
  3. 方法内部如果抛出了多个异常对象有子父类关系，那么直接声明父类异常即可
  4. 调用了一个声明抛出异常的方法，我们就必须处理声明的异常，要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM，要么try…catch自己处理
    1. 下面的代码演示编译期异常
      在这里插入图片描述
    1. 对于编译期异常，补救措施: ① throws声明 ② try…catch自己处理，但是下面还是出错了
      在这里插入图片描述
    1. 给main也加了一个throws声明，成功了
      在这里插入图片描述
    1. 增添一个后缀校验，throws声明直接填父类Exception就可以
      在这里插入图片描述

2.4 捕获异常try…catch

try…catch: 异常处理的第二种方式，自己处理异常

格式：

try{
    可能产生异常的代码
}catch(定义一个异常变量，用来接收try中抛出的异常对象){
    异常的处理逻辑，捕获异常对象字后，怎么处理异常对象
    一般在工作中，会把异常信息记录到一个日志中
}
可以接着更多的catch或其它代码
catch(异常类型名 变量名){
}
......

注意：

  1. try中可能会抛出多个异常对象，那么就可以使用对个catch来处理这些异常对象。
  2. 如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的异常处理逻辑之后，继续执行try…catch之后的代码
  3. 如果try中没有产生异常，那么执行完try里面的代码之后，继续执行try…catch之后的代码
  • 1. try…catch…的代码演示
    package exception;
import java.io.IOException;
public class Demo06tryCatch {
	public static void readFile(String fileName) throws IOException{
		if(!fileName.endsWith(".txt")) {
			//如果后缀名不是 .txt 就向调用该方法的main抛出一个异常对象
			throw new IOException("传递的文件名后缀不对");
		}	
	}
	public static void main(String[] args){
		try {
			//可能出现异常的代码
			readFile("c:\\a.tx");
		}catch(IOException e) { //try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
			//异常的处理逻辑，捕获异常对象之后，怎么处理异常对象
			System.out.println("catch: 传递的文件名后缀不对");
		}
		System.out.println("后续代码");
	}
}

在这里插入图片描述

  • try…catch和throws的一些不同
    1. try…catch是自己处理，比如上面代码中当main收到来自readFile的异常之后，它自己用catch里面的内容去解决了。而相比之下，throws声明只是让异常一级一级的往上抛，自己从不处理。
    2. try…catch代码执行完之后，还会执行余下的代码；throws中由于最终交给了JVM处理，JVM采用的是中断处理，所以会让整个程序到此结束，余下的代码不会再执行下去。

2.5 throwable 类中定义了3个打印异常的方法

  • 同样是用2.4中的代码作为示例：
    import java.io.IOException;
public class Demo06tryCatch {
	public static void readFile(String fileName) throws IOException{
		if(!fileName.endsWith(".txt")) {
			//如果后缀名不是 .txt 就向调用该方法的main抛出一个异常对象
			throw new IOException("传递的文件路径不是.txt结尾");
		}	
	}
	public static void main(String[] args) {
		try {
			readFile("c:\\a.tx");
		}catch(IOException e) { 
			//System.out.println("catch: 传递的文件名后缀不对");
			System.out.println(".................(1) getMessage方法......................");
			//返回throwable的简短描述
            System.out.println(e.getMessage()); 
			System.out.println(".................(2) toString方法........................");
			//返回throwable的详细信息字符串
            System.out.println(e.toString()); 
			System.out.println(".................(3) 直接打印e和toString方法一样...........");
			//和（2）一样
            System.out.println(e);
			System.out.println(".................(4)printStackTrace方法..................");
			//返回最详细的信息，平常默认JVM是打印的这个，包括异常的类型、原因、位置
            e.printStackTrace();
		}
		System.out.println("后续代码");
	}
}
  • 代码结果
    ........................(1) getMessage方法................................
catch: 传递的文件名后缀不对

........................(2) toString方法..................................
java.io.IOException: catch: 传递的文件名后缀不对

........................(3) 直接打印e和toString方法一样......................
java.io.IOException: catch: 传递的文件名后缀不对

........................(4)printStackTrace方法............................
java.io.IOException: catch: 传递的文件名后缀不对
后续代码
	at exception.Demo06tryCatch.readFile(Demo06tryCatch.java:7)
	at exception.Demo06tryCatch.main(Demo06tryCatch.java:12)

2.6 finally 代码块

下面的这种情况中，当readFile发生异常之后，就会直接转到catch那边的代码，try里面的System.oyt.println(“try的后续代码”)将不会被执行

在这里插入图片描述

无论发生异常与否，写在finally里面的代码都会被执行

import java.io.IOException;
public class Demo07tryCatchFinally {
	public static void readFile(String fileName) throws IOException{
		if(!fileName.endsWith(".txt")) {
			//如果后缀名不是 .txt 就向调用该方法的main抛出一个异常对象
			throw new IOException("传递的文件路径不是c:\\a.txt");
		}	
	}
	public static void main(String[] args) {
		try {
			//可能会产生异常的代码
			readFile("c:\\a.tx");
            System.out.println("try的后续代码");
		}catch(IOException e) { 
			//异常的处理逻辑
            e.printStackTrace();
		}finally {
			//无论发生异常与否，这里的代码都将会被执行
			System.out.println("资源释放");
		}
		System.out.println("后续代码");
	}
}

2.7 异常注意事项多次

多次异常情况下的处理方式：

  • 1. 多个异常，分别处理

    public static void main(String[] args) {
    //一个异常一个try...catch
    try { 
        int[] arr = {1, 2, 3};
        System.out.println(arr[3]);
    }catch(ArrayIndexOutOfBoundsException e) { 
        e.printStackTrace();
    }

    try {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.get(3));
    }catch(IndexOutOfBoundsException e) { 
        e.printStackTrace();
    }
    System.out.println("后续代码");
}

/*结果：
java.lang.ArrayIndexOutOfBoundsException: 3
	at exception.Demo08Attention.main(Demo08Attention.java:10)
java.lang.IndexOutOfBoundsException: Index: 3, Size: 3
	at java.util.ArrayList.rangeCheck(Unknown Source)
	at java.util.ArrayList.get(Unknown Source)
	at exception.Demo08Attention.main(Demo08Attention.java:20)
后续代码
 */

  • 2. 多个异常，一次捕获，多次处理

	public static void main(String[] args) {
		/*一个try多个catch的注意事项：
		 * catch里边定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则就会
		 * 报错，因为ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
		 * 所以一旦IndexOutOfBoundsException写在第一个catch中，那么无论两种异常谁发生，都会
		 * 在第一个catch起作用，那ArrayIn...这个就失去了作用，它就是个多余的，所以就报错。
		 */
		try {
			int[] arr = {1, 2, 3};
			System.out.println(arr[3]);
			
			ArrayList<Integer> list = new ArrayList<Integer>();
			list.add(1);
			list.add(2);
			list.add(3);
			System.out.println(list.get(3));
		}catch(ArrayIndexOutOfBoundsException e) { //子类写在前
            e.printStackTrace();
		}
		catch(IndexOutOfBoundsException e) {  //父类写在后
            e.printStackTrace();
		}
		System.out.println("后续代码");	
	}
  • 3. 多个异常，一次捕获，一次处理
	public static void main(String[] args) {
        /*其实就是2中，把子类异常去掉，直接写一个父类，因为父类也能处理子类的异常*/
		try {
			int[] arr = {1, 2, 3};
			System.out.println(arr[3]);
			
			ArrayList<Integer> list = new ArrayList<Integer>();
			list.add(1);
			list.add(2);
			list.add(3);
			System.out.println(list.get(3));
            
		}catch(IndexOutOfBoundsException e) { 
            e.printStackTrace();
		System.out.println("后续代码");	
	}
}

  • 4. 其实上面的都是运行时异常，可以不处理，直接交给JVM处理，JVM遇到时会打印异常并终止程序

  • 5. 如果finally中有return语句，那么返回的一定是finally中的return语句，应该避免

    	public static int getA() {
		int a = 10;
		try {
			return a;
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			//一定会执行的代码
			return a = 100;
		}
	}

	public static void main(String[] args) {
		System.out.println(getA()); //结果输出是100
	}

  • 6. 子类重写父类方法时，父类方法的throws声明长什么样，子类的throws声明就应该长什么样

    public class Fu {
	public void show01() throws NullPointerException, ClassCastException{}
	public void show02() throws IndexOutOfBoundsException{}
	public void show03() {}
}

class Zi extends Fu{
	public void show01() throws NullPointerException, ClassCastException{}
	//子类重写父类的方法时，throws的异常声明可以和父类的一样
	public void show02() throws ArrayIndexOutOfBoundsException{}
	//子类重写父类的方法时，throws的异常声明可以是父类声明的异常的子类
	public void show03() {}
	//子类重写父类方法时，父类没有throws声明，子类也不应该throws声明，但是可以用try..catch
}

第三章：自定义异常

3.1 概述

为什么需要自定义异常类？

因为有些异常java中并没有定义，比如年龄负数问题，注册名重复问题等等。

什么是自定义异常类

在开发中根据自己的业务的异常情况来定义异常类

自定义一个业务逻辑异常：RegisterException

异常类如何定义

  1. 自定义一个编译期异常：自定义类 并继承于java.lang.Exception
  2. 自定义一个运行期异常类：自定义类 并继承于 java.lang.RuntimeException

自定义异常类格式:

public class XXXException extends Exception | RuntimeException{
    添加一个空参数的构造方法
    添加一个带异常信息的构造方法
}

注意：

  1. 自定义异常类一般都是以Exception结尾，说明该类是一个异常类，比如我的RegisterException

  2. 自定义异常类，必须继承Exception或者RuntimeException

    1. 继承Exception：那么定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这个异常，要么throws，要么try…catch
    2. 继承RuntimeException：那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理（中断处理）

3.2 自定义异常练习

  • 自定义一个注册异常类，然后用它模拟注册操作

    public class RegisterException extends RuntimeException {

	private static final long serialVersionUID = 7115469508465834552L;
    
	//构造一个空参数的构造方法
	public RegisterException() {
		//让父类来处理
		super();
	}
	
	//添加一个带异常信息的构造方法
	public RegisterException(String Message) {
		//还是让父类来处理，其实是让它帮忙打印Message
		super(Message);
	}
}

  • 1. try…catch，CheckName方法抛异常给main，main自己处理

import java.util.Scanner;
/*
 * 要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
 * 分析：
 * 	1.使用数组保存已经注册过的用户名（数据库）
 * 	2.使用scanner获取用户输入的注册的用户名（前端，页面）
 * 	3.定义一个方法，对用户输入的注册的用户名进行判断
 * 		遍历存储已经注册过用户名的额数组，获取每一个用户名
 * 		使用获取到的用户和用户输入的用户名比较
 * 			true：
 * 				用户名已经存在，抛出RegisterException异常，并告知用户“亲，该用户名已经被注册”
 * 			false：
 * 				继续遍历比较
 * 		如果循环结束了，还没有找到重复的用户名，提示用户“恭喜您，注册成功了！”；
 */
public class PracticeRegisterException {
	static String[] UserName = {"张三", "李四", "王五"};
	
	public static void main(String[] args) {
		System.out.println("请输入您想要注册的用户名:");
		Scanner in = new Scanner(System.in);
		String name = in.next();
		try {
			CheckName(name);
		} catch (RegisterException e) {
			System.out.println("亲，该用户名已经被注册");
			return; 
            //try...catch方法里要有个return，不然catch执行完之后，下面的恭喜您也会被打印出来
		}
		System.out.println("恭喜您, 注册成功了！");
	}
	
	public static void CheckName(String name) throws RegisterException {
		for(String usr : UserName) {
			if(name.equals(usr)) {
				throw new RegisterException();
			}
		}
	}
}
  • 2. throws，CheckName方法抛异常给main，main把异常抛给JVM进行中断处理。
import java.util.Scanner;

/*
 * 要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
 * 分析：
 * 	1.使用数组保存已经注册过的用户名（数据库）
 * 	2.使用scanner获取用户输入的注册的用户名（前端，页面）
 * 	3.定义一个方法，对用户输入的注册的用户名进行判断
 * 		遍历存储已经注册过用户名的额数组，获取每一个用户名
 * 		使用获取到的用户和用户输入的用户名比较
 * 			true：
 * 				用户名已经存在，抛出RegisterException异常，并告知用户“亲，该用户名已经被注册”
 * 			false：
 * 				继续遍历比较
 * 		如果循环结束了，还没有找到重复的用户名，提示用户“恭喜您，注册成功了！”；
 */
public class PracticeRegisterException {
	static String[] UserName = {"张三", "李四", "王五"};
	
	public static void main(String[] args) throws RegisterException {
		System.out.println("请输入您想要注册的用户名:");
		Scanner in = new Scanner(System.in);
		String name = in.next();
		CheckName(name);
		System.out.println("恭喜您, 注册成功了！");
	}
	
	public static void CheckName(String name) throws RegisterException{
		for(String usr : UserName) {
			if(name.equals(usr)) {
				throw new RegisterException("亲，该用户已被注册");
			}
		}
	}
}
  • 3. 什么都不用做，CheckName方法直接抛出异常就行，默认交给JVM进行中断处理，因为我们的注册异常继承于RuntimeException
import java.util.Scanner;

/*
 * 要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
 * 分析：
 * 	1.使用数组保存已经注册过的用户名（数据库）
 * 	2.使用scanner获取用户输入的注册的用户名（前端，页面）
 * 	3.定义一个方法，对用户输入的注册的用户名进行判断
 * 		遍历存储已经注册过用户名的额数组，获取每一个用户名
 * 		使用获取到的用户和用户输入的用户名比较
 * 			true：
 * 				用户名已经存在，抛出RegisterException异常，并告知用户“亲，该用户名已经被注册”
 * 			false：
 * 				继续遍历比较
 * 		如果循环结束了，还没有找到重复的用户名，提示用户“恭喜您，注册成功了！”；
 */
public class PracticeRegisterException {
	static String[] UserName = {"张三", "李四", "王五"};
	
	public static void main(String[] args) {
		System.out.println("请输入您想要注册的用户名:");
		Scanner in = new Scanner(System.in);
		String name = in.next();
		CheckName(name);
		System.out.println("恭喜您, 注册成功了！");
	}
	
	public static void CheckName(String name){
		for(String usr : UserName) {
			if(name.equals(usr)) {
				throw new RegisterException("亲，该用户已被注册");
			}
		}
	}
}
阿福97
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java异常概述
weixin_56401913的博客
04-25 170
Java异常概述1.java的异常处理机制2.java的异常类型3.捕获异常a.try和catch语句使用多个catch捕获可能产生的多个异常Exception异常类的应用b.finally语句 所谓异常，是指程序运行过程中遇到的非致命错误，注意不是编译时的语法错误，这些事件的发生会阻碍程序的正常运行。 1.java的异常处理机制 Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw 语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE就会试
Java异常详细信息获取
SELECT_BIN的博客
03-07 4027
异常详细信息获取，方便定位； 测试代码： @Scheduled(cron = "0/10 * * * * ? ") public void testException(){ String str = null; try{ str.equals(1); }catch (Exception e){ final Writer result = new StringWri...
JAVA中的异常——Exception
2301_76967212的博客
05-28 2190
java语言中，将程序执行中发生的不正常情况称为异常。（开发过程中的语法错误和逻辑错误不是异常）
java.lang.*中Error 源代码详解
u014344668的专栏
12-24 622
java.lang.*中Error 源代码详解Error详解Error的使用场景核心方法 学习Java的同学注意了！！！ 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！ Error详解 Error的使用场景 核心方法 public Error() 构造方法 public Error(String message) public Error(String message, Throwable cause) public Error
Java CompletableFuture 实战应用指南
最新发布
编码行者的博客
06-05 665
在现代应用开发中，异步编程和并发任务处理变得越来越重要。Java 8 引入的为我们提供了一个强大且灵活的工具来简化这一过程。在本文中，我们将结合各种实战场景，详细介绍的核心API及其应用。
Java——异常登陆模拟
m0_63372226的博客
10-04 395
【代码】Java——异常登陆模拟。
【Java】异常（Exception）
懂得一千零一种,赋予你失败的方法！
02-16 851
Java.异常 一、异常的基本概念 1.什么是异常？ 第一，异常模拟的是我们日常生活中"不正常"的事件 第二，java中采用"类"去模拟异常 第三，异常类是可以创建对象的： NullPointerException e = 0x1234; e是引用类型，e中保存的内存地址指向堆内存中的"对象" .........
Java—异常(Exception)
weixin_61843013的博客
03-06 4561
基本概念 Java语言中，将程序执行中发生的不正常情况称为“ 异常 ”。(开发过程中的语法错误和逻辑错误不是异常) 执行过程中所发生的异常事件可分为两大类 1.Error(错误)：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError[栈溢出]和OOM(out of memory)，Error是严重错误，程序会崩溃 2.Exception：其它因编译错误和偶然的外在因素导致的一般性问题，可以使用针对性的代码......
Java 异常详解
08-31
Java异常详解异常是编程过程中不可避免的问题，它们是程序运行时发生的错误或不正常情况。Java提供了完善的异常处理机制，帮助开发者有效地管理和恢复程序状态。本文将深入探讨异常与错误的区别、异常的分类以及异常...
java异常详解
01-08
本文将深入探讨Java异常的各个方面，包括异常的分类、特点以及如何在API设计中合理地使用它们。 首先，异常通常分为两类：已检查异常（Checked Exception）和未检查异常（Unchecked Exception）。已检查异常是那些...
java 异常详解及应用实例
08-31
Java异常处理是编程中至关重要的一个环节，它用于处理程序运行过程中出现的错误或异常情况。异常分为两类：Error和Exception。Error通常是由JVM调用系统底层导致的，例如`OutOfMemoryError`，这类异常通常无法通过...
Java异常详解_动力节点Java学院整理
08-30
总结Java异常机制是程序错误处理的重要部分，它提供了结构化的错误处理方式，帮助开发者识别和解决程序中可能出现的问题。理解异常的分类、处理机制以及最佳实践，能够编写出更加健壮和易于维护的代码。
java关于Exception（异常）的详解
qq_39140680的博客
03-26 6213
目录 概述： 异常继承结构： 异常的两种处理方式： 异常上抛： 异常捕捉： 深入try..catch： finally语句： 自定义异常： 概述： 1、 程序在执行过程中发生了不正常的情况，而这种不正常的情况就叫做 ：异常 例如： System.out.println(10/0); 这个语句在控制台会输出： Exception in thread "main" java.lang.ArithmeticException: / by zero at excption.
java中的Exception--异常详解
Lotus_dong的博客
11-18 2638
文章目录异常Java异常概念异常分类解决异常的两种方法异常的体系异常体系图异常处理异常处理的流程异常处理的实现trycatchfinally捕获异常信息getMessage()printStackTrace()throws 和 throwthrowsthrowthrows和throw的总结自定义异常 异常 Java异常概念 ​ 在使用计算机语言开发时，尽管代码没有问题，但在系统的运行过程中仍会遇到问题。简单来说就是代码运行时，由于各种原因导致程序不能正常的执行。 异常分类 ​ 定义：Java语言中，将程
Java | 异常类【万字详解，看过来】
做技术人 · 产优质博客 · 找好工作
10-01 4881
万字详解Java异常类，带你感受异常类在开发中的重要性
有关Java异常体系
weixin_58104242的博客
01-17 483
异常也是一种对象，java当中定义了许多异常类，并且定义了基类java.lang.Throwable作为所有异常的超类。Java语言设计者将异常划分为两类：Error和Exception。 Error Error 类层次结构描述了 Java 运行时系统的内部错误和资源耗尽错误。 应用程序不应该 抛出这种类型的对象。 如果出现了这样的内部错误， 除了通告给用户，并尽力使程序安全地终止外， 再也无能为力了。这种情况很少出现,这些错误是不可查的，非代码性错误。因此，当此类错误发生时，应用不...
Java异常浅析一二
EndlessProcess的专栏
04-08 553
合理的处理异常，是程序健壮性的保证。
Java异常（Exception）详解
一只快乐的小蒟蒻~
10-31 487
Java异常（Exception）详解
【java基础知识 6】java异常详解
05-10
Java异常处理是Java程序设计的重要组成部分，也是程序设计过程中不可缺少的一部分。异常是在运行期间发生的错误，通常情况下不能交给编译器进行处理，需要程序员在代码中进行异常处理。 Java异常分为两个类型：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值