Java的异常处理机制

最新推荐文章于 2023-03-16 19:26:19 发布
最新推荐文章于 2023-03-16 19:26:19 发布
阅读量319 收藏 1
点赞数
分类专栏： javaSE 文章标签： javaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44260380/article/details/98240302
版权

Java的异常处理机制

Throwable、 Error、Exception
Java异常结构中定义有Throwable类（顶级父类）

Exception和Error是其派生的两个子类
Exception表示：由于网络故障、文件损坏、设备错误、用户输入非法等情况导致的异常
Error表示：Java运行时环境出现的错误，例如： JVM内存资源耗尽等

异常与错误的区别：

异常可以修复，错误不可以修
异常是程序允许的，错误是程序不允许的

理解为人类的行为就是
错误就是，我死了
异常就是，我病了

一、Java的异常处理机制中的 try-catch

1、语法结构：

try{
    程序代码块
}catch(XXXException e){//这里写异常类型和对象名
    当try中出现XXXException后的解决代码
}
或
try{
}finally{
}

当JVM执行程序时，发现某个错误，就会实例化对应的异常实例，

并将程序执行过程设置好，然后将该异常抛出

此时若是没有异常处理机制，该异常会被继续抛出到当前方法外（如果是main就抛出到了main方法外）

若最终抛给了虚拟机，则会直接中断

package exception;
public class TryCatchDemo {
	public static void main(String[] args) {
		System.out.println("程序开始了");
		String str = null;
        //这句抛出异常java.lang.NullPointerException
		System.out.println(str.length());
		System.out.println("程序结束了");
	}
}

2、使用try-catch，捕获异常

在try语句块中，出错以下代码都不会被执行

package exception;
public class TryCatchDemo {
	public static void main(String[] args) {
		System.out.println("程序开始了");
		try{
			String str = null;
			System.out.println(str.length());
			//注意上面一句抛出异常后，下面代码都不会执行了
			System.out.println("！！！！！！！！！");
		}catch(NullPointerException e){
			System.out.println("空指针异常！");
		}
		System.out.println("程序结束了");
	}
}

3、catch可以写多个，针对try中出现的不同异常，有不同处理方式时，可以分别捕获它们

package exception;
public class TryCatchDemo {
	public static void main(String[] args) {
		System.out.println("程序开始了");
		try{
			//String str = null;
		    String str = "";
			System.out.println(str.length()); //空指针异常
			//注意上面一句抛出异常后，下面代码都不会执行了
			System.out.println("！！！！！！！！！");
			System.out.println(str.charAt(0));  //字符串下标越界
		}catch(NullPointerException e){
			System.out.println("空指针异常！");
		}catch(StringIndexOutOfBoundsException e){
			System.out.println("字符串下标越界！");
		}
		System.out.println("程序结束了");
	}
}

注意：为了避免存在我们没有发现的异常，我们可以在最后一个catch中写一个大的捕获
catch(Exception e) 但是，这个是用于我们找不出的异常时的处理办法，避免程序终止

package exception;
public class TryCatchDemo {
	public static void main(String[] args) {
		System.out.println("程序开始了");
		try{
			//String str = null;
		    //String str = "";
			String str = "a";
			System.out.println(str.length()); //空指针异常
			//注意上面一句抛出异常后，下面代码都不会执行了
			System.out.println("！！！！！！！！！");
			System.out.println(str.charAt(0));  //字符串下标越界
			System.out.println(Integer.parseInt(str));
		}catch(NullPointerException e){
			System.out.println("空指针异常！");
		}catch(StringIndexOutOfBoundsException e){
			System.out.println("字符串下标越界！");
		}catch(Exception e){
			System.out.println("对不起，我们遇到一个未知错误，请您上传到安全中心！");
		}
		System.out.println("程序结束了");
	}
}

ps.空指针异常与下标越界异常

空指针异常，是操作了一个指向的是空对象的指针报的错误
比如：当一个对象不存在时，又调用其方法；或者访问或者修改一个对象不存在的字段时

空指针异常NullPointerException
下标越界ArrayIndexOutOfBoundsException
他们两不是同一异常

NullPointerException 继承 RuntimeException
ArrayIndexOutOfBoundsException 继承 IndexOutOfBoundsException继承RuntimeException

