在本文中，我们将详细介绍JAVA自定义异常的各个方面，并为您提供关于java自定义异常类的相关解答，同时，我们也将为您带来关于java中常见的异常和自定义异常、Java之自定义异常、java基础-自定
在本文中，我们将详细介绍JAVA自定义异常的各个方面，并为您提供关于java自定义异常类的相关解答，同时，我们也将为您带来关于java 中常见的异常和自定义异常、Java 之 自定义异常、java 基础 - 自定义异常、Java 如何抛出异常、自定义异常的有用知识。
本文目录一览：
JAVA自定义异常（java自定义异常类）
package com.ninemax.ak.throwable;
public class MyException extends Exception {
private static final long serialVersionUID = 5584580732265547931L;
/**
* 错误编码
*/
private String errorCode;
/**
* 消息是否为属性文件中的Key
*/
private boolean propertiesKey = true;
public MyException(String message) {
super(message);
}
public MyException(String message, Throwable cause) {
super(message, cause);
}
public MyException(String message, String errorCode) {
this(message, errorCode, true);
}
public MyException(String message, String errorCode, Throwable cause) {
this(message, errorCode, cause, true);
}
public MyException(String message, String errorCode, boolean propertiesKey) {
super(message);
this.setErrorCode(errorCode);
this.setPropertiesKey(propertiesKey);
}
public MyException(String message, String errorCode, Throwable cause,
boolean propertiesKey) {
super(message, cause);
this.setErrorCode(errorCode);
this.setPropertiesKey(propertiesKey);
}
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public boolean isPropertiesKey() {
return propertiesKey;
}
public void setPropertiesKey(boolean propertiesKey) {
this.propertiesKey = propertiesKey;
}
}测试方法
package com.ninemax.ak.throwable;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import org.junit.Test;
public class MyExceptionTest {
@Test
public void run() throws MyException {
throw new MyException("不是整数", new Throwable());
}
@Test
@SuppressWarnings("all")
public void readFile() throws MyException {
try {
File file = new File("G:/极速PDF阅读器/JisuPdf.txt");
// 判断文件是否存在
if (file.exists()) {
System.out.println("File is exist!");
// 节点流
FileInputStream in = new FileInputStream(file);
// 转换流
InputStreamReader reader = new InputStreamReader(in);
// 字节流
BufferedReader buffer = new BufferedReader(reader);
// 添加内容
StringBuffer content = new StringBuffer();
// 按行读取
String line = "";
// 读取内容
while (null != (line = buffer.readLine())) {
content.append(line + "\n");
}
System.out.println("content:" + content);
} else {
throw new MyException("File is not exist！");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
java 中常见的异常和自定义异常
常见异常：
java.lang.nullpointerexception
这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）
2. java.lang.classnotfoundexception
这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。
3. java.lang.arithmeticexception
这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。
4. java.lang.arrayindexoutofboundsexception
这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。
5. java.lang.illegalargumentexception
这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。
6. java.lang.illegalaccessexception
这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。
其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。
算术异常类：ArithmeticExecption
空指针异常类：NullPointerException
类型强制转换异常：ClassCastException
数组负下标异常：NegativeArrayException
数组下标越界异常：ArrayIndexOutOfBoundsException
违背安全原则异常：SecturityException
文件已结束异常：EOFException
文件未找到异常：FileNotFoundException
字符串转换为数字异常：NumberFormatException
操作数据库异常：SQLException
输入输出异常：IOException
方法未找到异常：NoSuchMethodException
java.lang.AbstractMethodError
抽象方法错误。当应用试图调用抽象方法时抛出。
java.lang.AssertionError
断言错。用来指示一个断言失败的情况。
java.lang.ClassCircularityError
类循环依赖错误。在初始化一个类时，若检测到类之间循环依赖则抛出该异常。
java.lang.ClassFormatError
类格式错误。当Java虚拟机试图从一个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。
java.lang.Error
错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。
java.lang.ExceptionInInitializerError
初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。
java.lang.IllegalAccessError
违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。
java.lang.IncompatibleClassChangeError
不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下，容易引发该错误。
java.lang.InstantiationError
实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.
java.lang.InternalError
内部错误。用于指示Java虚拟机发生了内部错误。
java.lang.LinkageError
链接错误。该错误及其所有子类指示某个类依赖于另外一些类，在该类编译之后，被依赖的类改变了其类定义而没有重新编译所有的类，进而引发错误的情况。
java.lang.NoClassDefFoundError
未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。
java.lang.NoSuchFieldError
域不存在错误。当应用试图访问或者修改某类的某个域，而该类的定义中没有该域的定义时抛出该错误。
java.lang.NoSuchMethodError
方法不存在错误。当应用试图调用某类的某个方法，而该类的定义中没有该方法的定义时抛出该错误。
java.lang.OutOfMemoryError
内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。
java.lang.StackOverflowError
堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。
java.lang.ThreadDeath
线程结束。当调用Thread类的stop方法时抛出该错误，用于指示线程结束。
java.lang.UnknownError
未知错误。用于指示Java虚拟机发生了未知严重错误的情况。
java.lang.UnsatisfiedLinkError
未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。
java.lang.UnsupportedClassVersionError
不支持的类版本错误。当Java虚拟机试图从读取某个类文件，但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候，抛出该错误。
java.lang.VerifyError
验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。
java.lang.VirtualMachineError
虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。
java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
java.lang.ArrayStoreException
数组存储异常。当向数组中存放非数组声明类型对象时抛出。
java.lang.ClassCastException
类造型异常。假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。
java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
java.lang.CloneNotSupportedException
不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。
java.lang.EnumConstantNotPresentException
枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象，但该枚举对象并不包含常量时，抛出该异常。
java.lang.Exception
根异常。用以描述应用程序希望捕获的情况。
java.lang.IllegalAccessException
违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法，而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。
java.lang.IllegalMonitorStateException
违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象（O）的监控器或者通知其他线程等待该对象（O）的监控器时，抛出该异常。
java.lang.IllegalStateException
违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态，而调用了该方法时，抛出该异常。
java.lang.IllegalThreadStateException
违法的线程状态异常。当县城尚未处于某个方法的合法调用状态，而调用了该方法时，抛出异常。
java.lang.IndexOutOfBoundsException
索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。
java.lang.InstantiationException
实例化异常。当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。
java.lang.InterruptedException
被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。
java.lang.NegativeArraySizeException
数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。
java.lang.NoSuchFieldException
属性不存在异常。当访问某个类的不存在的属性时抛出该异常。
java.lang.NoSuchMethodException
方法不存在异常。当访问某个类的不存在的方法时抛出该异常。
java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。
java.lang.NumberFormatException
数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。
java.lang.RuntimeException
运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。
java.lang.SecurityException
安全异常。由安全管理器抛出，用于指示违反安全情况的异常。
java.lang.StringIndexOutOfBoundsException
字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。
java.lang.TypeNotPresentException
类型不存在异常
用户自定义异常：
一、第一种定义方式，继承Exception类
public class MyFirstException extends Exception {
public MyFirstException() {
super();
}
public MyFirstException(String msg) {
super(msg);
}
public MyFirstException(String msg, Throwable cause) {
super(msg, cause);
}
public MyFirstException(Throwable cause) {
super(cause);
}
//自定义异常类的主要作用是区分异常发生的位置，当用户遇到异常时，
//根据异常名就可以知道哪里有异常，根据异常提示信息进行修改。
}二、 第二种定义方式：继承Throwable 类
public class MySecondException extends Throwable {
public MySecondException() {
super();
}
public MySecondException(String msg) {
super(msg);
}
public MySecondException(String msg, Throwable cause) {
super(msg, cause);
}
public MySecondException(Throwable cause) {
super(cause);
}
}
三、测试
/**
* 自定义异常类的使用
* @author new
*
*/
public class TestMyException {
public static void firstException() throws MyFirstException{
throw new MyFirstException("/"firstException()/" method occurs an exception!");
}
public static void secondException() throws MySecondException{
throw new MySecondException("/"secondException()/" method occurs an exception!");
}
public static void main(String[] args) {
try {
TestMyException.firstException();
TestMyException.secondException();
} catch (MyFirstException e1){
System.out.println("Exception: " + e1.getMessage());
e1.printStackTrace();
} catch (MySecondException e2){
System.out.println("Exception: " + e2.getMessage());
e2.printStackTrace();
}
//当一个try块后面跟着多个catch块时，如果发生的异常匹配第一个catch块的参数，便将异常处理权利交给第一个catch块。
//如果发生的异常与第一个catch块不匹配，便看是否与第二个catch块匹配，依次下去，如果到最后依然无法匹配该异常，
//便需要在方法声明中添加一条throw语句，将该异常抛出。
//因此，在有多个catch块，而且每次处理的异常类型具有继承关系时，应该首先catch子类异常，再catch父类异常。
//比如，如果MySecondException继承MyFirstException，那么最好将catch (MySecondException e2)放在前面，
//把catch (MyFirstException e1)放在后面。
}
Java 之 自定义异常
1、为什么需要自定义异常类
Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是没有定义好的,此时我们根据自己业务的异常情况来定义异常类。
一些异常都是 Java 内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题，这时就需要我们自定义异常。
2、什么是自定义异常类
在开发中根据自己业务的异常情况来定义异常类。
3、异常类如何定义
（1）自定义一个编译器异常：自定义类 并继承 java.lang.Exception
（2）自定义一个运行时期的异常类：自定义类，并继承于 java.lang.RuntimeException。
建议：保留两种构造器的形式
①无参构造
②带给父类的message属性赋值的构造器
语法格式：
public class XXXExcepiton extends Exception | RuntimeException{
添加一个空参数的构造方法
添加一个带异常信息的构造方法
}
注意：
（1）自定义异常类一般都是以Exception结尾,说明该类是一个异常类
（2）自定义异常类,必须的继承Exception或者RuntimeException
继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch
继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)
Demo：
1 public class DemoRegisterException {
2 // 1.使用数组保存已经注册过的用户名(数据库)
3 static String[] usernames = {"张三","李四","王五"};
4
5 public static void main(String[] args) /*throws RegisterException*/ {
6 //2.使用Scanner获取用户输入的注册的用户名(前端,页面)
7 Scanner sc = new Scanner(System.in);
8 System.out.println("请输入您要注册的用户名:");
9 String username = sc.next();
10 checkUsername(username);
11
12 }
13
14 //3.定义一个方法,对用户输入的中注册的用户名进行判断
15 public static void checkUsername(String username) /*throws RegisterException*/ {
16 //遍历存储已经注册过用户名的数组,获取每一个用户名
17 for (String name : usernames) {
18 //使用获取到的用户名和用户输入的用户名比较
19 if(name.equals(username)){
20 //true:用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
21 try {
22 throw new RegisterException("亲，该用户名已经被注册");
23 } catch (RegisterException e) {
24 e.printStackTrace();
25 return; //结束方法
26 }
27 }
28 }
29
30 //如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
31 System.out.println("恭喜您,注册成功!");
32 }
33 }
34
35 // 异常类
36 public class RegisterException extends /*Exception*/ RuntimeException{
37 //添加一个空参数的构造方法
38 public RegisterException(){
39 super();
40 }
41
42 /*
43 添加一个带异常信息的构造方法
44 查看源码发现,所有的异常类都会有一个带异常信息的构造方法,方法内部会调用父类带异常信息的构造方法,让父类来处理这个异常信息
45 */
46 public RegisterException(String message){
47 super(message);
48 }
49 }
java 基础 - 自定义异常
在软件开发过程中，我们可能需要自定义一些异常来描述一个程序中异常的信息，并以此来区分其他的异常信息，这样，我们就需要自定义一些异常信息。
那如何实现自定义异常呢？
通过了解，类 java.lang.Throwable 是所有异常类的基类，它包括两直接已知子类：Exception 和 Error，Exception 类用于描述程序能够捕获的异常，如 ClassNotFoundException，IOException 等。Error 类用于指示合理的应用程序不应该试图捕获的严重问题，如虚拟机错误 VirtualMachineError，io 异常 IOError 等
自定义异常类可以继承 Throwable 类或者 Exception，而不要继承 Error 类。自定义异常类之间也可以有继承关系，
需要为自定义异常类设计构造方法，以方便构造自定义异常对象。
代码示例：
ArgsException.java
package net.test.test;
public class ArgsException extends Exception {
//继承Exception实现自定义异常
private static final long serialVersionUID = 1L;
public ArgsException(String msg) {
super(msg);
}
public ArgsException(String msg, Throwable cause) {
super(msg, cause);
}
public ArgsException(Throwable cause) {
super(cause);
}
}Args2Exception.java
package net.test.test;
public class Args2Exception extends Throwable{
//继承Throwable基类实现自定义异常
private static final long serialVersionUID = 1L;
public Args2Exception(String msg) {
super(msg);
}
public Args2Exception(String msg, Throwable cause) {
super(msg, cause);
}
public Args2Exception(Throwable cause) {
super(cause);
}
}TestException.java
package net.test.test;
public class TestException {
public void e() throws ArgsException{
//继承Exception实现自定义异常
throw new ArgsException("这是一个自定义异常1");
}
public void t() throws Args2Exception{
//继承Throwable基类实现自定义异常
throw new Args2Exception("这是一个自定义异常2");
}
public static void main(String[] args) {
try {
new TestException().e();
} catch (ArgsException e) {
e.printStackTrace();
}
try {
new TestException().t();
} catch (Args2Exception e) {
e.printStackTrace();
}
}
}
运行结果：
net.test.test.ArgsException: 这是一个自定义异常1
at net.test.test.TestException.e(TestException.java:6)
at net.test.test.TestException.main(TestException.java:19)
net.test.test.Args2Exception: 这是一个自定义异常2
at net.test.test.TestException.t(TestException.java:10)
at net.test.test.TestException.main(TestException.java:25)
Exception in thread "main" net.test.test.ArgsError: 这是一个自定义异常3
at net.test.test.TestException.error(TestException.java:14)
at net.test.test.TestException.main(TestException.java:30)
Java 如何抛出异常、自定义异常
一、异常的抛出
1、定义 ： 一个方法不处理这个异常，而是调用层次向上传递，谁调用这个方法，这个异常就由谁来处理。
2、throw : 将产生的异常抛出(强调的是动作)，抛出的既可以是异常的引用，也可以是异常对象。（位置: 方法体内）
3、throws : 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常（可以是一种类型，也可以是多种类型，用逗号隔开）（位置: 写在方法名 或方法名列表之后 ，在方法体之前。）
注意 ： 调用可能会抛出异常的方法，必须添加try-catch代码块尝试去捕获异常 或者 添加throws 声明 来将异常 抛出给更上一层的调用者进行处理,这里需要注意一个细节:新的异常包含原始异常的所有信息，根据这个我们可以去追溯最初异常发生的位置，
如下图所示
4、简单使用
// 定义一个方法,抛出 数组越界和算术异常（多个异常 用 "," 隔开）
public void Test1(int x) throws ArrayIndexOutOfBoundsException,ArithmeticException{
System.out.println(x);
if(x == 0){
System.out.println("没有异常");
return;
}
//数据越界异常
else if (x == 1){
int\[\] a = new int\[3\];
a\[3\] = 5;
}
//算术异常
else if (x == 2){
int i = 0;
int j = 5/0;
}
}
在main方法中调用
public static void main(String[] args) {
//创建对象
ExceptionInital object = new ExceptionInital();
// 调用会抛出异常的方法，用try-catch块
try{
object.Test1(0);
}catch(Exception e){
System.out.println(e);
}
// 数组越界异常
try{
object.Test1(1);
}catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组越界异常:"+e);
}
// 算术异常
try{
object.Test1(2);
}catch(ArithmeticException e){
System.out.println("算术异常:"+e);
}
//使用 throw 抛出异常(可以抛出异常对象，也可以抛出异常对象的引用)
try{
ArrayIndexOutOfBoundsException exception = new ArrayIndexOutOfBoundsException();
throw exception;//new ArrayIndexOutOfBoundsException();
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("thorw抛出异常:"+e);
}
}
public static void main(String[] args) {
//创建对象
ExceptionInital object = new ExceptionInital();
// 调用会抛出异常的方法，用try-catch块
try{
object.Test1(0);
}catch(Exception e){
System.out.println(e);
}
// 数组越界异常
try{
object.Test1(1);
}catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组越界异常:"+e);
}
// 算术异常
try{
object.Test1(2);
}catch(ArithmeticException e){
System.out.println("算术异常:"+e);
}
//使用 throw 抛出异常(可以抛出异常对象，也可以抛出异常对象的引用)
try{
ArrayIndexOutOfBoundsException exception = new ArrayIndexOutOfBoundsException();
throw exception;//new ArrayIndexOutOfBoundsException();
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("thorw抛出异常:"+e);
}
}
public static void main(String[] args) {
//创建对象
ExceptionInital object = new ExceptionInital();
// 调用会抛出异常的方法，用try-catch块
try{
object.Test1(0);
}catch(Exception e){
System.out.println(e);
}
// 数组越界异常
try{
object.Test1(1);
}catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组越界异常:"+e);
}
// 算术异常
try{
object.Test1(2);
}catch(ArithmeticException e){
System.out.println("算术异常:"+e);
}
//使用 throw 抛出异常(可以抛出异常对象，也可以抛出异常对象的引用)
try{
ArrayIndexOutOfBoundsException exception = new ArrayIndexOutOfBoundsException();
throw exception;//new ArrayIndexOutOfBoundsException();
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("thorw抛出异常:"+e);
}
}
运行结果：
总结下 throw 和throws 关键字的区别
1、写法上 : throw 在方法体内使用，throws 函数名后或者参数列表后方法体前
2、意义 ： throw 强调动作，而throws 表示一种倾向、可能但不一定实际发生
3、throws 后面跟的是异常类，可以一个，可以多个，多个用逗号隔开。throw 后跟的是异常对象，或者异常对象的引用。
4、throws 用户抛出异常，当在当前方法中抛出异常后，当前方法执行结束（throws 后，如果有finally语句的话，会执行到finally语句后再结束。）。可以理解成return一样。
##二、自定义异常
前面所讲的异常，都是系统自带的，系统自己处理，但是很多时候项目会出现特有问题，而这些问题并未被java所描述并封装成对象，所以对于这些特有的问题可以按照java的对问题封装的思想，将特有的问题进行自定义异常封装。在Java中要想创建自定义异常，需要继承Throwable或者他的子类Exception。
语法：
class 自定义异常类 extends 异常类型(Exception){
// 因为父类已经把异常信息的操作都完成了，所在子类只要在构造时，将异常信息传递给父类通过super 语句即可。
// 重写 有参 和 无参 构造方法
}
例如：
public class CustomException extends Exception {
//无参构造方法
public CustomException(){
super();
}
//有参的构造方法
public CustomException(String message){
super(message);
}
// 用指定的详细信息和原因构造一个新的异常
public CustomException(String message, Throwable cause){
super(message,cause);
}
//用指定原因构造一个新的异常
public CustomException(Throwable cause) {
super(cause);
}
}
// 备注： 这些方法怎么来的？ 重写父类Exception的方法，那么如何查看Exception具有哪些API，快捷键：选中Exception, command+单击。windows系统 ：选中Exception, control+单击。
自定义异常的使用例子:
自定义test1()方法，抛出 "我喝酒了"的异常信息，test2()方法调用test1()方法，并将异常包装成RuntimeException类型的异常，继续抛出，在main方法中调用test2()方法，并尝试捕获异常
public void test2() {
try{
test1();
}catch (CustomException e){
RuntimeException exception = new RuntimeException(e);
//exception.initCause(cause)
throw exception;
}
}
public void test1() throws CustomException{
throw new CustomException("我喝酒了");
}
// main方法
public static void main(String\[\] args) {
CustomExceptionInital object = new CustomExceptionInital();
//try{
object.test2();
//}catch(Exception e){
//e.printStackTrace();
//}
}
输出结果:
关于JAVA自定义异常和java自定义异常类的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于java 中常见的异常和自定义异常、Java 之 自定义异常、java 基础 - 自定义异常、Java 如何抛出异常、自定义异常等相关知识的信息别忘了在本站进行查找喔。
本文标签：
