JAVA异常

最新推荐文章于 2024-09-03 09:28:19 发布
最新推荐文章于 2024-09-03 09:28:19 发布
阅读量117 收藏
点赞数
分类专栏： JAVA 基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32480989/article/details/120458611
版权

异常概述

String写成string不是异常，是错误。
在这里插入图片描述

Error

/*
 * Error:
 * Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。
 * 
 * 一般不编写针对性的代码进行处理。
 */
public class ErrorTest {
	public static void main(String[] args) {
		//1.栈溢出：java.lang.StackOverflowError
		main(args);//它不断的调用自己，直到栈溢出
		//2.堆溢出：java.lang.OutOfMemoryError 
		Integer[] arr = new Integer[1024*1024*1024];//1024*1024*1024太大了，堆里撑不开了。
		
	}
}

Exception

编译时异常，
运行时异常

常见异常的举例

编译时异常 报红线
在这里插入图片描述
异常

package com.atguigu.java1;

import java.io.File;
import java.io.FileInputStream;
import java.util.Date;
import java.util.Scanner;

import org.junit.Test;

/*
 * 一、异常体系结构
 * 
 * java.lang.Throwable
 * 		|-----java.lang.Error:一般不编写针对性的代码进行处理。
 * 		|-----java.lang.Exception:可以进行异常的处理
 * 			|------编译时异常(checked)
 * 					|-----IOException输入或输出异常
 * 						|-----FileNotFoundException文件不存在异常
 * 					|-----ClassNotFoundException类找不到异常
 * 			|------运行时异常(unchecked,RuntimeException)
 * 					|-----NullPointerException空指针
 * 					|-----ArrayIndexOutOfBoundsException数组越界
 * 					|-----ClassCastException类转换异常
 * 					|-----NumberFormatException数字转化异常
 * 					|-----InputMismatchException 输入的类型错误
 * 					|-----ArithmeticException算术运算异常
 * 
 * 
 * 
 * 面试题：常见的异常都有哪些？举例说明↓
 */
public class ExceptionTest {
	
	//******************以下是编译时异常***************************
	@Test  //编译异常不会生成字节码文件，可以执行javac命令 无误
	public void test7(){
		File file = new File("hello.txt");
		FileInputStream fis = new FileInputStream(file);

		int data = fis.read();//读一个字节
		while(data != -1){//等于-1时就是到末尾了，就跳出了
			System.out.print((char)data);
			data = fis.read();
		}

		fis.close();//资源 fis流需要显式的关闭
		
	}
	
	//******************以下是运行时异常***************************
	//ArithmeticException//数学运算错误
	@Test
	public void test6(){
		int a = 10;
		int b = 0;
		System.out.println(a / b);//数学运算错误
	}
	
	//InputMismatchException//输入的类型错误
	@Test
	public void test5(){
		Scanner scanner = new Scanner(System.in);
		int score = scanner.nextInt();//输入78等数组类型没事，输入abc报错
		System.out.println(score);
		
		scanner.close();
	}
	
	//NumberFormatException//数据转换错误
	@Test
	public void test4(){
		
		String str = "123";
		str = "abc";
		int num = Integer.parseInt(str);//转化为数字(这里字母不能转化为数字，数据转化错误)
		
		
		
	}
	
	//ClassCastException//类型转换异常
	@Test
	public void test3(){
		Object obj = new Date();//先向上转型
		String str = (String)obj;//再向下转型
	}
	
	//IndexOutOfBoundsException//越界异常
	@Test
	public void test2(){
		//ArrayIndexOutOfBoundsException//数组越界
		int[] arr = new int[10];
	    System.out.println(arr[10]);//数组越界

		//StringIndexOutOfBoundsException//字符串越界
		String str = "abc";
		System.out.println(str.charAt(3));//字符串越界
	}
	
	//NullPointerException//空指针异常
	@Test
	public void test1(){
		//空指针异常
	    int[] arr = null;
	    System.out.println(arr[3]);
		
		String str = "abc";
		str = null;//空指针异常
		System.out.println(str.charAt(0));
		
	}
	
	
}

异常处理方式概论

在这里插入图片描述
在这里插入图片描述

try-catch方式

6、在try结构中声明的变量，再出了try结构以后，就不能再被调用（改进见下面代码↓）
在这里插入图片描述
代码：

package com.atguigu.java1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import org.junit.Test;