空指针异常通常发生在对象操作时，有指针时，才会有空指针异常，把指针当做一个箭头就行了
下标越界是发生在数据存储时，访问存储的数据

4、finally块

语法位置：
finally块是异常处理机制中的最后一部分（一条处理机制中finally下面不能再写catch）
它可以直接跟在try语句块之后或者最后一个catch块之后

作用：
finally可以保证只要程序执行到try当中，无论是否出现异常，finally中的代码都必须执行

finally可以保证只要程序执行到try当中，无论是否出现异常，finally中的代码都必须执行

通常我们可以将释放资源（文件或流的关闭）这样的必须操作的代码放在这里

**注意：**如果try里面写了return的话，try-catch机制外的代码是不会运行的，
所以只有把一些必要操作放在finally中才一定会执行

package exception;
public class FinallyDemo {
	public static void main(String[] args) {
		System.out.println("程序开始了----------");
		try{
			//String str = null;
			String str = "";
			System.out.println(str.length());
            return;
		}catch(Exception e){
			System.out.println("出错了");
		}finally{
			System.out.println("finally块执行");
		}
		System.out.println("程序结束了----------");
	}
}

**finally的实际应用：**在IO中使用异常处理机制

package exception;

import java.io.FileOutputStream;
import java.io.IOException;

public class FinallyDemo2 {
	public static void main(String[] args) {
		FileOutputStream fos = null;
		try{
			fos = new FileOutputStream("fos.dat");
			fos.write(1);
		}catch(Exception e){
			System.out.println("出错了！");
		}finally{
			try {
				if(fos!=null){
					fos.close();
				}
			} catch (IOException e) {
			}
		}
	}
}
知识点：（面试中finally常见问题）

第一题：

package exception;
public class FinallyDemo3 {
	public static void main(String[] args) {
		System.out.println(test("0")+","+test(null)+","+test(""));
	}
	public static int test(String str){
		try{
			return str.charAt(0)-'0';
		}catch(NullPointerException e){
			return 1;
		}catch(Exception e){
			return 2;
		}finally{
			return 3;
		}
	}
}

问输出结果：正确为3,3,3 如果注释掉finally中的return，结果为0,1,2

因为finally是最后一定要运行的，所以finally中写return方法会覆盖掉try-catch语句中的return方法

第二题：问请分别说明final、finally、finalize

final：关键字，可修饰类、方法、属性

finally：try-catch异常处理机制的最后一块，是一定最后会运行的一部分

finalize：是Object类定义的一个方法，该方法是当GC释放该对象资源时，调用此方法，调用后该对象即被释放（一个对象的临终遗言，每个对象都会继承的一个方法）
注意：此方法若重写，里面不应当有耗时的操作（Object文档规定的）（比如死循环这样的操作）

5、AutoCloseable接口特性（为我们关闭流JDK7之后）

JDK7之后推出了一个特性：AutoCloseable

该特性旨在让我们在源代码中可以以更简化的代码完成在finally中关闭流

try语句后面可以追加小括号，我们可以把流的定义放在小括号里

在这里定义的流最终会被编译器改为在finally中关闭

注意：实现了AutoClosable的接口的才可以在这里定义
所有流和RandomAccessFile都实现了这个接口

这个特性为编译器支持，JVM并不认可，只是编译器为我们完成了我们没完成的功能

package exception;

import java.io.FileOutputStream;

public class AutoClosableDemo {
	public static void main(String[] args) {
		try(
			//实现了AutoClosable的接口的才可以在这里定义
			//所有流都实现了这个接口
			//这个特性为编译器支持，JVM并不认可，只是编译器为我们完成了我们没完成的功能
			//在这里定义的流最终会被编译器改为在finally中关闭
			FileOutputStream fos = new FileOutputStream("fos.dat");
		){
			fos.write(1);
		}catch(Exception e){
			System.out.println("出错了");
		}
	}
}

二、异常的抛出（throw关键字）

异常的抛出

**throw关键字：**用于主动抛出一个异常

通常以下情况我们会主动抛出异常：

  1. 程序遇到一个满足语法要求，但是不满足业务逻辑要求时，
    我们可以主动抛出异常，告知调用方不应当这样做
  2. 程序确实出现了异常，但是该异常不应当在当前代码片段被解决时，
    可以对外抛出给调用方解决

