objeto! = Verificación nula

Question

¿Es esta verificación si el objeto pasado nulo o no está bien o debería usar un tipo de métodos iguales()?

public void addCard(Card card) throws IllegalArgumentException { 
     if (card != null){ 
      cardList.add(card); 
     } else { 
      throw new IllegalArgumentException(); 
     } 
    } 

Answer 1

prefiero hacerlo de esta manera:

/** 
* Adds a card to the deck. 
* 
* @param the card to add. 
* @throws IllegalArgumentException if the card is null. 
*/ 
public void addCard(final Card card) 
{ 
    if(card == null) 
    { 
     throw new IllegalArgumentException("card must not be null"); 
    } 

    cardList.add(card); 
} 

1. es menos código para leer
2. que separa la condición de error de la condición de espera (sin otra cosa = sin guión)
3. nadie necesita ver lo que está en la línea X para ver que la variable de la tarjeta era nula = menos tiempo para que las personas que buscan descubran lo que hicieron mal.
4. sin necesidad de recargar el código con tiros inútiles declaraciones - que debe Javadoc que aunque con una cláusula @throws

Aparte de eso, que está haciendo las cosas bien, en mi opinión.

Answer 2

Como está comparando la referencia, debe usar !=. El uso de equals arrojará una excepción.

Answer 3

Si solo quiere verificar si las tarjetas que se agregan no son null, su código funcionará bien. Solo necesita asegurarse de manejar el IllegalArgumentException cuando llame al addCard.

Answer 4

Eso es correcto, pero personalmente lo estructuraría al revés. Es común para validar los argumentos en el inicio del método, y luego usarlos para el resto del método de saber si es correcta:

public void addCard(Card card) { 
    if (card == null) { 
     throw new IllegalArgumentException("Attempt to add null card"); 
    } 
    cardList.add(card); 
} 

La ventaja de hacer todas las pruebas argumento por adelantado es que si una Se le pasa un argumento no válido, lanzará una excepción antes de que se produzcan efectos secundarios, en lugar de transcurrir la mitad del método, lo que podría dejar al objeto en un estado no válido. Por supuesto, en este caso no importa, pero estoy a favor de la coherencia aquí :)

Tenga en cuenta que no hay necesidad de declarar IllegalArgumentException - es una subclase de RuntimeException, lo que significa que no está marcada (que no es necesario declarar que)

Answer 5

Puede usar la clase commons-langValidate. Esto hace que el código más corto y más simple:

public void addCard(Card card) { 
    Validate.notNull(card); 
    cardList.add(card); 
} 

se lanzará una IllegalArgumentException con un mensaje predeterminado (se puede pasar un mensaje personalizado como un segundo argumento, si se quiere)

Answer 6

Effective Java de Josh Blosh recomienda lo siguiente:

/** 
* ads a card to card list. 
* 
* @param card card to add. Can not be null 
* 
*/ 
public void addCard(Card card) { 
     if (card == null) { 
      throw new NullPointerException("Card can not be null") 
     } 
     cardList.add(card); 
    } 

Así que, en primer lugar, no declaras la RuntimeException. En segundo lugar lanzas una NullPointerException porque tu argumento no es simplemente incorrecto, es nulo. En tercer lugar, especifica los argumentos en javadoc, pueden ser nulos o no.