Question

我是Java自定义异常的新手。我看到很多关于如何创建它们的例子，但有两个问题我找不到答案：

1）可以在它想要的对象类中定义自定义异常，还是必须在它自己的类文件中？

2）无论位置如何，可以在单个类文件中定义多个自定义异常，还是每个自定义异常都需要自己的类文件？

非常感谢一些代码段。

感谢。

Answer 1

异常是类，所以很明显它们都需要自己的类。它可以像往常一样是普通类，内部类或嵌套类。

Answer 2

因为例外是类，所以下面给出了一些代码片段：

Java Custom Exception:

<强> InvalidAgeException.java

class InvalidAgeException extends Exception{  
 InvalidAgeException(String s){  
  super(s);  
 }  
}

<强> TestCustomException1.java

class TestCustomException1{  

   static void validate(int age)throws InvalidAgeException{  
     if(age<18)  
      throw new InvalidAgeException("not valid");  
     else  
      System.out.println("welcome to vote");  
   }  

   public static void main(String args[]){  
      try{  
      validate(13);  
      }catch(Exception m){System.out.println("Exception occured: "+m);}  

      System.out.println("rest of the code...");  
  }  
}

<强>输出：

Output:Exception occured: InvalidAgeException:not valid
       rest of the code...

Answer 3

1）是的：

public class Entity
{
   public void foo() throws EntityException
   {
      ...
      throw new EntityException();
   }

   public static class EntityException extends Exception
   {
   ...
   }
}

2）您可以将每个自定义异常包装在容器类中，如下所示：

public class CustomExceptions
{
   public static class CustomExceptionA extends Exception
   {
   ...
   }

   public static class CustomExceptionB extends Exception
   {
   ...
   }
}

Answer 4

以下是与您的问题相关的示例。

Exception与普通类一样，可以是嵌套的，内部的，匿名的或顶级的。

这是一个确实需要遵循的规则：已检查的异常是Exception的子类，而未检查的是RunTimeExceptions的子类（即使RTE是异常，这是方式去）

来源

public class MyException extends Exception{

    public MyException (String msg) {
        super(msg);
    }

}

class DifferentExceptions {

    class InnerException extends Exception {
        public InnerException(String msg) {
            super(msg);
        }
    }

    static class NestedException extends Exception {
        public NestedException(String msg) {
            super(msg);
        }
    }

    public static void main(String[] args) throws Exception {
        int example = 0;

        switch(example) {
        case 1 : throw new MyException("msg") ; 
        case 2 : throw new DifferentExceptions().new InnerException("msg") ; 
        case 3 : throw new DifferentExceptions.NestedException("msg") ; 
        default : throw new Exception("Not found") ;
        }
    }

}

Answer 5

1）自定义异常类可以在它所针对的类中定义，也可以在单独的类中定义。

前者的例子 - ThrowingClass.java：

public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

    public void throwingMethod() throws ThrownInnerException {
        throw new ThrownInnerException();
    }
}

后者的例子 - ThrownException.java：

public class ThrownException extends Exception {
    public ThrownException() {};
}

和ThrowingClass.java：

public class ThrowingClass {
    public void throwingMethod() throws ThrownException {
        throw new ThrownException();
    }
}

2）可以在单个类文件中定义多个自定义异常类。每个自定义异常类都不需要自己的类文件。

示例 - MultiThrowingClass.java：

public class MultiThrowingClass {
    public static class ThrownExceptionTypeOne extends Exception {
        public ThrownExceptionTypeOne() {};
    }

    public static class ThrownExceptionTypeTwo extends Exception {
        public ThrownExceptionTypeTwo() {};
    }

    public void throwingMethodOne() throws ThrownExceptionTypeOne {
        throw new ThrownExceptionTypeOne();
    }

    public void throwingMethodTwo() throws ThrownExceptionTypeTwo {
        throw new ThrownExceptionTypeTwo();
    }
}

Java中的每个自定义异常都需要自己的类吗？

5 个答案:

来源