/*
 * 一、异常的处理：抓抛模型
 * 
 * 过程一："抛"：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。
 *           并将此对象抛出。
 *           一旦抛出对象以后，其后的代码就不再执行。
 * 		
 * 		关于异常对象的产生：① 系统自动生成的异常对象
 * 					 ② 手动的生成一个异常对象，并抛出（throw）
 * 
 * 过程二："抓"：可以理解为异常的处理方式：① try-catch-finally  ② throws
 * 
 * 
 * 二、try-catch-finally的使用
 * 
 * try{
 * 		//可能 出现异常的代码
 * 
 * }catch(异常类型1 变量名1){
 * 		//处理异常的方式1
 * }catch(异常类型2 变量名2){
 * 		//处理异常的方式2
 * }catch(异常类型3 变量名3){
 * 		//处理异常的方式3
 * }
 * ....
 * finally{
 * 		//一定会执行的代码
 * }
 * 
 * 说明：
 * 1. finally是可选的。
 * 2. 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象
 *    的类型，去catch中进行匹配
 * 3. 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的
 *    try-catch结构（在没有写finally的情况）。继续执行其后的代码
 * 4. catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
 *    catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
 * 5. 常用的异常对象处理的方式： ① getMessage() 返回String类型的值   ② printStackTrace()
 * 6. 在try结构中声明的变量，再出了try结构以后，就不能再被调用
 * 7. try-catch-finally结构可以嵌套
 * 
 * 体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。
 *     相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
 *     
 * 体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。（因为就算是写异常，也是报出一堆异常，和不写异常区别没啥）
 *      针对于编译时异常，我们说一定要考虑异常的处理。
 */
public class ExceptionTest1 { 
	
