如果它是一个“setter”，或者我要获取一个成员稍后使用的地方，我倾向于使用IllegalArgumentException。

如果它是我现在要在方法中使用(解引用)的东西，我主动抛出一个NullPointerException。我更喜欢这样做，而不是让运行时来做，因为我可以提供有用的消息(似乎运行时也可以这样做，但这是另一天的咆哮)。

如果我重写一个方法，我使用被重写的方法使用的任何东西。

如果你不希望null是一个允许的值，似乎会调用IllegalArgumentException，如果你试图使用一个结果为null的变量，则会抛出NullPointerException。

Apache Commons Lang有一个NullArgumentException，它完成了这里讨论的许多事情:它扩展了IllegalArgumentException，并且它唯一的构造函数采用了参数的名称，而参数的名称本应该是非空的。

虽然我觉得抛出NullArgumentException或IllegalArgumentException之类的异常更准确地描述了异常情况，但我和同事们还是选择遵从Bloch在这个问题上的建议。

实际上，在我看来，抛出IllegalArgumentException或NullPointerException的问题只是对Java中不完全理解异常处理的少数人的“圣战”。一般来说，规则很简单，如下:

argument constraint violations must be indicated as fast as possible (-> fast fail), in order to avoid illegal states which are much harder to debug in case of an invalid null pointer for whatever reason, throw NullPointerException in case of an illegal array/collection index, throw ArrayIndexOutOfBounds in case of a negative array/collection size, throw NegativeArraySizeException in case of an illegal argument that is not covered by the above, and for which you don't have another more specific exception type, throw IllegalArgumentException as a wastebasket on the other hand, in case of a constraint violation WITHIN A FIELD that could not be avoided by fast fail for some valid reason, catch and rethrow as IllegalStateException or a more specific checked exception. Never let pass the original NullPointerException, ArrayIndexOutOfBounds, etc in this case!

至少有三个非常好的理由反对将所有类型的参数约束违反映射到IllegalArgumentException，第三个理由可能非常严重，以至于标志着这种做法的糟糕风格:

(1) A programmer cannot a safely assume that all cases of argument constraint violations result in IllegalArgumentException, because the large majority of standard classes use this exception rather as a wastebasket if there is no more specific kind of exception available. Trying to map all cases of argument constraint violations to IllegalArgumentException in your API only leads to programmer frustration using your classes, as the standard libraries mostly follow different rules that violate yours, and most of your API users will use them as well!

(2) Mapping the exceptions actually results in a different kind of anomaly, caused by single inheritance: All Java exceptions are classes, and therefore support single inheritance only. Therefore, there is no way to create an exception that is truly say both a NullPointerException and an IllegalArgumentException, as subclasses can only inherit from one or the other. Throwing an IllegalArgumentException in case of a null argument therefore makes it harder for API users to distinguish between problems whenever a program tries to programmatically correct the problem, for example by feeding default values into a call repeat!

(3) Mapping actually creates the danger of bug masking: In order to map argument constraint violations into IllegalArgumentException, you'll need to code an outer try-catch within every method that has any constrained arguments. However, simply catching RuntimeException in this catch block is out of the question, because that risks mapping documented RuntimeExceptions thrown by libery methods used within yours into IllegalArgumentException, even if they are no caused by argument constraint violations. So you need to be very specific, but even that effort doesn't protect you from the case that you accidentally map an undocumented runtime exception of another API (i.e. a bug) into an IllegalArgumentException of your API. Even the most careful mapping therefore risks masking programming errors of other library makers as argument constraint violations of your method's users, which is simply hillareous behavior!

With the standard practice on the other hand, the rules stay simple, and exception causes stay unmasked and specific. For the method caller, the rules are easy as well: - if you encounter a documented runtime exception of any kind because you passed an illegal value, either repeat the call with a default (for this specific exceptions are neccessary), or correct your code - if on the other hand you enccounter a runtime exception that is not documented to happen for a given set of arguments, file a bug report to the method's makers to ensure that either their code or their documentation is fixed.

如果它是一个setter方法，并且null被传递给它，我认为抛出一个IllegalArgumentException会更有意义。NullPointerException似乎在尝试实际使用null的情况下更有意义。

如果你在使用它，它是空的，NullPointer。如果它被传入并且它为空，则为非法参数。

如果它是一个“setter”，或者我要获取一个成员稍后使用的地方，我倾向于使用IllegalArgumentException。

如果它是我现在要在方法中使用(解引用)的东西，我主动抛出一个NullPointerException。我更喜欢这样做，而不是让运行时来做，因为我可以提供有用的消息(似乎运行时也可以这样做，但这是另一天的咆哮)。

如果我重写一个方法，我使用被重写的方法使用的任何东西。