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

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

java

Java中的每个自定义异常都需要自己的类吗。。？,java,custom-exceptions,Java,Custom Exceptions,我不熟悉Java自定义异常。我看到了许多关于如何创建它们的示例，但有两个问题我找不到答案： 1）自定义异常可以在其目标对象类中定义，还是必须在其自己的类文件中定义 2）无论位置如何，可以在单个类文件中定义多个自定义异常，还是每个自定义异常都需要自己的类文件一些代码片段将不胜感激谢谢。例外是类，所以很明显它们每个人都需要自己的类。它可以像往常一样是普通类、内部类或嵌套类。异常是类，所以显然它们每个都需要自己的类。它可以是普通类、内部类或嵌套类。类也是例外，下面给出了一些代码片段： In

我不熟悉Java自定义异常。我看到了许多关于如何创建它们的示例，但有两个问题我找不到答案：

1）自定义异常可以在其目标对象类中定义，还是必须在其自己的类文件中定义

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

一些代码片段将不胜感激

谢谢。

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

异常是类，所以显然它们每个都需要自己的类。它可以是普通类、内部类或嵌套类。

类也是例外，下面给出了一些代码片段：

InvalidAgeException.java

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

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...");  
  }  
}

TestCustomException1.java

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

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...");  
  }  
}

作为例外，类也是如此，下面给出了一些代码片段：

InvalidAgeException.java

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

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...");  
  }  
}

TestCustomException1.java

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

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...");  
  }  
}

1）是的：

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

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

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

1）是的：

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

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

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

这里有一些与你的问题相关的例子

与普通类一样，

异常可以是嵌套的、内部的、匿名的或顶级的
但是有一条规则确实需要遵循：选中的异常是异常的子类
，而未选中的异常是运行时异常的子类
（即使RTE是异常，这也是一种方法）

来源
这里有一些与你的问题相关的例子
与普通类一样，异常可以是嵌套的、内部的、匿名的或顶级的
但是有一条规则确实需要遵循：选中的异常是异常的子类
，而未选中的异常是运行时异常的子类
（即使RTE是异常，这也是一种方法）

来源
1） 自定义异常类可以在其预期的类中定义，也可以在单独的类中定义
前者的示例-ThrowingClass.java
：
public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

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

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

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

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();
    }
}

后者的示例-ThrownException.java
：
public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

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

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

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

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();
    }
}

和ThrowingClass.java
：
public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

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

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

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

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();
    }
}

2） 可以在单个类文件中定义多个自定义异常类。每个自定义异常类不需要自己的类文件
示例-MultiThrowingClass.java
：
public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

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

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

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

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();
    }
}

1） 自定义异常类可以在其预期的类中定义，也可以在单独的类中定义
前者的示例-ThrowingClass.java
：
public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

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

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

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

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();
    }
}

后者的示例-ThrownException.java
：
public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

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

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

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

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();
    }
}

和ThrowingClass.java
：
public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

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

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

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

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();
    }
}

2） 可以在单个类文件中定义多个自定义异常类。每个自定义异常类不需要自己的类文件
示例-MultiThrowingClass.java
：
public class ThrowingClass {
    public static class ThrownInnerException extends Exception {
        public ThrownInnerException() {};
    }

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

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

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

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();
    }
}

对于1）和2），您是指“自定义异常类”还是“自定义异常对象”？我这样问是因为可以通过在抛出之前将其消息或其他字段设置为自定义值来自定义抛出的异常。@MarkA.Fitzgerald消息可以自定义，但抛出的异常保持不变。对于1）和2），您是指“自定义异常类”还是“自定义异常对象”？我这样问是因为可以通过在抛出之前将其消息或另一个字段设置为自定义值来自定义抛出的异常。@MarkA.Fitzgerald消息可以自定义，但抛出的异常保持不变。