Mengapa chaining setters tidak konvensional?

Memiliki rantai yang diimplementasikan pada kacang sangat berguna: tidak perlu untuk membebani konstruktor, konstruktor besar, pabrik, dan memberi Anda peningkatan keterbacaan. Saya tidak bisa memikirkan kelemahan, kecuali jika Anda ingin objek Anda tidak berubah , dalam hal ini tidak akan memiliki setter. Jadi adakah alasan mengapa ini bukan konvensi OOP?

public class DTO {

    private String foo;
    private String bar;

    public String getFoo() {
         return foo;
    }

    public String getBar() {
        return bar;
    }

    public DTO setFoo(String foo) {
        this.foo = foo;
        return this;
    }

    public DTO setBar(String bar) {
        this.bar = bar;
        return this;
    }

}

//...//

DTO dto = new DTO().setFoo("foo").setBar("bar");

Jadi adakah alasan mengapa ini bukan konvensi OOP?

Tebakan terbaik saya: karena melanggar CQS

Anda telah mendapat perintah (mengubah status objek) dan kueri (mengembalikan salinan status - dalam hal ini, objek itu sendiri) dicampur ke dalam metode yang sama. Itu tidak selalu menjadi masalah, tetapi itu melanggar beberapa pedoman dasar.

Misalnya, dalam C ++, std :: stack :: pop () adalah perintah yang mengembalikan void, dan std :: stack :: top () adalah kueri yang mengembalikan referensi ke elemen teratas di stack. Klasik, Anda ingin menggabungkan keduanya, tetapi Anda tidak bisa melakukan itu dan menjadi pengecualian aman. (Tidak masalah di Jawa, karena operator penugasan di Jawa tidak melempar).

Jika DTO adalah tipe nilai, Anda mungkin mencapai akhir yang sama dengannya

public DTO setFoo(String foo) {
    return new DTO(foo, this.bar);
}

public DTO setBar(String bar) {
    return new DTO(this.foo, bar);
}

Juga, merantai nilai kembali adalah rasa sakit yang luar biasa ketika Anda berurusan dengan warisan. Lihat "Pola templat berulang yang aneh"

Akhirnya, ada masalah bahwa konstruktor default harus meninggalkan Anda dengan objek yang dalam keadaan valid. Jika Anda harus menjalankan banyak perintah untuk mengembalikan objek ke status yang valid, ada yang salah.

1. Menyimpan beberapa penekanan tombol tidak menarik. Mungkin bagus, tetapi konvensi OOP lebih peduli pada konsep dan struktur, bukan penekanan tombol.

2. Nilai kembali tidak ada artinya.

3. Bahkan lebih daripada menjadi tidak berarti, nilai kembali menyesatkan, karena pengguna dapat mengharapkan nilai kembali memiliki arti. Mereka mungkin berharap bahwa itu adalah "penyetel abadi"

   public FooHolder {
       public FooHolder withFoo(int foo) {
           /* return a modified COPY of this FooHolder instance */
       }
   }
   

   Pada kenyataannya, setter Anda mengubah objek.

4. Itu tidak bekerja dengan baik dengan warisan.

   public FooHolder {
       public FooHolder setFoo(int foo) {
           ...
       }
   }
   

   public BarHolder extends FooHolder {
       public FooHolder setBar(int bar) {
           ...
       }
   } 
   

   Saya bisa menulis

   new BarHolder().setBar(2).setFoo(1)

   tapi tidak

   new BarHolder().setFoo(1).setBar(2)

Bagi saya, # 1 hingga # 3 adalah yang penting. Kode yang ditulis dengan baik bukan tentang teks yang disusun dengan menyenangkan. Kode yang ditulis dengan baik adalah tentang konsep, hubungan, dan struktur dasar. Teks hanyalah refleksi luar dari arti sebenarnya dari kode.

Saya tidak berpikir ini adalah konvensi OOP, ini lebih terkait dengan desain bahasa dan konvensi.

Sepertinya Anda suka menggunakan Java. Java memiliki spesifikasi JavaBeans yang menentukan tipe pengembalian setter yang batal, yaitu bertentangan dengan rantai setter. Spesifikasi ini diterima secara luas dan diimplementasikan dalam berbagai alat.

Tentu saja Anda mungkin bertanya, mengapa tidak merantai bagian dari spesifikasinya. Saya tidak tahu jawabannya, mungkin pola ini tidak dikenal / populer saat itu.

Seperti yang dikatakan orang lain, ini sering disebut antarmuka yang lancar .