	//体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。
	// 相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
	@Test
	public void test2(){
		try{
			File file = new File("hello.txt");
			FileInputStream fis = new FileInputStream(file);
			
			int data = fis.read();
			while(data != -1){
				System.out.print((char)data);
				data = fis.read();
			}
			
			fis.close();
		}catch(FileNotFoundException e){//如果真没hello.txt文件，还是会报异常。
			e.printStackTrace();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
	
	@Test
	public void test1(){//运行时异常
		
		String str = "123";
		str = "abc";
		int num = 0;
		try{
			num = Integer.parseInt(str);
			
			System.out.println("hello-----1");
		}catch(NumberFormatException e){
//			System.out.println("出现数值转换异常了，不要着急....");
			//getMessage() 异常处理方式1：返回String类型的
			System.out.println(e.getMessage());//获取异常信息
			//printStackTrace() 异常处理方法2：打印整个堆栈的信息了
			e.printStackTrace();
			
		}catch(NullPointerException e){
			System.out.println("出现空指针异常了，不要着急....");
		}catch(Exception e){
			System.out.println("出现异常了，不要着急....");
			
		}
		System.out.println(num);
		
		System.out.println("hello-----2");
	}
	
}

finally

public void test2()
在这里插入图片描述
如果fis = new FileInputStream(file);过了，那这个流就打开了，碰到int data = fis.read();出现异常，直接跳过fis.close();去catch (IOException e)那处理异常了，导致这个流没关，这是问题所在。解决方法在下面代码test2中。

package com.atguigu.java1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import org.junit.Test;

/*
 * try-catch-finally中finally的使用：
 * 
 * 
 * 1.finally是可选的
 * 
 * 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有
 * return语句等情况。
 * 
 * 3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的
 *   释放。此时的资源释放，就需要声明在finally中。
 * 
 */
public class FinallyTest {
	
	
	@Test
	public void test2(){
		FileInputStream fis = null;//声明放在外面，防止finally那的fis.close();说没有定义
		try {
			File file = new File("hello1.txt");
			fis = new FileInputStream(file);//try声明了，现在是给fis赋值
			
			int data = fis.read();
			while(data != -1){
				System.out.print((char)data);
				data = fis.read();
			}
			
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fis != null)//如果资源都没创建成功，那么都没new成功，就不需要关闭流
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	@Test
	public void testMethod(){
		int num = method();
		System.out.println(num);
		//输出
		//我一定会被执行
		//3（下面没加return 3时是返回2，加了return 3后返回3，return 3抢断了return 2）
	}
	
	public int method(){//此方法要求返回值是int型
		
		try{
			int[] arr = new int[10];
			System.out.println(arr[10]);//异常，
			// 执行catch(ArrayIndexOutOfBoundsException e)的语句，
			// 输出堆栈异常信息，返回2，并执行finally的语句，
			return 1;
		}catch(ArrayIndexOutOfBoundsException e){
			e.printStackTrace();
			return 2;
		}finally{
			System.out.println("我一定会被执行");
			return 3;//（没加return 3时是返回2，加了return 3后返回3，return 3抢断了return 2）
		}
		
		
	}
	
	@Test
	public void test1(){
		try{
			int a = 10;
			int b = 0;
			System.out.println(a / b);//异常
			
		}catch(ArithmeticException e){
			e.printStackTrace();
			//下面两条语句会出异常，会跳出程序，但是仍然会执行finally中的我好帅啊，
			//我好帅啊！！！~~"（被注释的）则不会执行
			int[] arr = new int[10];
			System.out.println(arr[10]);
			
		}catch(Exception e){
			e.printStackTrace();
		}
		//这个其实也能一直都执行（如果没有return的话）↓
        // System.out.println("我好帅啊！！！~~");
		
		finally{
			System.out.println("我好帅啊~~");
		}
		
	}
	
}

throws方式

 package com.atguigu.java1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
 * 异常处理的方式二：throws + 异常类型
 * 
 * 1. "throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
 *     一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常
 *     类型时，就会被抛出。异常代码后续的代码，就不再执行！
 *     
 * 2. 体会：try-catch-finally:真正的将异常给处理掉了。
 *        throws的方式只是将异常抛给了方法的调用者。调用者还能往上抛，  并没有真正将异常处理掉。  
 * 
 * 3. 开发中如何选择使用try-catch-finally 还是使用throws？（这个问题在本章后边有介绍）
 *   3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果
 *       子类重写的方法中有异常，必须使用try-catch-finally方式处理。
 *   3.2 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws
 *       的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。
 * 
 */
public class ExceptionTest2 { 
	//统一解决是可以节省很多代码的，遇到一个当场解决，那代码量太大了，所以可以往上抛
	public static void main(String[] args){
		try{
			method2();//method2中异常抛回来，在下面的catch(IOException e)就解决了
			
		}catch(IOException e){
			e.printStackTrace();
		}
		
		method3();//method3中要是有异常在method3方法中就解决了，
		// 因此不需要在main（）方法中提供解决办法。
		
	}
	
	
//throws只是往上抛，并不解决问题，抛到main方法就必须要解决了，
// try-catch才能解决异常	
	
	public static void method3(){
		try {
			method2();//method2()往上抛，抛到method3这了
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	
	public static void method2() throws IOException{
		method1();//method1()往上抛，抛到method2这了
	}
	
	
	public static void method1() throws FileNotFoundException,IOException{//throws后边是异常类型
		//以编译时异常举例
		File file = new File("hello1.txt");
		FileInputStream fis = new FileInputStream(file);
		
		int data = fis.read();
		while(data != -1){
			System.out.print((char)data);
			data = fis.read();
		}
		
		fis.close();
		
		System.out.println("hahaha!");
	}
	
	
}

重写方法异常抛出的规则

package com.atguigu.java1;

import java.io.FileNotFoundException;
import java.io.IOException;

/*
 * 方法重写的规则之一：
 * 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
 * //可知，如果父类没有抛异常，子类绝对不能抛异常。
 * 
 */
public class OverrideTest {
	
	public static void main(String[] args) {
		OverrideTest test = new OverrideTest();
		test.display(new SubClass());//通过test调用display
	}

	
	public void display(SuperClass s){//多态SuperClass s=new SubClass()
		try {
			s.method();//调用的子类SubClass的重写方法
		} catch (IOException e) {//如果此时子类抛出异常，父类那个异常处理应该能罩得住子类抛出的异常。
			// 如果父类的异常罩不住子类的异常，那么异常就无法处理了。
			//可知，如果父类没有抛异常，子类绝对不能抛异常。
			e.printStackTrace();
		}
	}
}
//父类 
class SuperClass{
	
	public void method() throws IOException{
		//父类抛出异常IOException
	}
}
//子类
class SubClass extends SuperClass{
	public void method()throws FileNotFoundException{
		//子类抛出异常FileNotFoundException小于等于父类异常
	}
}

开发中如何选择哪种方式处理异常

3、 开发中如何选择使用try-catch-finally 还是使用throws？
3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。
3.2 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系（第一个方法执行得出的结果作为参数给第二个方法用，第二个方法执行得出的结果作为参数给第三个方法用，即为递进方法（递进关系））执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。（假设递进方法是方法1，2，3，如果方法1异常了，经过try-catch处理后，接着执行方法2，3，最后返回方法a的值可能都不能用了；或者方法1异常了，经过try-catch处理后，往下执行不动了，卡住了，返回不了了。所以不让他们用try-catch，而是用throws进行处理。）

一点理解:
如果没写异常处理，可能就展现一顿乱码；写了异常处理就很友好了，可能会说“开发人员忙碌中，请稍后！！”。处理异常也没解决问题，只是更友好了些。

手动抛出异常对象

在过程"抛"中：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。

关于异常对象的产生：
① 系统自动生成的异常对象
② 手动的生成一个异常对象，并抛出（throw）

throw new RuntimeException(“您输入的数据非法！”);
//RuntimeException带形参的构造器RuntimeException(String message)
在这里插入图片描述
在这里插入图片描述
throw new Exception(“您输入的数据非法！”);
//Exception包括编译时异常和运行时异常，必须显式处理异常，
在这里插入图片描述
throw生成一个异常对象，通过 throws来异常处理
在这里插入图片描述
在主函数中如下处理。
在这里插入图片描述
结果：
在这里插入图片描述
附参考代码：

package com.atguigu.java2;

public class StudentTest {
	
	public static void main(String[] args) {
		try {
			Student s = new Student();
			s.regist(-1001);
			System.out.println(s);
		} catch (Exception e) {
//			e.printStackTrace();
			System.out.println(e.getMessage());
			//getMessage输出的是throw new Exception("您输入的数据非法！");中的“您输入的数据非法！”
		}
	}
	
}


class Student{
	
	private int id;
	
	public void regist(int id) throws Exception {
		if(id > 0){
			this.id = id;
		}else{
			//手动抛出异常对象
			throw new RuntimeException("您输入的数据非法！");
			//↑RuntimeException带形参的构造器RuntimeException(String message)
			//抛的异常是RuntimeException，运行时异常，所以在主方法中也可以不处理
			throw new Exception("您输入的数据非法！");
			//Exception包括编译时异常和运行时异常，必须处理异常，通过在
			// 方法public void regist(int id)后加 throws Exception处理
			throw new MyException("不能输入负数");//MyException是继承的RuntimeException（运
		// 行时异常类）的，所以可以把public void regist(int id) 后的throws Exception去掉
			
			//错误的
//			throw new String("不能输入负数");
//          String没有继承于异常，不是一个异常类，
//			String父类是Object类，只能抛一个异常类的对象
		}
		
	}

	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}
	
	
}

如何自定义异常

MyException,java

package com.atguigu.java2;
/*
 * 如何自定义异常类？
 * 1. 继承于现有的异常结构：RuntimeException 、Exception
 * 2. 提供全局常量：serialVersionUID
 * 3. 提供重载的构造器
 * 
 */
//MyException是自定义异常类
public class MyException extends Exception{
	//可查看Exception源码。
	//serialVersionUID可唯一标识MyException这个类，这个数随便写一个可
	static final long serialVersionUID = -7034897193246939L;
	
	//构造器
	public MyException(){
		
	}
	//含参构造器
	public MyException(String message){
		super(message);
	}
}

StudentTest.java
在这里插入图片描述

结果：
在这里插入图片描述

异常的练习题

第一题

1、第一部分：

执行顺序：
在这里插入图片描述
结果：
在这里插入图片描述
2、第二部分
执行顺序
在这里插入图片描述
结果：
在这里插入图片描述

附参考代码：

package com.atguigu.java2;

public class ReturnExceptionDemo {
	static void methodA() {
		try {
			System.out.println("进入方法A");
			throw new RuntimeException("制造异常");
		} finally {
			System.out.println("用A方法的finally");
		}
	}

	static void methodB() {
		try {
			System.out.println("进入方法B");
			return;
		} finally {
			System.out.println("调用B方法的finally");
		}
	}

	public static void main(String[] args) {
		try {
			methodA();
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		
		
		
		methodB();
	}
}

第二题大练习

题目
在这里插入图片描述
EcDef.java

package com.atguigu.exer;

//自定义异常类
public class EcDef extends Exception {

	static final long serialVersionUID = -33875164229948L;

	public EcDef() {
	}

	public EcDef(String message) {
		super(message);
	}
}

EcmDef.java

package com.atguigu.exer;
/*
 * 编写应用程序EcmDef.java，接收命令行的两个参数，要求不能输入负数，计算两数相除。
	对数据类型不一致(NumberFormatException)、缺少命令行参数(ArrayIndexOutOfBoundsException、
  	除0(ArithmeticException)及输入负数(EcDef 自定义的异常)进行异常处理。
提示： 
	(1)在主类(EcmDef)中定义异常方法(ecm)完成两数相除功能。
	(2)在main()方法中使用异常处理语句进行异常处理。
	(3)在程序中，自定义对应输入负数的异常类(EcDef)。
	(4)运行时接受参数 java EcmDef 20 10   //args[0]=“20” args[1]=“10”
	(5)Interger类的static方法parseInt(String s)将s转换成对应的int值。
        如：int a=Interger.parseInt(“314”);	//a=314;

 */
public class EcmDef {
	public static void main(String[] args) {
		try{
			int i = Integer.parseInt(args[0]);
			int j = Integer.parseInt(args[1]);
			
	 		int result = ecm(i,j);
			
			System.out.println(result);
			
		}catch(NumberFormatException e){
			System.out.println("数据类型不一致");
		}catch(ArrayIndexOutOfBoundsException e){
			System.out.println("缺少命令行参数");
		}catch(ArithmeticException e){
			System.out.println("除0");
		}catch(EcDef e){
			System.out.println(e.getMessage());
		}
		
	}
	
	public static int ecm(int i,int j) throws EcDef{
		if(i < 0 || j < 0){
			throw new EcDef("分子或分母为负数了！");
			//throw 出一个异常对象，由throws EcDef做异常的处理
		}
		return i / j;
	}
}

一点总结

在这里插入图片描述
throws 是 捕获，是异常处理的一种方式。
throw 是手动抛出一个异常对象，生成一个异常对象。
在这里插入图片描述
上游排污（throw），下游治污（throws），当然throws 的处理方式是往上报，并没有真正把水变清澈。

在这里插入图片描述

没有人会真的躺平
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 异常处理 -- Java 语言的异常、异常链与断言
栗筝i的博客
06-13 3170
世界上存在永远不会出错的程序吗？也许这只会出现在程序员的梦中。随着编程语言和软件的诞生，异常情况就如影随形地纠缠着我们，只有正确处理好意外情况，才能保证程序的可靠性。
logback异常RuntimeException in Action for tag [encoder] java.lang.NumberFormatException
wxj123465的博客
08-19 9585
我的配置文件： &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;configuration scan="true" scanPeriod="60"&gt; &lt;appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender&qu
7-异常处理
sinat_37106527的博客
04-15 203
第7章：异常处理 1、异常概述与异常体系结构 Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理。 Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如： 空指针访问 试图读取不存在的文件 网络连接中断 数组角标越界 ex package com.atguigu.java; /* * Error: * Java虚拟机无法解决的严
异常处理
荣华的博客
09-19 228
什么是异常 异常定义： 导致程序的正常流程被中断的事件，叫做异常 例如： 比如要打开d盘的LOL.exe文件，这个文件是有可能不存在的 Java中通过 new FileInputStream(f) 试图打开某文件，就有可能抛出文件不存在异常FileNotFoundException 如果不处理该异常，就会有编译错误 处理办法参见 异常处理 package exception; import ...
springboot集成logback,报错java.lang.IllegalStateException: Logback configuration error detected:
qq_26797239的博客
03-19 1万+
最近需要将一个springboot项目部署到一台新服务器上。而且新服务器是完全copy了旧服务器的环境与项目。但是在新服务器上启动该springboot项目，就一直报错 2019-03-18 18:54:35.532 [main] ERROR o.s.boot.SpringApplication - Application startup failed java.lang.Illegal...
logback加入按时间与大小分割日志文件时报错处理
三千炼心的博客
06-11 1937
ERROR in ch.qos.logback.core.joran.spi.Interpreter@26:19 - RuntimeException in Action for tag [rollingPolicy] java.lang.IllegalStateException: FileNamePattern [/mySoft/logs/demo.log] does not contain ...
java.lang.IllegalArgumentException 异常报错完美解决
辰小白
07-12 15万+
目录 修改JDK使用版本 修改开发工具idea配置（eclipse的直接跳过这个看下面） 修改开发工具eclipse配置 学习spring依赖注入的时候碰到这个坑，折腾了许久，记录一下以防其他小伙伴入坑！ 该异常主要原因是因为JDK与Spring版本不一致。要么更换jdk，要么重新下载符合jdk的springjar包 我本地装了两个JDK版本，一个1.8，一个1.7，原本以为只要修改一...
Java 异常
今天我学废了吗
08-15 273
Java中异常的处理
Java的异常
会写Bug的攻城狮
01-10 879
运行时异常是指在程序运行过程中可能会出现的异常，这些异常通常是由程序逻辑错误引起的，而不是外部环境或用户输入造成的。这些异常通常是由外部环境或用户输入造成的，程序员需要在代码中显式地处理这些异常，以确保程序的稳定性和可靠性。在这个示例中，我们展示了一个可能抛出文件未找到异常和IO异常的情况，并使用try-catch块来捕获并处理这些异常。一般在service层处理受检异常，通过创建一个自定义的异常类，在需要的地方抛出自定义异常即可。可以直接在service层的最外层进行抛出异常或者直接捕获异常并处理异常。
java异常处理练习题
08-17
java异常练习题，北大青鸟学士后课后练习，主要是异常处理的小测验
Java异常的性能分析
03-23
Java异常的性能分析.在Java中抛异常的性能是非常差的。通常来说，抛一个异常大概会消耗100到1000个时钟节拍。 　在Java中抛异常的性能是非常差的。通常来说，抛一个异常大概会消耗100到1000个时钟节拍。 　通常是...
关于Java异常处理的几条建议_动力节点Java学院整理
08-30
Java 异常处理机制详解 Java 异常处理是 Java 语言中的一种机制，用于处理程序中的异常情况。Java 提供了抛出异常、捕捉异常和 finally 语句的使用来处理程序异常。下面是关于 Java 异常处理的几条建议： 建议 1: ...
已解决java.lang.IllegalArgumentException异常的正确解决方法，亲测有效！！！
小明的Java问道之路
01-07 3万+
IllegalArgumentException是由于传递给方法的参数非法或不正确而引发的，要解决这个问题，需要在调用方法前验证输入，并在方法内部使用断言来检查参数的有效性。
java.lang.IllegalStateException异常以及解决
热门推荐
qq_43633916的博客
07-20 21万+
今天运行项目时出现的这个问题，java.lang.IllegalStateExceptio，第一次见到这个异常， 查询后 错误原因：该异常表示，当前对客户端的响应已经结束，不能在响应已经结束（或说消亡）后再向 客户端（实际上是缓冲区）输出任何内容。 具体分析：首先解释下flush()，我们知道在使用读写流的时候数据先被读入内存这个缓冲区中， 然后再写入文件，但是当数据读完时不代表数据已经写入文件完...
Java常见异常(Runtime Exception )小结
潇的编程之路
10-14 8767
ArithmeticException（除数为0的异常）, BufferOverflowException（缓冲区上溢异常）, BufferUnderflowException（缓冲区下溢异常）, IndexOutOfBoundsException（出界异常）, NullPointerException（空指针异常）, EmptyStackException（空栈异常）, IllegalArgumentException（不合法的参数异常）, NegativeArraySizeException, NoSu
java.util.regex.PatternSyntaxException表达式错误异常【JAVA小知识】
My Blog My Style
07-12 6938
这是我从网上摘录的，自己也遇到了同样的错误，在此感谢作者！ Java.util.regex.PatternSyntaxException表达式错误异常 String s="/babalaautomgr.ejs?method=constr";     int i=s.split("?").length;     System.out.println(i);
Exception in thread "main" org.apache.kafka.common.KafkaException: Failed create new KafkaAdminClien...
weixin_30552635的博客
08-15 5313
[root@linux04 Downloads]# java -cp kafka001-1.0-SNAPSHOT.jar com.bw.Stream.Application SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder". SLF4J: Defaulting to no-operation (NOP)...
SpringBoot 项目集成 xxl-job
最新发布
qq_58159506的博客
09-03 537
SpringBoot 项目集成 xxl-job
Java异常
05-26
Java 异常是指在程序运行过程中出现的不正常情况。Java 中的异常分为两类： 1. 可查异常（Checked Exception）：编译器会强制要求程序处理这种异常。比如FileNotFoundException，如果不处理这个异常，编译器就会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值