throws关键字： 当一个方法中使用throw抛出异常时，就要在当前方法上使用throws声明该异常的抛出，告知调用者去解决该异常

注：只有抛出RuntimeException及其子类型异常时可以不这样做

当调用一个含有throws声明异常抛出的方法时
编译器要求必须处理该异常，否则编译不通过

处理异常的方式有两种：

  1. 使用try-catch捕获并处理该异常
  2. 在当前方法上继续使用throws声明该异常抛出

使用哪种处理方式，根据具体责任来看，该归哪个方法管就抛出到哪个方法，让他具体处理
但记住，不要在main方法上面抛出throws，这是极不负责的表现

package exception;
/**
 * 使用当前类测试异常的抛出（throw）
 * @author Tian
 *
 */
public class Person {
	private int age;

	public int getAge() {
		return age;
	}

//	public void setAge(int age) {
//		this.age = age;
//	}
	
	public void setAge(int age) throws Exception{
		if(age<0||age>120){
			//RuntimeException的异常可以不用throws抛出异常声明
			//throw new RuntimeException("年龄不合法");
			throw new Exception("年龄不合法");
		}
		this.age = age;
	}
}


package exception;
public class ThrowDemo {
	public static void main(String[] args) {
		Person p = new Person();
		try {
			p.setAge(10);
		} catch (Exception e) {
			System.out.println("瞎输什么，滚！");
		}
		System.out.println(p.getAge());
	}
}

**注意：**由于throws是写在方法中的，所以要注意
子类重写父类含有throws声明异常抛出的方法时对throws的重写规则

  1. 允许抛出一模一样的异常
  2. 允许不再抛出任何异常
  3. 允许抛出部分异常
  4. 允许抛出父类抛出异常的子类型异常

不允许的情况：

  1. 不能抛出额外异常（超类中没有的，而且没有继承关系的）
  2. 不允许抛出比父类方法抛出异常的父类型异常（子类抛出的异常不能比父类的大）
package exception;

import java.awt.AWTException;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * 子类重写父类含有throws声明异常抛出的方法时
 * 对throws的重写规则
 * @author Tian
 *
 */
public class ThrowsDemo {
	public void dosome() throws IOException,AWTException{}
}
class Sub extends ThrowsDemo{
	//允许的情况
    //一模一样的允许
	//public void dosome() throws IOException,AWTException{}
	//允许不再抛出任何异常
	//public void dosome(){}
	//允许抛出部分异常
	//public void dosome() throws AWTException{}
	//允许抛出父类抛出异常的子类型异常
	public void dosome() throws FileNotFoundException{}
    
    //不允许的情况
	//不允许抛出额外异常，即：超类方法没有的异常，也不存在继承关系的异常
	//public void dosome() throws SQLException{}
	//不允许抛出比父类方法抛出异常的父类型异常（子类抛出的异常不能比父类的大）
	//public void dosome() throws Exception{}
}

三、异常API（异常中的常见方法）

Java异常可以分为可检测异常、非检测异常：

可检测异常：
可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或声明规则，
不捕捉这个异常，编译器就通不过，不允许编译

非检测异常:
非检测异常不遵循处理或者声明规则。
在产生此类异常时，不一定非要采取任何适当操作，编译器不会检查是否已经解决了这样一个异常

RuntimeException类属于非检测异常
因为普通JVM操作引起的运行时异常随时可能发生， 此类异常一般是由特定操作弓|发。
但这些操作在java应用程序中会频繁出现。因此它们不受编译器检查与处理或声明规则的限制。

常见RuntimeException（非检测异常/运行时异常）

  1. IllegalArgumentException
    抛出的异常表明向方法传递了一个不合法或不正确的参数
  2. NullPointerException
    当应用程序试图在需要对象的地方使用null时，抛出该异常
  3. ArrayIndexOutOfBoundsException
    当使用的数组下标超出数组允许范围时，抛出该异常
  4. ClassCastException
    当试图将对象强制转换为不是实例的子类时，抛出该异常
  5. NumberFormatException
    当应用程序试图将字符串转换成种数值类型，但该字符串不能转换为适当格式时,抛出该异常。

Exception常用API

printStackTrace();

该方法用于输出异常信息，将当前错误信息输出到控制台上

String getMessage();

获取错误消息（不是所有异常都有错误消息，但是大部分有）

