¿Es mejor usar afirmar o IllegalArgumentException para los parámetros de método requeridos?

En Java, ¿cuál es más recomendable y por qué? Ambos tipos arrojarán excepciones, por lo que, en ese sentido, manejarlos es lo mismo. assertes un poco más corto, pero no estoy seguro de cuánto importa.

public void doStuff(Object obj) {
    assert obj != null;
    ...
}

vs

public void doStuff(Object obj) {
    if (obj == null) {
        throw new IllegalArgumentException("object was null");
    }
    ...
}

¡TENER CUIDADO!

Las aserciones se eliminan en tiempo de ejecución a menos que especifique explícitamente "habilitar aserciones" al compilar su código. Las aserciones de Java no se deben usar en el código de producción y se deben restringir a métodos privados (consulte Excepción frente a aserción ), ya que se espera que los métodos privados sean conocidos y utilizados solo por los desarrolladores. También assertarrojará AssertionError que Errorno se extiende Exception, y que normalmente indica que tiene un error muy anormal (como "OutOfMemoryError" que es difícil de recuperar, ¿no es así?) Que no se espera que pueda tratar.

Elimine el indicador "habilitar aserciones" y verifique con un depurador y verá que no pisará la llamada de lanzamiento IllegalArgumentException ... ya que este código no se ha compilado (nuevamente, cuando se elimina "ea")

Es mejor usar la segunda construcción para métodos públicos / protegidos, y si desea hacer algo en una línea de código, hay al menos una forma que conozco. Yo personalmente uso la primavera Marco 's Assertclase que tiene unos métodos para comprobar que los argumentos y tirar 'IllegalArgumentException' en caso de fallo. Básicamente, lo que haces es:

Assert.notNull(obj, "object was null");

... que de hecho ejecutará exactamente el mismo código que escribió en su segundo ejemplo. Hay algunos otros métodos útiles, como hasText, hasLengthallí.

No me gusta escribir más código del necesario, así que estoy contento cuando reduzco el número de líneas escritas en 2 (2 líneas> 1 línea) :-)

Necesitas usar una excepción. Usar una afirmación sería un mal uso de la función.

Las excepciones no marcadas están diseñadas para detectar errores de programación de los usuarios de su biblioteca, mientras que las aserciones están diseñadas para detectar errores en su propia lógica. Estos son problemas separados que no deben mezclarse.

Por ejemplo, una afirmación

assert myConnection.isConnected();

significa "Sé que cada ruta de código que conduce a esta afirmación garantiza que myConnectionesté conectado; si el código anterior no pudo obtener una conexión válida, debería haber lanzado una excepción o regresar antes de llegar a este punto".

Por otro lado, un cheque

if (!myConnection.isConnected()) {
    throw new IllegalArgumentException("connection is not established");
}

significa que "Llamar a mi biblioteca sin establecer una conexión es un error de programación".

Si está escribiendo una función que no permite nullun valor de parámetro válido, debe agregar la @Nonnullanotación a la firma y usarla Objects.requireNonNullpara verificar si el argumento es válido nully arrojar un NullPointerExceptionsi es así. La @Nonnullanotación es para documentación y proporcionará advertencias útiles en el momento de la compilación en algunos casos. No impide que nullse pase en tiempo de ejecución.

void doStuff(@Nonnull Object obj) {
    Objects.requireNonNull(obj, "obj must not be null");

    // do stuff...
}

Actualización: la @Nonnullanotación no forma parte de la biblioteca estándar de Java. En cambio, existen numerosos estándares competidores de bibliotecas de terceros (consulte ¿Qué anotación Java @NotNull debo usar? ). Eso no significa que sea una mala idea usarlo, solo que no es estándar.

Siempre prefiero lanzar IllegalArgumentException sobre aserciones.

Las afirmaciones se usan principalmente en JUnit u otras herramientas de prueba, para verificar / afirmar los resultados de la prueba. Por lo tanto, podría dar una falsa impresión a otros desarrolladores de que su método es un método de prueba.

También tiene sentido lanzar IllegalArgumentException cuando un método ha pasado un argumento ilegal o inapropiado . Esto es más coherente con la convención de manejo de excepciones seguida por los desarrolladores de Java.

OMI, el segundo es un poco mejor porque trae más información y podría ampliarse aún más (por ejemplo, al extender la clase de excepción) para ser aún más informativo, además no utiliza una comparación negativa que es más fácil de entender.

No uso mucho aserts, pero un enfoque común con Lombock @NonNull: https://projectlombok.org/features/NonNull

Implementación de Lombok: import lombok.NonNull;

public class NonNullExample extends Something {
  private String name;

  public NonNullExample(@NonNull Person person) {
    super("Hello");
    this.name = person.getName();
  }
}

Versión de Java:

 import lombok.NonNull;

public class NonNullExample extends Something {
  private String name;

  public NonNullExample(@NonNull Person person) {
    super("Hello");
    if (person == null) {
      throw new NullPointerException("person");
    }
    this.name = person.getName();
  }
}

Lombok es una biblioteca realmente bonita que uso en todas partes