Java: metodo pseudo-setter per le classi immutabili

Question

Diciamo che ho una classe Foo in Java che dispone di dati immutabili:

class Foo { 
    final private int x; 
    public int getX() { return this.x; } 
    final private OtherStuff otherstuff; 
    public Foo(int x, OtherStuff otherstuff) { 
     this.x = x; 
     this.otherstuff = otherstuff; 
    } 
    // lots of other stuff... 
} 

Ora mi piacerebbe aggiungere un metodo di utilità che crea un valore "fratello" con lo stato identico ma con un nuovo valore di x. Potrei chiamo setX():

class Foo 
{ 
    ... 
    Foo setX(int newX) { return new Foo(newX, this.otherstuff); } 
    ... 
} 

ma la semantica di setX() sono diversi rispetto alla convenzione standard setter per gli oggetti di fagioli mutabili, quindi in qualche modo questo non mi sembra giusto.

Qual è il nome migliore per questo metodo?

Devo chiamarlo withX() o newX() o qualcos'altro?

---

edit: nuova priorità nel mio caso: ho clienti di scripting (tramite JSR-223 e un modello a oggetti esporto) che può facilmente ottenere un oggetto Foo. È tuttavia ingombrante chiamare costruttori o creare costruttori o altro. Quindi è auspicabile che fornisca questo metodo come vantaggio per i client di scripting.

Answer 1

withX() è riuscita perché è una convenzione utilizzata per alcuni builder .

Questo è più di un "clone parziale" o "costruttore" di un "setter" ...

Se si guarda alla java.lang.String (anche immutabile) ci sono tutti i tipi di metodi che restituiscono una nuova stringa basata su quello vecchio (sottostringa, toLowerCase(), ecc) ...

Aggiornamento: Vedere anche rispondere da aioobe [deriveFoo()] che mi piace - è forse più chiaro, in particolare a tutti coloro che non hanno familiarità con builder .

Answer 2

E 'sicuramente non un setter, dal momento che in realtà costruisce e restituisce un nuovo oggetto. Credo che la semantica di fabbrica sarebbe l'opzione più appropriata in questo caso

public Foo newFooWith(int x) { 
    return new Foo(x, other); 
} 

L'alternativa potrebbe essere una variante del costruttore di copia

class Foo { 
    public Foo(Foo foo, int x) { 
     return new Foo(x, foo.getOtherStuff()); 
    } 
} 

Answer 3

Seguendo lo stile dello Font class nell'API standard lo chiamereo deriveFoo(int x).

Un'altra opzione sarebbe quella di fornire una classe builder che possa accettare un oggetto come prototipo per nuovi oggetti. In questi casi, il nome è setBar() come solo bar(). Questo darebbe qualcosa di simile

Foo newFoo = new Foo.Builder(foo).x(123).build(); 

Answer 4

lo chiamerei withX(value). Dice che sarà qualcosa con x = value.

Se la classe aveva un sacco di campi, io avrei paura di:

obj.withX(1).withY(2).withZ(3).withU(1)... 

Quindi direi forse utilizzare il generatore di pattern di introdurre una variante mutabile della classe data con solo dati e metodi per creare la classe originale con il suo stato attuale. E li chiamerei questi metodi x(), y(), z() e li facciamo restituire this. Quindi sarebbe simile:

Immutable im2 = new Mutable(im1).x(1).y(2).z(3).build();