La fonction appelante doit renvoyer la valeur par défaut, si l'objet (ou tout autre résultat de la fonction) est nul

Question

Est-il possible d'intégrer le code suivant dans une fonction réutilisable?

EDIT:cela est juste un exemple, je veux une solution de travail pour toutes les profondeurs de récursion

ce que je veux est que le code suivant est généré:

if (MyObject o == null || 
    o.getSubObject() == null || 
    o..getSubObject().getSubSubObject() == null /*|| 
    ... */) 
    return defaultValue; 
return o.getSubObject().getSubObject()/*...*/.getDesiredValue(); 

en appelant quelque chose comme

Object defaultValue = null; 
Object result = NullSafeCall(o.getSubObject().getSubObject()/*...*/.getDesiredValue(), defaultValue); 

Le bloc de code seond est juste une idée, je ne sais pas attention à quoi il ressemble, tout ce que je veux, c'est que je, si désiré, peut éviter toutes les vérifications null avant d'appeler une fonction plus profonde ...

L'injection pourrait faire cela propably, mais il n'y a pas d'autre/solution plus facile? Jamais regardé injection avant encore ...

EDIT2:exemple dans une autre langue: http://groovy.codehaus.org/Operators#Operators-SafeNavigationOperator

Answer 1

Pas vraiment, tout code que vous écrivez cette façon regarderait horrible et/ou utiliser la réflexion très lent. Sauf si vous utilisez un préprocesseur Java réel qui peut comprendre et modifier le code que vous avez écrit.

Une meilleure approche (mais associée à un peu de refactoring) serait de s'assurer que les valeurs en question ne peuvent pas être nulles. Par exemple, vous pouvez modifier les accesseurs individuels (getSubObject(), getDesiredValue()) pour ne jamais renvoyer de null en premier lieu: faites-les retourner les valeurs par défaut. Les accesseurs sur les valeurs par défaut retournent les valeurs par défaut à leur tour.

Answer 2

Vous pouvez faire quelque chose comme ça

public static Object NullSafeCall(MyObject o,Object defaultValue){ 
    if (o == null || o.getSubObject() == null) 
    { 
     return defaultValue; 
    } 
    else 
    { 
     return o.getSubObject().getDesiredValue(); 
    } 
} 

Maintenant, vous pouvez appeler cette méthode comme suit

Object result = NullSafeCall(o, defaultValue); 

Answer 3

Je suggère simplement remplacer

Object result = NullSafeCall(o.getSubObject().getDesiredValue(), defaultValue); 

par le

Object result = (o == null || o.subObject == null) ? defaultVlue : o.getSubObject().getDesiredValue(); 

Créer une méthode uniquement si vous pouvez la réutiliser ......

Answer 4

Ce que vous voulez n'est pas possible. Il est essentiel de comprendre que l'utilisation de cette syntaxe: Object result = NullSafeCall(o.getSubObject().getSubObject() ...); la partie de o.getSubObject().getSubObject() sera évaluée avant tout contrôle passe à la fonction/méthode rejetant ainsi l'exception.

Il est nécessaire d'avoir un certain type de contexte avant d'exécuter un tel code.Le plus proche de ce que je pouvais penser, peut être fait en utilisant des classes internes anonymes comme dans l'exemple ci-dessous:

// intended to be implemented by an anonymous inner class 
interface NullSafeOperation<T> { 
    public T executeSafely(); 
}; 

// our executor that executes operations safely 
public static class NullSafeExecutor<T> { 
    public NullSafeExecutor() {} 

    public T execute(T defaultValue, NullSafeOperation<T> nso) { 
     T result = defaultValue; 
     try { 
      result = nso.executeSafely(); 
     } catch(NullPointerException e) { 
      // ignore 
     } 
     return result; 
    } 

    // utility method to create a new instance and execute in one step 
    public static <T> T executeOperation(T defaultValue, NullSafeOperation<T> nso) { 
     NullSafeExecutor<T> e = new NullSafeExecutor<T>(); 
     T result = e.execute(defaultValue, nso); 
     return result; 
    } 
} 


public static void main(String[] args) { 

    final String aNullString = null; 

    String result = NullSafeExecutor.executeOperation("MyDefault", new NullSafeOperation<String>() { 
     @Override 
     public String executeSafely() { 
      // trying to call a method on a null string 
      // it will throw NullPointerException but it will be catched by the executor 
      return aNullString.trim(); 
     } 
    }); 

    System.out.println("Output = " + result); // prints: Output = MyDefault 
} 

Answer 5

Java8 aide à obtenir le plus proche, vous aurez à votre syntaxe avec des performances décentes je pense;

// Evaluate with default 5 if anything returns null. 
int result = Optional.eval(5, o, x->x.getSubObject(), x->x.getDesiredValue()); 

Cela peut être fait avec cette classe d'utilitaire;

class Optional { 
    public static <T, Tdef, T1> Tdef eval(Tdef def, T input, Function<T,T1> fn1, 
              Function<T1, Tdef> fn2) 
    { 
     if(input == null) return def; 
     T1 res1 = fn1.apply(input); 
     if(res1 == null) return def; 
     return fn2.apply(res1); 
    } 
} 

Malheureusement, vous aurez besoin d'un eval séparé() défini par le nombre d'appels de méthode dans la chaîne, de sorte que vous pouvez définir un peu, mais la compilation type de temps sûr et réutilisable avec à peu près tous les appels/les types.