package exception;
public class ExceptionApiDemo {
	public static void main(String[] args) {
		System.out.println("程序开始");
		try{
			String str = "a";
			System.out.println(Integer.parseInt(str));
		}catch(Exception e){
			//该方法用于输出异常信息，将当前错误信息输出到控制台上
			e.printStackTrace();
			//获取错误消息（不是所有异常都有错误消息，但是大部分有）
			String message = e.getMessage();
			System.out.println(message);
		}
		System.out.println("程序结束");
	}
}

四、自定义异常

自定义异常通常用来定义业务逻辑问题，这种异常java是没有提供的

自定义异常几步：

  1. 定义类，类名要见名知意（看见名字知道是什么错误）
  2. 需要继承自Exception，可以间接继承Exception
  3. 提供所有的构造方法

注意：Exception的父类实现了序列化接口的，定义其子类时最好手动添加序列化ID

package exception;

//需要继承自Exception，可以间接继承Exception
public class IllegalAgeException extends Exception{
	/**
	 * 定义其子类时最好手动添加序列化ID
	 */
	private static final long serialVersionUID = 1L;
	
	/*
	 * 下面构造器自动生成，Source中选择Constructors from Superclass的构造方法
	 */
	public IllegalAgeException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public IllegalAgeException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public IllegalAgeException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public IllegalAgeException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}
	
}

异常常考面试题

1、简述java中的异常体系

异常体系：

  1. Thorwable类（表示可抛出）是所有异常和错误的超类
  2. 两个直接子类为Error和Exception，分别表示错误和异常
  3. 异常类Exception又分为非检查型异常（Unchecked Exception）和检查异常（CheckedException），
    这两种异常有很大的区别，也称之为 运行时异常(RuntimeException)和非运行时异常

这些异常之间的区别与联系：

  1. Error与Exception
    Error是程序无法处理的错误，它是由JVM产生和抛出的，比如OutOfMemoryError、ThreadDeath等。
    这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

    Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常。
    程序中应当尽可能去处理这些异常。

  2. 非检查型异常（运行时异常）：
    在Java中所有RuntimeException的派生类都是非检查型异常，
    与检查型异常对比，非检查型异常可以不在函数声明中添加throws语句，调用函数上也不需要强制处理。
    常见的NullPointException、ClassCastException、IndexOutOfBoundsException是常见的非检查型异常。
    非检查型异常可以不使用try…catch进行处理，但是如果有异常产生，则异常将由JVM进行处理。

    检查型异常（非运行时异常）：

    在Java中所有不是RuntimeException派生的Exception都是检查型异常。
    当函数中存在抛出检查型异常的操作时该函数的函数声明中必须包含throws语句。
    调用改函数的函数也必须对该异常进行处理，如不进行处理则必须在调用函数上声明throws语句。

    检查型异常是JAVA首创的，在编译期对异常的处理有强制性的要求。在JDK代码中大量的异常属于检查型异常，包括IOException，SQLException等等。

2、简述java中的异常处理机制

try 可能出异常的代码块 catch(异常类型 异常) 异常的处理 finally 必定运行的代码块

补充 try、catch、finally三个语句块应注意的问题：

  1. try、catch、finally三个语句块均不能单独使用，三者可以组成 try…catch…finally、try…catch、try…finally三种结构，catch语句可以有一个或多个，finally语句最多一个。
  2. try、catch、finally三个代码块中变量的作用域为代码块内部，分别独立而不能相互访问。
    如果要在三个块中都可以访问，则需要将变量定义到这些块的外面。
  3. 多个catch块时候，最多只会匹配其中一个异常类且只会执行该catch块代码，而不会再执行其它的catch块，且匹配catch语句的顺序为从上到下，也可能所有的catch都没执行。
  4. 先Catch子类异常再Catch父类异常。
  5. JDK7之后推出了一个特性：AutoCloseable，简化的代码完成在finally中关闭流
    try语句后面可以追加小括号，我们可以把流的定义放在小括号里，在这里定义的流最终会被编译器改为在finally中关闭

3、throw和throws的区别

  1. throw：
    throw关键字是用于方法体内部，用来抛出一个Throwable类型的异常。
    如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。
    该方法的调用者也必须检查处理抛出的异常。
    如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。
  2. throws：
    throws关键字用于方法体外部的方法声明部分，用来声明方法可能会抛出某些异常。
    仅当抛出了检查异常，该方法的调用者才必须处理或者重新抛出该异常。
    当方法的调用者无力处理该异常的时候，应该继续抛出.

