Null returns in Java

Das Thema der null Referenzen in Java, insbesondere als Rückgabewert von Methoden ist umstritten. Generell führt es zu einer erhöhten Gefahr von (aussagelosen) NullPointerExceptions.

An manchen stellen kann man diese einfach vermeiden: finder die eine Liste von Objekten zurückliefern sollten eine leere Ergebnismenge (die ohne Fehler zustande gekommen ist) nicht mit einem null; Rückgabewert signalisieren, sondern mit einer leeren Collection: "return List.EMPTY_LIST;".

An anderen Stellen ist die Vermeidung von null nicht immer unumstritten. Auf die Diskussion will ich mich hier jetzt garnicht einlassen. Deswegen habe ich hier eine einfache Policy - falls null Rückgabe Werte doch zulässig sein sollten:

Wenn schon null als Rückgabe Wert einer Methode, so darf dies nur passieren wenn:

1. im Javadoc erwähnt wird "@returns the Object requested or null"
2. der null Wert im Code durch ein explizites "return null;" angegeben wird.

Ein Negativbeispiel ist dies hier (der Code mit der Entscheidungsfindung ist hier deutlich übersichtlicher als bei größeren Methoden mit state variablen in der Praxis:

public IThing getCarOrBike(int distance, Person p) {
  IThing ret = null;

  if (distance > 1000) {
    ret = new Car();
    ret.add(p);
  }

  if (distance > 100) {
    ret = new Bike();
    ret.add(p);
  }

  return ret; // BAD
}

Mit einem expliziten return wird dies klarer, entweder (die von mir oftmals bevorzugte Early-Out Variante):

public IThing getCarOrBike(int distance, Person p) {

  if (distance < 0 || p == null)
    throw new IllegalArgumentException("You must specify a person and positive distance");

  if (distance <= 100)
    return null; // pedestrian

  IThing ret;

  if (distance > 1000) {
    ret = new Car();
  } else {
    ret = new Bike();
  }
 
  ret.add(p);

  return ret;
}

Oder eine if/else Cascade:

/**
 * Return Transportation for given distance.
 * <P>
 * This will return instances of Car or Bike. If the distance
 * is short enough, null will be returned.
 *
 * @return null or new instance of Car or Bike with person added
 */
public IThing getCarOrBike(int distance, Person p) {
  IThing ret = null;

  if (distance > 1000) {
    ret = new Car();
  } else if (distance > 100) {
    ret = new Bike();
  } else {
    return null; // pedestrian
  }

  ret.add(p);
  return ret;
}

Wichtig ist dabei immer, dass im Code klar wird, was die Intention ist - also: soll null wirklich zurückgegeben werden oder wurde nur eine Fallunterscheidung vergessen. Wenn man sich dazu überwindet "return null;" zu schreiben, so ist es zugegebenermaßen manchmal etwas langatmiger, aber dafür eindeutig.

Eine Code Policy wie "jede Methode darf nur einen return punkt haben" ist übrigens nicht nur weil es dieses Idiom verbietet unsinnig. Das führt nur zu extremen Verschachtelungen. Dank Java finally gibt es dazu auch sehr selten Grund.

Übrigens versuche ich auch die returns innerhalb eines entsprechenden try/finally Blocks zu haben und vermeide "Alibi" returns am ende der Methode - die beschwichtigen nur erwünschte Warnings.