ทำไม setters ที่ไม่เป็นทางการคืออะไร

การผูกมัดแบบติดตั้งบนถั่วนั้นมีประโยชน์มาก: ไม่จำเป็นต้องใช้ตัวสร้างมากเกินไปตัวสร้างขนาดใหญ่โรงงานและช่วยให้คุณอ่านง่ายขึ้น ฉันไม่สามารถคิดถึงข้อเสียใด ๆ เว้นแต่ว่าคุณต้องการให้วัตถุของคุณไม่เปลี่ยนรูปในกรณีนี้มันจะไม่มีตัวตั้งค่าใด ๆ อยู่ดี มีเหตุผลทำไมนี่ไม่ใช่การประชุม 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");

ดังนั้นมีเหตุผลทำไมนี่ไม่ใช่การประชุม OOP

การเดาที่ดีที่สุดของฉัน: เพราะมันละเมิดCQS

คุณได้รับคำสั่ง (เปลี่ยนสถานะของวัตถุ) และแบบสอบถาม (คืนสำเนาของรัฐ - ในกรณีนี้วัตถุเอง) ผสมกันเป็นวิธีเดียวกัน ไม่จำเป็นต้องเป็นปัญหา แต่มันละเมิดหลักเกณฑ์พื้นฐานบางประการ

ตัวอย่างเช่นใน C ++, std :: stack :: pop () เป็นคำสั่งที่ส่งกลับค่าโมฆะและ std :: stack :: top () เป็นแบบสอบถามที่ส่งคืนการอ้างอิงไปยังองค์ประกอบด้านบนในสแต็ก คลาสสิกคุณต้องการรวมทั้งสองอย่างเข้าด้วยกัน แต่คุณไม่สามารถทำได้และปลอดภัยยกเว้น (ไม่ใช่ปัญหาใน Java เนื่องจากตัวดำเนินการกำหนดค่าใน Java ไม่ได้โยน)

หาก DTO เป็นประเภทค่าคุณอาจได้รับจุดสิ้นสุดที่คล้ายกัน

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

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

นอกจากนี้ค่าตอบแทนที่ผูกมัดเป็นความเจ็บปวดมหึมาเมื่อคุณกำลังจัดการกับมรดก ดู"รูปแบบเทมเพลตที่เกิดซ้ำซอกแซก"

ในที่สุดก็มีปัญหาที่ตัวสร้างเริ่มต้นควรปล่อยให้คุณกับวัตถุที่อยู่ในสถานะที่ถูกต้อง หากคุณต้องเรียกใช้คำสั่งเครือเพื่อคืนค่าวัตถุให้อยู่ในสถานะที่ถูกต้องมีบางอย่างผิดพลาดไปมาก

1. การบันทึกการกดแป้นบางอย่างนั้นไม่น่าสนใจ มันอาจจะดี แต่การประชุม OOP ให้ความสำคัญกับแนวคิดและโครงสร้างไม่ใช่การกดแป้น

2. ค่าส่งคืนนั้นไม่มีความหมาย

3. ยิ่งกว่าไร้ความหมายค่าส่งคืนนั้นทำให้เข้าใจผิดเนื่องจากผู้ใช้อาจคาดหวังว่าค่าที่ส่งคืนจะมีความหมาย พวกเขาอาจคาดหวังว่ามันเป็น "หมาตัวเซ็ทที่ไม่เปลี่ยนรูป"

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

   ในความเป็นจริง setter ของคุณกลายพันธุ์วัตถุ

4. มันใช้งานไม่ได้กับมรดก

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

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

   ฉันเขียนได้

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

   แต่ไม่

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

สำหรับฉัน # 1 ถึง # 3 เป็นคนสำคัญ โค้ดที่เขียนได้ดีนั้นไม่เกี่ยวกับข้อความที่จัดเรียงอย่างน่าพึงพอใจ รหัสที่เขียนได้ดีนั้นเกี่ยวกับแนวคิดพื้นฐานความสัมพันธ์และโครงสร้าง ข้อความเป็นเพียงภาพสะท้อนภายนอกของความหมายที่แท้จริงของโค้ด

ฉันไม่คิดว่านี่เป็นแบบแผนของ OOP มันเกี่ยวข้องกับการออกแบบภาษาและแบบแผนมากกว่า

ดูเหมือนว่าคุณต้องการใช้ Java Java มีข้อกำหนดJavaBeansซึ่งระบุชนิดการคืนค่าของ setter ให้เป็นโมฆะนั่นคือขัดแย้งกับการโยงของ setters ข้อมูลจำเพาะนี้ได้รับการยอมรับและนำไปใช้อย่างแพร่หลายในเครื่องมือที่หลากหลาย

แน่นอนคุณอาจถามว่าทำไมไม่ผูกมัดส่วนหนึ่งของรายละเอียด ฉันไม่รู้คำตอบบางทีรูปแบบนี้อาจไม่เป็นที่รู้จัก / เป็นที่นิยมในขณะนั้น

