Tại sao mô hình xây dựng thường được thực hiện như thế này?

Thường thì tôi thấy việc triển khai mẫu trình xây dựng (trong Java) là như thế này:

public class Foo {
    private Foo(FooBuilder builder) {
        // get alle the parameters from the builder and apply them to this instance
    }

    public static class FooBuilder {
        // ...
        public Foo build() {
            return new Foo(this); // <- this part is what irritates me
        }
    }
}

Ví dụ cũng ở đây:

• /programming/25130510/builder-potype-in-java
• https://www.javacodegeek.com/2013/01/the-builder-potype-in-practice.html

Tại sao mọi người giới thiệu sự phụ thuộc mạnh mẽ (lẫn nhau) giữa người xây dựng và loại để xây dựng?

EDIT: Ý tôi là, tôi biết rằng về bản chất, trình xây dựng được gắn với lớp tôi muốn xây dựng một thể hiện từ ( FooBuilder -> Foo). Điều tôi thắc mắc là: tại sao lại có sự cần thiết cho cách khác ( Foo -> FooBuilder)

Ngược lại, tôi thấy các triển khai (ít thường xuyên hơn) tạo ra một bản năng mới Fookhi trình tạo được tạo và đặt các trường theo trường hợp Fookhi các phương thức xây dựng thích hợp được gọi. Tôi thích cách tiếp cận này tốt hơn, bởi vì nó vẫn có API thông thạo và không ràng buộc lớp với trình tạo của nó. Có bất kỳ nhược điểm của phương pháp khác này?

Nó sôi sục đến mức không bao giờ có Foo trong trạng thái được xây dựng một nửa

Một số lý do mà mùa xuân đến tâm trí:

Bản chất của người xây dựng gắn liền với lớp mà nó đang xây dựng. Bạn có thể nghĩ về các trạng thái trung gian của trình xây dựng là ứng dụng một phần của hàm tạo, do đó, lập luận của bạn rằng nó quá khớp nối không có sức thuyết phục.

Bằng cách chuyển toàn bộ trình xây dựng vào, các trường trong MyClass có thể là cuối cùng, làm cho lý luận về MyClass dễ dàng hơn. Nếu các trường không phải là cuối cùng, bạn có thể dễ dàng có setters thông thạo hơn so với một người xây dựng.

Trình xây dựng sẽ giữ các trường có thể thay đổi, được đặt bằng các phương thức. Lớp thực tế ( Foo) sau đó có thể tạo finalcác trường bất biến từ trình xây dựng.

Vì vậy, Builder là một lớp trạng thái.

Nhưng người xây dựng có thể gọi là alse new Foo(x, y, z). Đó sẽ là IMHO một chiều, phong cách tốt hơn. Khi đó, mô hình chống, trường FooBuilder hoặc như vậy sẽ không thể thực hiện được. Mặt khác, FooBuilder đảm bảo tính toàn vẹn của dữ liệu.

Mặt khác, FooBuilder đóng hai vai trò: xây dựng với API thông thạo và để trình bày dữ liệu cho nhà xây dựng. Nó là một lớp kiểu sự kiện cho hàm tạo. Trong một mã được thiết kế quá mức, các tham số hàm tạo có thể được giữ trong một số FooConstructorParams.

Bởi vì "Builder" thường được sử dụng để giải quyết "vấn đề nhà xây dựng kính thiên văn", đặc biệt là trong bối cảnh các lớp không thay đổi. Xem liên kết này cho một ví dụ đầy đủ.

Hãy xem xét các lựa chọn thay thế sẽ như thế nào:

 public static class FooBuilder {
    // works with immutable classes, but leads to telescoping constructor
    public Foo build() {
        return new Foo(par1, par2, par3, ....); 
    }
 }

Hoặc là:

 public static class FooBuilder {
    // does not work for immutable classes:
    public Foo build() {
        var foo = new Foo(); 
        foo.Attribute1=par1;
        foo.Attribute2=par2;
        //...
        return foo;
    }
 }

Vì vậy, đặc biệt đối với các lớp không thay đổi, nếu bạn muốn không có hàm tạo với một loạt các tham số, thực sự không có thay thế nào.