Java 同时抛出两个异常

我有以下java方法

public static double realDivision(Integer num, Double denom) {
  double result = 0.0;
  try{
      result=(double)num/(double)denom;
  }
  catch (ArithmeticException e){
    System.err.println("Smart up Goof");
    e.printStackTrace(System.err);
  }
  return result;

}

我在这里试图实现的是让异常更具描述性。当其中一个数字为null时，如何让Java稍微聪明一点并抛出NullPointerException，当两个输入都等于零时，如何抛出类似UndefinedNumber的异常。关于用非零分子除以零，它也应该更具表现力。我该怎么做

编辑

---

我不想要一堆条件，比如空检查或零检查。我希望Java知道为什么会发生算术异常或NPE，并抛出精确的异常。如果我能让java做到这一点，我就可以按它应该的方式编写错误处理代码。

您只需在

try-catch

块中添加检查即可。 比如：

if ((num == null) || (denum == null))
{
   throw new NullPointerException("Argument is null");
}

然而，我应该对使用这样的未检查异常有点谨慎，因为它们会在不强制调用方捕获的情况下使堆栈冒泡

也许创建自己的异常并声明抛出它的方法会更好

在编辑问题后更新

为什么不简单地将其更改为：

public static double realDivision(int num, double denom) 
{
  return (double) num / denom;    
}

参数现在是原语而不是对象，因此它们不能为

null

。传递给函数的参数仍然可以是

Integer

和

Double

的实例，Java的自动装箱功能将为您进行转换（如果

为null，则抛出
异常
）

在这种情况下，如果需要，您需要手动执行的唯一检查是
denom
是否为
0
。这是因为在
double
的情况下，Java返回无穷大，而不是抛出
算术异常
，因为实际上这就是答案，并且在某些双精度计算中非常有用。如果您使用的是整数，则会出现
算术异常
 只需在
try-catch
块中添加检查即可。
比如：

if ((num == null) || (denum == null))
{
   throw new NullPointerException("Argument is null");
}

然而，我应该对使用这样的未检查异常有点谨慎，因为它们会在不强制调用方捕获的情况下使堆栈冒泡

也许创建自己的异常并声明抛出它的方法会更好

在编辑问题后更新

为什么不简单地将其更改为：

public static double realDivision(int num, double denom) 
{
  return (double) num / denom;    
}

参数现在是原语而不是对象，因此它们不能为
null
。传递给函数的参数仍然可以是
Integer
和
Double
的实例，Java的自动装箱功能将为您进行转换（如果
为null，则抛出
异常
）

在这种情况下，如果需要，您需要手动执行的唯一检查是
denom
是否为
0
。这是因为在
double
的情况下，Java返回无穷大，而不是抛出
算术异常
，因为实际上这就是答案，并且在某些双精度计算中非常有用。如果您使用的是整数，则会出现
算术异常
 您需要区分两个变量为空和值为零。
如果您像这样运行程序，其中两个变量为null，则会出现所需的异常：

public class Arithmetics {      
      public static double realDivision(Integer num, Double denom) {
          double result = 0.0;
          try{
              result=(double)num/(double)denom;
          }
          catch (ArithmeticException e){
            System.err.println("Smart up Goof");
            e.printStackTrace(System.err);
          }
          return result;

        }

    public static void main(String[] args) {            
        double results=Arithmetics.realDivision(null, null);
        System.out.println(results);

    }

}

Exception in thread "main" java.lang.NullPointerException
    at Arithmetics.realDivision(Arithmetics.java:7)
    at Arithmetics.main(Arithmetics.java:19)

已编辑
而且。。。如果使用值

double results=Arithmetics.realDivision(new Integer(0), new Double(0));

结果是

NaN

infinite

如果你使用

double results=Arithmetics.realDivision(new Integer(1), new Double(0));

结果是

NaN

infinite

您需要区分两个变量为null和值为零。
如果您像这样运行程序，其中两个变量为null，则会出现所需的异常：

public class Arithmetics {      
      public static double realDivision(Integer num, Double denom) {
          double result = 0.0;
          try{
              result=(double)num/(double)denom;
          }
          catch (ArithmeticException e){
            System.err.println("Smart up Goof");
            e.printStackTrace(System.err);
          }
          return result;

        }

    public static void main(String[] args) {            
        double results=Arithmetics.realDivision(null, null);
        System.out.println(results);

    }

}

Exception in thread "main" java.lang.NullPointerException
    at Arithmetics.realDivision(Arithmetics.java:7)
    at Arithmetics.main(Arithmetics.java:19)

已编辑
而且。。。如果使用值

double results=Arithmetics.realDivision(new Integer(0), new Double(0));

结果是

NaN

infinite

如果你使用

double results=Arithmetics.realDivision(new Integer(1), new Double(0));

结果是

NaN

infinite

Java已经抛出了两个不同的异常，不是同时抛出，而是根据其中一个发生的情况抛出。也许你的意思是如何捕捉两个可能不同的异常？
例如：

public static double realDivision(Integer num, Double denom) {
          double result = 0.0;
          try{
              if(num.intValue()==0){

              }
              result=(double)num/(double)denom;
          }
          catch (ArithmeticException e){
            System.err.println("Smart up Goof");
            e.printStackTrace(System.err);
          }
          catch (NullPointerException e){
                System.err.println("One of the numbers is null. I am smart. Java");
                e.printStackTrace(System.err);
              }
          return result;

        }

但是请注意，在这种情况下，不会抛出算术异常，因为您使用的是浮点。如果使用integer，则会出现异常。
Java已经抛出了两个不同的异常，不是同时抛出的，而是根据发生的异常。也许你的意思是如何捕捉两个可能不同的异常？
例如：

public static double realDivision(Integer num, Double denom) {
          double result = 0.0;
          try{
              if(num.intValue()==0){

              }
              result=(double)num/(double)denom;
          }
          catch (ArithmeticException e){
            System.err.println("Smart up Goof");
            e.printStackTrace(System.err);
          }
          catch (NullPointerException e){
                System.err.println("One of the numbers is null. I am smart. Java");
                e.printStackTrace(System.err);
              }
          return result;

        }

但是请注意，在这种情况下，不会抛出算术异常，因为您使用的是浮点。如果使用integer，则会出现异常。
您可以编写自己的异常，然后手动抛出这些异常……您无法提高Java的智能性。您必须为此编写代码。还要指出的是，两个异常不会同时抛出，其中只有一个会抛出。您需要更精确的异常做什么？你打算用它做什么？如果只是为了打印一条更好的消息，那么您可以在让java变得更智能的catch{..}Lol中这样做！您可以编写自己的异常，然后手动抛出这些异常……您无法提高Java的智能性。您必须为此编写代码。还要指出的是，两个异常不会同时抛出，其中只有一个会抛出。您需要更精确的异常做什么？你打算用它做什么？如果只是为了打印一条更好的消息，那么您可以在让java变得更智能的catch{..}Lol中这样做！如果你想处理这个问题，在划分之前先用逻辑。例如，如果（num.intValue（）==0）{}…并且如果要处理该问题，请在除法之前使用逻辑。例如，如果（num.intValue（）==0）{}。。。