4、final、finally、finalize的区别

**final：**关键字，可修饰类、方法、属性

**finally：**try-catch异常处理机制的最后一块，是一定最后会运行的一部分

**finalize：**是Object类定义的一个方法，该方法是当GC释放该对象资源时，调用此方法，调用后该对象即被释放（一个对象的临终遗言，每个对象都会继承的一个方法）

5、列举几个常见的检查型异常和非检查型异常

检查型异常：

  1. IOException IO流异常
  2. SQLException

非检查型异常：

  1. NullPointerException 空指针异常
  2. ArrayIndexOutOfBoundsException 数组下标越界异常
  3. ClassCastException 强制类型转换异常

6、如何自定义一个异常

  1. 定义类，类名要见名知意（看见名字知道是什么错误）
  2. 需要继承自Exception，可以间接继承Exception
  3. 提供所有的构造方法
人生当苦
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java异常处理】检查型非检查型异常、try-catch、try-with-resources、throws、finally、getMessage、自定义异常、实现断言类
愿你怀着最初的梦走最艰难的路
02-23 457
异常处理 文章目录异常处理简介开发中的错误异常检查型、非检查型异常try、catch异常对象的常用方法（getMessage、printStackTrace）finallytry-with-resources 语句throwsthrow自定义异常使用异常的好处实现断言类 简介 开发中的错误 在开发 Java 程序的过程中，会遇到各种各样的错误： 语法错误 会导致编译失败，程序无法正常运行 逻辑错误 比如需要执行加法操作时，不小心写成了减法操作 运行时错误 在程序运行过程中产生的意外，会导致程序终止运行 在
Java异常的处理机制
最新发布
qq_39939541的博客
07-07 1869
finally块必定会被执行，通常用于释放资源或进行清理工作。除了Java提供的异常类之外，我们还可以自定义异常类来表示特定的异常情况。在Java中，可以通过创建自定义的类来定义自己的异常。自定义异常类通常需要继承自Java提供的异常类（如Exception或RuntimeException）或它们的子类。// 自定义异常类 public class MyException extends Exception {
Java异常处理机制
qq_51691274的博客
03-16 123
（4）如果try语句块在执行过程中发生异常，try语句块中剩下的代码都将被忽略，系统会自动生成相应的异常对象，包括异常的类型、异常出现时程序的运行状态及该异常的详细描述。发生异常时的执行顺序是，先执行catch语句块中return之前的语句，再执行finally语句块中的语句，最后执行catch语句块中的return语句退出。2）如果try语句块在执行过程中发生异常，并且这个异常与catch语句块中声明的异常类型匹配，那么try语句块中剩下的代码都将被忽略，而相应的catch语句将会被执行。
Java 异常处理机制理解
weixin_43934104的博客
09-26 148
java 异常处理机制 1、 java异常包括Exception（异常）和error（错误）。它们都继承自throwable。 Error一般指JVM出现的问题，程序无法做处理。Exception是程序本身可以处理的异常，分为运行时异常和非运行时异常。 2、 非运行时异常程序必须进行处理，要么try catch块进行捕获，要么通过throws 声明抛出，否则编译不通过，也称作可检查异常。运行时异常...
对于try-catch处理“被检查异常”实际应用的反思
zeng8129的博客
12-28 541
对于try-catch处理“被检查异常”实际应用的反思
高效Java异常处理机制
03-04
Java异常处理成为社区中讨论最多的话题之一。一些人认为Java语言中的已检查异常（CheckedExceptions）是一次失败的尝试。本文认为错误并不在于Java模型本身，而在于Java库设计人员没有认识到方法失败的两个基本原因...
java异常处理机制
01-07
java异常处理机制,异常的概念,发生的原因,throwable,捕获异常的简单思维导图
Java异常处理机制try catch流程详解
08-19
Java异常处理机制try catch流程详解 Java 异常处理机制是 Java 语言中一个非常重要的机制，它允许开发者捕获和处理运行时的异常，从而提高程序的鲁棒性和可靠性。下面是 Java 异常处理机制的详细介绍。 一、异常...
[ XJTUSE ]JAVA语言基础知识——6.3 异常的处理机制
weixin_47692652的博客
08-18 177
文章目录6.3 异常的处理机制6.3.1 非检查型异常处理6.3.2 检查型异常处理1、捕获异常2、声明抛出异常 6.3 异常的处理机制 Java的异常处理机制是如何工作的呢?无论是检查型异常还是非检查型异常，针对可能出现的异常，用户程序必须从以下两种处理方式中做出选择: 1 ) 在异常出现的方法中主动用try…catch句型处理。 2) 如果该方法中没有做出任何处理，就把异常抛给调用该方法的上一层方法，如果上一层方法由try-catch句型处理了，则到此为止，否则继续顺着方法调用的层次逐级向上抛出，沿着被
为什么推荐使用try-with-resources代替try-finally
冯冬冬的博客
12-21 1万+
这篇文章是我近期看了《Effective java》一书中总结的，来自其中第九条。为了对其理解的更加透彻，因此重新分析了一下，并加入了一些其他点。 本文的所有例子均在本地代码运行完毕 基于JDK版本1.8，运行环境eclipse 本文类名：TryWithResources，下文的堆栈信息也以此为基础 在java开发中，一些网络链接或者是文件资源都需要程序员去手动调用close方法关闭，比如InputStream、OutputStream和java.sql.Connection。如果忘关了就可能造成严重的
Java 异常处理机制（全）
qq_48010634的博客
12-06 6427
Java异常处理与异常体系结构
最全最详细的Java异常处理机制
波哩个波的博客
01-27 3万+
一、异常概述与异常体系结构 异常概述 在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。 程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常（开发过程中的语法错误和逻辑错误不是异常）。 Java程序在执行过程中所发生的异常事件可分为两类： ...
Java基础学习总结（86）——Java异常处理机制Exception抛出异常时throw和throws用法详解...
weixin_34290000的博客
11-23 359
什么时运行时异常？什么是非运行时异常？ 通俗的讲： 运行时异常：就是编译通过，运行时就崩了，比如数组越界。 非运行时异常：就是编译不通过，这时就得必须去处理了。不然就没法运行了。 全面的讲： Throwable 是所有 Java程序中错误处理的父类 ，有两种资类： Error 和 Exception 。 Error ：表示由JVM所侦测到的无法预期的错误，由于这是属于JVM层次的严重...
简述Java中的异常处理机制
weixin_44154020的博客
11-08 3130
1.首先我们应该知道什么是异常，异常是指Java程序运行时（非编译）所发生的非正常情况或错误。java对异常进行了分类，不同类型的异常使用了不同的java类，所有异常的根类为java.lang.Throwable.Throwable派生了2个子类：Error和Exception. 2.Error表示程序本身无法克服和恢复的一种严重错误，程序只有死的份，如内存溢出和死锁问题等系统问题。 3.Exce...
Java中的异常处理机制是什么
newflyer666的博客
06-19 1492
Java异常处理方式 Java通过面向对象的方法进行异常处理，一旦方法抛出异常，系统自动根据该异常对象寻找合适异常处理器（Exception Handler）来处理该异常，把各种不同的异常进行分类，并提供了良好的接口。在java中，每个异常都是一个对象，它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。Java的异常是通过五个关键字来实现的：try、catch、throw、throws和final
JavaSwing_2.6: JTextField（文本框）
热门推荐
谢TS的博客
07-09 8万+
JTextField，文本框。JTextField 用来编辑单行的文本。
Java的异常总结
代朝恒的博客
09-06 272
异常：在java程序中编译或运行时出现的以外 a、编译期异常  必须处理 b、运行时异常  尽量处理 Exception -->RuntimeException  -->NullPointerException   -->ArithmeticException -->IoException -->AWTException 常见异常： 1>数组下标越界异常 Arra
Java 中throws Exception的使用
Pei_hua100的专栏
06-08 1203
1、(终极解释！！！)throwsException放在方法后边，是throwsException表示的是本方法不处理异常，交给被调用处处理(如果你不希望异常层层往上抛，你就要用throws Exception)，而且被调用处必须处理。 2、throw new Exception表示人为的抛出一个异常，例如： publicbooleaninsert(Newsn){ try{ ..... }catch{ thrownewException("这是我自己抛出的一个异常，如果我看到此段信息表示...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值