Biasanya setter adalah panggilan lewat variabel sebagai respons terhadap kode logika dalam aplikasi; kelas DTO Anda adalah contohnya. Kode konvensional ketika setter tidak mengembalikan apa pun adalah yang terbaik untuk ini. Jawaban lain telah menjelaskan caranya.

Namun ada beberapa kasus di mana antarmuka yang lancar mungkin merupakan solusi yang baik, ini memiliki kesamaan.

• Konstanta sebagian besar diteruskan ke setter
• Logika program tidak mengubah apa yang diteruskan ke setter.

Menyiapkan konfigurasi, misalnya fasih-nhibernate

Id(x => x.Id);
Map(x => x.Name)
   .Length(16)
   .Not.Nullable();
HasMany(x => x.Staff)
   .Inverse()
   .Cascade.All();
HasManyToMany(x => x.Products)
   .Cascade.All()
   .Table("StoreProduct");

Menyiapkan data uji dalam unit test, menggunakan TestDataBulderClasses khusus (Object Mothers)

members = MemberBuilder.CreateList(4)
    .TheFirst(1).With(b => b.WithFirstName("Rob"))
    .TheNext(2).With(b => b.WithFirstName("Poya"))
    .TheNext(1).With(b => b.WithFirstName("Matt"))
    .BuildList(); // Note the "build" method sets everything else to
                  // senible default values so a test only need to define 
                  // what it care about, even if for example a member 
                  // MUST have MembershipId  set

Namun menciptakan antarmuka yang lancar sangat sulit , jadi itu hanya layak jika Anda memiliki banyak pengaturan "statis". Juga antarmuka yang lancar tidak boleh dicampur dengan kelas "normal"; karenanya pola pembangun sering digunakan.

Saya pikir banyak alasan itu bukan konvensi untuk rantai satu setter demi satu karena untuk kasus-kasus itu lebih khas untuk melihat objek opsi atau parameter dalam konstruktor. C # memiliki sintaks initializer juga.

Dari pada:

DTO dto = new DTO().setFoo("foo").setBar("bar");

Orang mungkin menulis:

(dalam JS)

var dto = new DTO({foo: "foo", bar: "bar"});

(dalam C #)

DTO dto = new DTO{Foo = "foo", Bar = "bar"};

(di Jawa)

DTO dto = new DTO("foo", "bar");

setFoodan setBarkemudian tidak lagi diperlukan untuk inisialisasi, dan dapat digunakan untuk mutasi nanti.

Sementara chainability berguna dalam beberapa keadaan, penting untuk tidak mencoba memasukkan semuanya dalam satu baris hanya demi mengurangi karakter baris baru.

Sebagai contoh

dto.setFoo("foo").setBar("fizz").setFizz("bar").setBuzz("buzz");

membuatnya lebih sulit untuk membaca dan memahami apa yang terjadi. Memformat ulang ke:

dto.setFoo("foo")
    .setBar("fizz")
    .setFizz("bar")
    .setBuzz("buzz");

Jauh lebih mudah dipahami, dan membuat "kesalahan" di versi pertama lebih jelas. Setelah Anda refactored kode ke format itu, tidak ada keuntungan nyata dari:

dto.setFoo("foo");
dto.setBar("bar");
dto.setFizz("fizz");
dto.setBuzz("buzz");

Teknik itu sebenarnya digunakan dalam pola Builder.

x = ObjectBuilder()
        .foo(5)
        .bar(6);

Namun, secara umum hal itu dihindari karena bersifat rancu. Tidak jelas apakah nilai kembali adalah objek (sehingga Anda dapat memanggil setter lain), atau jika objek kembali adalah nilai yang baru saja ditetapkan (juga merupakan pola umum). Dengan demikian, Prinsip Terkecil Least menyarankan Anda tidak boleh mencoba menganggap pengguna ingin melihat satu solusi atau yang lain, kecuali itu mendasar untuk desain objek.

Ini lebih merupakan komentar daripada jawaban, tapi saya tidak bisa berkomentar, jadi ...

Saya hanya ingin mengatakan bahwa pertanyaan ini mengejutkan saya karena saya tidak melihat ini sama sekali tidak umum . Sebenarnya, di lingkungan kerja saya (pengembang web) sangat umum.

Sebagai contoh, ini adalah bagaimana perintah Symfony: menghasilkan: perintah entitas menghasilkan otomatis semua setters , secara default .

jQuery agak rantai sebagian besar metodenya dengan cara yang sangat mirip.