Question

我在“Point”类中有这个方法：

public Point sumPoints(Point p) {
        if(dimension != p.getDimension())
            throw new RuntimeException("Wrong dimensions.");

        Double[] coord = new Double[dimension];
        for(int i = 0; i < dimension; i++)
            coord[i] = coordinates[i] + p.getCoord(i);
        Point P = new Point(coord);

        return P;

这个想法是点可以是n维的，所以我应该在尝试添加它们之前检查点的尺寸是否匹配。问题是，在它们不匹配的情况下，我不能返回特定值（例如-1，就像我在C中所做的那样），因为返回类型是Point。

在这些情况下我该怎么办？ RuntimeExeption是一个好的做法吗？

Answer 1

由于多种原因，异常处理是在Java中实现错误处理的一种更优雅的方式。

错误代码

返回错误代码works well in C，特别是因为能够在C中将指针作为函数参数传递：这样，您可以例如在函数内部创建一个新对象，并通过传递给函数的指针“返回”它，并让函数实际return一个正确的错误代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int create_message_str(char *p_message, const size_t p_message_len)
{
    int result = -1;

    const char message[] = "Hello, world!";
    if (NULL != p_message && strlen(message) <= p_message_len)
    {
        strcpy(p_message, message);
        result = 0;     
    }

    return result;
}

int main(int argc, char **argv)
{
    int result = EXIT_FAILURE;

    const size_t p_message_len = 13;
    char *p_message = malloc(p_message_len * sizeof(char));

    if (create_message_str(p_message, p_message_len) == 0)
    {
        printf("%s\n", p_message);
        result = EXIT_SUCCESS;
    } 
    else
    {
        fprintf(stderr, "%s\n", "Could not copy string to pointer memory.");
    }

    free(p_message);

    return result;
}

但是，在Java中，您必须创建一个例如某种类似于Supplier的可变对象，用于保存对象的引用，该引用将由C函数中的指针引用：

public class ReferenceSwapper {

    private static class MutableSupplier<T> implements Supplier<T> {

        private T supplied;

        public MutableSupplier(final T supplied) {
            this.supplied = supplied;
        }

        @Override
        public T get() {
            return supplied;
        }

        public void set(final T supplied) {
            this.supplied = supplied;
        }

    }

    public static void main(final String[] args) {
        final MutableSupplier<String> firstSupplier = new MutableSupplier<String>("foo");
        final MutableSupplier<String> secondSupplier = new MutableSupplier<String>("bar");
        System.out.println("Before reference swap: " + firstSupplier.get() + secondSupplier.get());
        swapSupplied(firstSupplier, secondSupplier);
        System.out.println("After reference swap: " + firstSupplier.get() + secondSupplier.get());
    }

    private static <T> void swapSupplied(final MutableSupplier<T> firstSupplier,
            final MutableSupplier<T> secondSupplier) {
        final T firstSupplied = firstSupplier.get();
        final T secondSupplied = secondSupplier.get();
        firstSupplier.set(secondSupplied);
        secondSupplier.set(firstSupplied);
    }
}

此代码打印出来：

Before reference swap: foobar
After reference swap: barfoo

正如您所看到的，由于pass-by-value semantics，这在Java中非常复杂。

例外

但是，Java提供了一种更高级别的方法来定义错误处理行为：异常。虽然some people debate if the idea of exceptions are a good thing or not和exception handling is really just fancy conditional logic，但它们是Java语言的一部分，can work well用于报告异常（即错误）状态。

作为Andy Turner already mentioned，抛出IllegalArgumentException将是报告有关方法特定参数的错误的最自然方式，您不应该（通常）必须捕获和处理：您将是假设使用sumPoints(Point p)的人足够聪明，可以传递正确的参数，或者至少在程序停止时如果不是这样。但是，如果你做期望这是一种常见现象，至少是一种纯粹通过明智的编程无法避免的事件（例如，如果从磁盘读取数据并且可能以某种方式损坏或不可用），然后抛出一个捕获的异常以强制调用方法来处理发生这种情况的情况可能会更好。

Answer 2

简而言之，你的问题的答案是肯定的。例外是处理错误的可接受方式。有很多异常更具体，但是从RuntimeException继承。IllegalArgumentException会浮现在脑海中。您也可以编写自己的RuntimeException继承的异常。然后当然有一个关于使用Unchecked（继承自RuntimeException）或已检查（继承自Exception）的异常的讨论。只需键入Google“runtimeexception vs exception”，您就可以获得一系列链接，让您保持警惕:)。这只是一个例子：difference between java.lang.RuntimeException and java.lang.Exception。对此没有明确的答案。你必须自己选择。

Answer 3

java中有异常的事情是你可以编写自己的类，从Exception扩展到在类中使用它，你可以处理所有可能遇到你的程序然后你抛出它的异常。例如：

public class Erreur extends Exception{
String message; 
public Erreur(String message){
this.message=message;    
}    
public String getMessage(){ return message;}
}

然后

public class Calcule {
    public static double division(double x, double y) throws Erreur{
    double r=0;
    Erreur erre=new Erreur("can't divide by zero");
    if(y==0) throw (erre); 
    else r=(x/y);
    return r;
             } 
   }

在方法

3 个答案:

错误代码

例外