本文目录一览：
- 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()方法
}
