java自定义异常,java自定义异常处理

本文目录一览：

• 1、java中自定义异常为何要继承exception类
• 2、java如何自定义一个可捕获的异常
• 3、java自定义异常问题
• 4、java自定义异常类问题
• 5、java自定义异常类
• 6、java自定义异常类 super() showMessage()

java中自定义异常为何要继承exception类

java.lang.Exception类是Java中所有异常的直接或间接父类。即Exception类是所有异常的根类。

1、异常的分类：

① 非运行时异常（Checked Exception）

② 运行时异常（Runtime Exception/Unchecked Exception）

public class Exception

extends Throwable

Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。

public class RuntimeException

extends Exception

RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。

可能在执行方法期间抛出但未被捕获的 RuntimeException 的任何子类都无需在 throws 子句中进行声明。

a) RuntimeException类直接继承自Exception类，称为运行时异常。Java中所有的运行时异常都直接或间接的继承自RuntimeException.

Java中所有的异常类都直接或间接的继承自Exception。

2、异常的处理：

对应非运行时异常，必须对其进行处理。处理方式有两种：

使用try…catch…finally语句块进行捕获

在产生异常的方法所在的方法声明throws Exception

对于运行时异常，可以不对其进行处理，也可以对其进行处理。一般情况下都不对其进行处理。

3、捕获异常：

try {

FileInputStream fs = new FileInputStream(“D:/temp/a.txt”);

} catch (FileNotFoundException e) {

System.out.println(“catch…”);

e.printStackTrace();

} finally{

System.out.println(“finally…”);

}

4、抛出和捕获异常：

4.1、把异常交给JVM处理：

public class ExceptionTest {

public static void execute() throws Exception {

System.out.println(“execute…”);

throw new Exception();

}

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

execute();

}

}

4.2、或者使用try catch语句块捕获异常：

public class ExceptionTest {

public static void execute() throws Exception {

System.out.println(“execute…”);

throw new Exception();

}

public static void main(String[] args) {

try {

execute();

} catch (Exception e1) {

e1.printStackTrace();

}

}

}

5、自定义异常：

自定义异常通常是定义一个继承自Exception类的子类。一般情况下我们都会直接继承自Exception类，而不会继承某个运行时的异常类。

5.1、创建自定义异常：

public class MyException extends Exception{

public MyException(){

super();

}

public MyException(String msg){

super(msg);

}

}

5.2、在类中使用异常：

public class ExceptionTest {

public static void execute(String a) throws MyException {

System.out.println(“execute…”);

if(“true”.equals(a)){

throw new MyException(“参数不能为 true”);

}

}

}

5.3、捕获自定义异常：

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

execute(“true”);

}

6、异常使用注意事项：

当使用多个catch语句块来捕获异常时，需要将父类的catch语句块放到子类型的catch块之后，这样才能保证后续的catch可能被执行，否则子类型的catch将永远无法到达，Java编译器会报编译错误。

如果try语句块中存在return语句，那么首先会执行finally语句块中的代码，然后才返回。

如果try语句块中存在System.exit(0)语句，那么久不会执行finally语句块的代码了，因为System.exit(0)会终止当前运行的JVM。程序在JVM终止前结束执行。

java如何自定义一个可捕获的异常

1）先定义一个类继承Exception（或者别的RuntimeException等）；

2）然后写个方法可能抛出这个异常，并且什么情况下会抛出异常；

3)调用这个方法，写try，catch语句，捕获这个异常；

小例子，你参考看下：

class UserNotFoundException extends RuntimeException {

public UserNotFoundException() {}

public UserNotFoundException(String message) {

super(message);

}

public void f() throws UserNotFoundException {

throw new UserNotFoundException(“用户名不对”);

} 

}

public class Exception  {

public static void main(String args[]) {

try {

new UserNotFoundException().f();

} catch (UserNotFoundException e) {

System.out.println(e.getMessage());

}

}

}

java自定义异常问题

class ParameterNumberException extends Exception{

ParameterNumberException(){

super(“参数个数异常！”);}

public String toString(){

return “ParameterNumberException”;}

}

class ParameterFormatException extends Exception{

ParameterFormatException(){

super(“参数格式异常！”);

public String toString(){

return “ParameterFomatException”;}

}

public class NullPointer2 {

public static void main(String args[])throws ParameterNumberException,ParameterFormatException{

try{

if(args.length2)

throw new ParameterNumberException();

else

throw new ParameterFormat();

}

catch(ParameterNumberException e){

System.out.println(e);

e.printStackTrace();}

catch(ParameterFomatException e){

System.out.println(e);

e.printStackTrace();}

}

}

java自定义异常类问题

异常类的理解，个人看法

是不是说输出异常的信息啊，在自定义类中输出异常的信息

然后在程序中当判断到输入的数据是小于0，调用小于0的异常类里的输出信息

大于100，就调用大于100的异常类里的输出信息

java自定义异常类

public void MyException extends Exception{

public MyExceprion(){

System.out.println(“自定义异常”);

}

}

public class Exam{

public static void mul() throws MyException{

if(自己写条件){

throw new MyException();

}

}

}

这个应该能看懂吧，我只是写了个结构没写完整程序的，你看懂这个就行，定义一个自定义异常，然后在你需要的地方抛出异常，在主方法中调用方法的时候达到一定条件就会抛出异常

java自定义异常类 super() showMessage()

//定义一个自己定义Exception类，名为MyException，然后继承Exception

class MyException extends Exception{

//重写构造方法

public MyException(String message){

super(message); //这句话的意思是调用Exception的有参构造方法。

}

}

//运行一下

public class ExceptionDemo{

public static void main(String[] args){

try{

throw new MyException(“我的异常”); //这里已经发生异常了，我抛出

}catch(MyException e){//这里写我们自定义的异常类

System.out.println(e.getMessage());//这句话是调用父类的getMessage方法，将“我的异常”输出。

}

}

/*public void showMessage(){

System.out.println(msg);

}*/ //这句话就是自定义showMessage方法，输出e.showMessage();//模仿父类异常，而不是重写父类异常的getMessage()方法

}