Mi è capitato di creare una classe mutabile come questa:
class Mutable<T> {
private T value;
public Mutable() { this.value = null; }
public Mutable(T value) { this.value = value; }
T get() { return this.value; }
void set(T value) { this.value = value; }
}
E poi viene spesso usato in un metodo come questo:
boolean operation(String input, Mutable<Set<String>> dataOut) throws ... {
boolean result;
try {
String data = doSomething(input);
result = validate(data);
if (result && dataOut != null) {
List<String> values = Arrays.asList(data.split(", "));
Collections.sort(values);
dataOut.set(new LinkedHashSet<String>(values));
}
} catch(SpecificIgnorableException ex) {
result = false;
logger.debug(ex);
}
return result;
}
... che è solo un esempio, potrebbe essere un caso d'uso, dove si userebbero ref o out parametri in C #, o parametri di riferimento non-const in C ++, o puntatori ai parametri di output in C.
In primo luogo, lo stesso potrebbe essere fatto utilizzando un array (con un elemento) anziché il tipo personalizzato sopra. Ha senso avere questo tipo personalizzato che dichiara chiaramente mutable , invece di usare un array mutabilmente implicito?
In secondo luogo, questo modello è cattivo e l'odore del codice in Java? Limitiamoci ai casi in cui l'utilizzo del parametro out avrebbe senso in C #. Dovrebbe essere sostituita ogni istanza di questo tipo di codice Java? Con cosa?