ขณะที่คนอื่น ๆ ได้กล่าวมานี้มักจะเรียกว่าอินเตอร์เฟซได้อย่างคล่องแคล่ว

โดยทั่วไปตัวตั้งค่าจะเรียกการส่งผ่านตัวแปรเพื่อตอบสนองต่อรหัสตรรกะในแอปพลิเคชัน คลาส DTO ของคุณเป็นตัวอย่างของสิ่งนี้ รหัสทั่วไปเมื่อผู้ตั้งค่าไม่ส่งคืนสิ่งใดเป็นเรื่องปกติที่ดีที่สุดสำหรับเรื่องนี้ คำตอบอื่น ๆ ได้อธิบายวิธี

อย่างไรก็ตามมีบางกรณีที่อินเตอร์เฟซที่คล่องแคล่วอาจเป็นทางออกที่ดีสิ่งเหล่านี้มีเหมือนกัน

• ค่าคงที่ส่วนใหญ่จะถูกส่งไปยังผู้ตั้งค่า
• ตรรกะของโปรแกรมจะไม่เปลี่ยนแปลงสิ่งที่ผ่านไปยังตัวตั้งค่า

การตั้งค่าคอนฟิเกอเรชันเช่นfluent-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");

การตั้งค่าข้อมูลการทดสอบในการทดสอบหน่วยโดยใช้TestDataBulderClassesพิเศษ(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

อย่างไรก็ตามการสร้างส่วนต่อประสานที่ดีนั้นทำได้ยากมากดังนั้นมันจึงคุ้มค่าเมื่อคุณมีการตั้งค่า "คงที่" จำนวนมาก อินเทอร์เฟซที่คล่องแคล่วไม่ควรผสมกับคลาส "ปกติ" ดังนั้นรูปแบบการสร้างมักจะใช้

ฉันคิดว่าเหตุผลส่วนใหญ่มันไม่ใช่แบบแผนในการโยงลูกโซ่หนึ่ง setter หลังจากนั้นเป็นเพราะในกรณีเหล่านั้นมันเป็นเรื่องปกติมากกว่าที่จะเห็นวัตถุตัวเลือกหรือพารามิเตอร์ในตัวสร้าง C # มีไวยากรณ์เริ่มต้นเช่นกัน

แทน:

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

หนึ่งอาจเขียน:

(ใน JS)

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

(ใน C #)

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

(ใน Java)

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

setFooและsetBarไม่จำเป็นสำหรับการเริ่มต้นอีกต่อไปและสามารถใช้สำหรับการกลายพันธุ์ในภายหลัง

ในขณะที่ความสามารถด้านลูกโซ่มีประโยชน์ในบางสถานการณ์สิ่งสำคัญคือต้องไม่พยายามทำทุกสิ่งในบรรทัดเดียวเพื่อลดอักขระบรรทัดใหม่

ตัวอย่างเช่น

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

ทำให้ยากต่อการอ่านและเข้าใจสิ่งที่เกิดขึ้น การจัดรูปแบบใหม่เป็น:

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

ง่ายต่อการเข้าใจและทำให้ "ความผิดพลาด" ในรุ่นแรกชัดเจนยิ่งขึ้น เมื่อคุณปรับโครงสร้างโค้ดในรูปแบบนั้นแล้วจะไม่มีข้อได้เปรียบเหนือกว่า:

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

เทคนิคนั้นใช้จริงในรูปแบบตัวสร้าง

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

อย่างไรก็ตามโดยทั่วไปจะหลีกเลี่ยงได้เนื่องจากไม่ชัดเจน ไม่ชัดเจนว่าค่าส่งคืนเป็นวัตถุ (เพื่อให้คุณสามารถเรียกตัวตั้งค่าอื่น ๆ ) หรือถ้าวัตถุส่งคืนเป็นค่าที่เพิ่งได้รับมอบหมาย (เช่นรูปแบบทั่วไป) ดังนั้นหลักการของ Least Surprise แนะนำว่าคุณไม่ควรลองสมมติว่าผู้ใช้ต้องการเห็นวิธีแก้ปัญหาเดียวหรืออีกวิธีหนึ่งเว้นแต่จะเป็นพื้นฐานในการออกแบบของวัตถุ

นี่เป็นความคิดเห็นมากกว่าคำตอบ แต่ฉันไม่สามารถแสดงความคิดเห็นดังนั้น ...

แค่อยากพูดถึงว่าคำถามนี้ทำให้ฉันประหลาดใจเพราะฉันไม่เห็นว่ามันผิดปกติเลย จริงๆแล้วในสภาพแวดล้อมการทำงานของฉัน (นักพัฒนาเว็บ) เป็นเรื่องธรรมดามาก

ตัวอย่างเช่นนี้เป็นวิธีที่ Symfony ของหลักคำสอน: สร้าง: หน่วยงานคำสั่งอัตโนมัติสร้างทั้งหมด setters , โดยปริยาย

jQuery kindaโซ่วิธีส่วนใหญ่ในลักษณะที่คล้ายกันมาก