Pattern kreatif pertama kali digambarkan dalam Gang of Four yang terkenal Buku ini memperkenalkan setiap corak dalam bab khusus dan mengikuti struktur yang ketat untuk setiap corak: niat, motivasi, kegunaan, struktur, peserta, kerjasama, akibat, pelaksanaan, sampel kod, kegunaan yang diketahui, dan corak yang berkaitan. corak niat memperkenalkan matlamat ringkas corak, manakala kegunaan memberitahu bila anda harus menggunakannya. Reka Bentuk Pattern Sebagai contoh, di sini adalah satu ekstrak untuk Pattern : Pembinaan 
 
 
 
 
 
 usaha : Memisahkan pembinaan objek kompleks daripada perwakilan sehingga proses pembinaan yang sama boleh mewujudkan perwakilan yang berbeza. kegunaan : Gunakan pattern Builder apabila 
 
 
 Algoritma untuk mencipta objek kompleks mesti bebas daripada Bahagian-bahagian yang membentuk objek dan bagaimana mereka disatukan. the construction process must allow different representations for the object that's constructed. : Intent Memisahkan pembinaan objek kompleks daripada perwakilan sehingga proses pembinaan yang sama boleh mewujudkan perwakilan yang berbeza. : Applicability Gunakan pattern Builder apabila 
 
 
 Algoritma untuk mencipta objek kompleks mesti bebas daripada Bahagian-bahagian yang membentuk objek dan bagaimana mereka disatukan. proses pembinaan mesti membenarkan perwakilan yang berbeza untuk objek yang dibina. GoF (Gang of Four) telah menjadi asas dalam domain pemrograman berorientasikan objek dan telah memberi pengaruh kepada reka bentuk bahasa pemrograman, termasuk bahasa yang meluas seperti Java. Apabila saya kembali ke kedudukan kejuruteraan, saya mendapati kod Java yang ditulis baru yang mempunyai banyak potensi peningkatan mengenai pemeliharaan. Ia berfungsi, tetapi saya membayangkan jurutera perlu mengemas kini ia, termasuk diri saya dan saya, dan saya yakin saya boleh membantu mereka. Minggu ini, saya membina semula kod menggunakan corak kreatif untuk meningkatkan pemeliharaan. Dalam post ini, saya ingin menerangkan masalah yang saya hadapi dan menyebutkan bagaimana corak membantu saya. Konstruktor dengan banyak parameter jenis yang sama. Mari kita bayangkan pembina dengan banyak parameter String: public License (
    String id, String licenseeName,
    String licenseId, String environment,
    LocalDateTime generatedAt
)
 Apabila memanggil pembina ini, kebarangkalian adalah pemanggil mungkin tidak sengaja menukar perintah parameter: var license = new License("My license", "XXX-123", "Customer", "User-acceptance tests", new LocalDateTime());
 Oops, saya telah menukar nama pemegang lesen dan ID lesen. IDE anda boleh membantu di sini, tetapi terdapat cara lain. Jenis Wrappers Penyokong OOP tulen dengan gembira akan menunjukkan bahawa seseorang tidak boleh menggunakan string secara langsung. sebaliknya, seseorang harus membungkus setiap parameter dalam jenis khusus, untuk java : dan g. record public record Id(String id) { ... }
public record LicenseeName(String licenseeName) { ... }
public record LicenseeId(String licenseId) { ... }
public record Environment(String environment) { ... }
public record GeneratedAt(LocalDateTime generatedAt) { ... }
 Kita tidak boleh buat kesilapan: var id = new Id("My license");
var licenseeName = new LicenseeName("Customer");
var licenseId = new LicenseeId("XXX-123");
var environment = new Environment("User-acceptance tests");
var generatedAt = new LocalDateTime();

var license = new License(id, licenseId, licenseName, environment, generatedAt); //1
 
 
 Kesilapan masa kompilasi Walaupun pendekatan ini pasti meningkatkan penyelenggaraan, wrapper meningkatkan saiz memori. peningkatan yang tepat bergantung kepada pelaksanaan JDK, tetapi untuk jenis tunggal, ia kira-kira 5 kali lebih besar. Kotlin menjadikannya angin dengan menyediakan : pembungkusan adalah cek masa kompilasi, tetapi kod bytecode menunjukkan kepada jenis yang dibungkus dengan batasan berikut: Kelas nilai inline 
 
 Kelas inline mesti mempunyai satu sifat yang dimulakan dalam pembina utama Kelas inline mesti mempunyai satu sifat yang dimulakan dalam pembina utama Nama parameter Java hanya menawarkan panggilan kaedah dengan parameter kedudukan, tetapi bahasa lain, , Python, Kotlin, dan Rust juga menawarkan parameter yang dinamakan. dan g. Berikut ialah pembina Kotlin yang mencerminkan kelas di atas: class License (
    val id: String, val licenseeName: String,
    val licenseId: String, val environment: String,
    val generatedAt: LocalDateTime
)
 Anda boleh memanggil pembina dengan menamakan parameter, dengan itu mengurangkan risiko membuat kesilapan: val license = License(
    id = "My license", licenseeName = "Customer",
    licenseId = "XXX-123", environment = "User-acceptance tests",
    generatedAt = LocalDateTime()
)
 yang Pattern Pembinaan yang pattern ialah pendekatan lain yang layak, walaupun ia bukan sebahagian daripada kes penggunaan yang diterangkan dalam GoF. Pembinaan Berikut ialah kod : public class License {

    private final String id;
    private final String licenseeName;
    private final String licenseId;
    private final String environment;
    private final LocalDateTime generatedAt;

    private License (                              //1
        String id, String licenseeName,
        String licenseId, String environment,
        LocalDateTime generatedAt
    ) { ... }
    
    public static LicenseBuilder builder() {       //2
        return new LicenseBuilder();
    }

    public static class LicenseBuilder {

        private String id;                         //3
        private String licenseeName;               //3
        private String licenseId;                  //3
        private String environment;                //3
        private LocalDateTime generatedAt;         //3

        private LicenseBuilder() {}                //1
        
        public LicenseBuilder withId(String id) {  //4
            this.id = id;                          //5
            return this;                           //4
        }
        
        // Other `withXXX` methods
        
        public License build() {                   //6
            return new License(
                id, licenseeName,
                licenseId, environment,
                generatedAt
            );
        }
    }
}
 
 
 
 
 
 
 
 Mencegah instantiasi objek langsung Mencipta pembina baru Bidang builder meniru bidang objek Setiap kaedah mengembalikan objek builder itu sendiri Masukkan atribut Kembalikan objek lengkap Sekarang boleh dipanggil pembina seperti ini: val license = License.builder()
                     .withId("My license")
                     .withLicenseName("Customer")
                     .withLicenseId("XXX-123")
                     .withEnvironment("User-acceptance tests")
                     .withGeneratedAt(new LocalDateTime())
 Mencipta kod pembina adalah kesakitan (kecuali anda menggunakan AI), tetapi ia membolehkan pembacaan yang lebih baik.Selain itu, seseorang boleh menambah pengesahan untuk setiap panggilan kaedah, memastikan objek yang sedang dibina adalah sah. . Pembina muka Ringkasan 
 
 
 
 
 
 
 
 
 
 Approach 
 Pros 
 Cons 
 
 
 
 
 Type wrappers 
 Object-Oriented Programming 
 - More verbose- Can be memory-heavy depending on the language 
 
 
 
 
 Named parameters 
 Easy 
 Not available in Java 
 
 
 
 
 Builder pattern 
 Verbose 
 - Allows creating complex objects- Allows validating Jenis Wrappers Pengaturcaraan berorientasikan objek - Lebih verbose- Boleh menjadi memori berat bergantung kepada bahasa Nama parameter mudah Tidak tersedia dalam Java Pembinaan Pattern Perkosaan - Membolehkan untuk mencipta objek yang kompleks- Membolehkan untuk mengesahkan Pembina membuang pengecualian Dalam codebase yang sama, saya mendapati kod berikut: public Stuff(UuidService uuidService, FallbackUuidService fallbackUuidService) {

    try {
        uuid = uuidService.getUuid();
    } catch(CannotGetUuidException e) {
        try {
            uuid = fallbackUuidService.getUuid();
        } catch(CannotGetUuidException e1) {
            uuid = "UUID can be fetched";
        }
    }
}
 Dengan sedikit pengalaman, anda boleh melihat apa yang salah dalam snippet di atas. ini dimulakan dengan string yang bukan UUID. Semua kod yang bergantung kepada UUID mesti berurusan dengan mungkin bukan-UUID nilai. Satu mesti gagal dengan cepat. penyelesaian cepat akan kelihatan seperti ini: uuid public Stuff(UuidService uuidService, FallbackUuidService fallbackUuidService) {

    try {
        uuid = uuidService.getUuid();
    } catch(CannotGetUuidException e) {
        try {
            uuid = fallbackUuidService.getUuid();
        } catch(CannotGetUuidException e1) {
            throw new RuntimeException(e1);
        }
    }
}
 Sekarang, setiap objek mempunyai UUID yang sah. Walau bagaimanapun, membuang pengecualian di dalam pembina mempunyai masalah yang berpotensi: Stuff 
 
 
 
 Resource Leaks: Jika pembina mengalokasikan sumber (contohnya, fail, soket) dan membuang pengecualian, sumber tersebut mungkin tidak dikeluarkan. Warisan: Jika pembina superkelas melemparkan pengecualian, pembina subkelas tidak akan berjalan. Pengecualian yang disahkan: Ia adalah mustahil untuk menggunakan pengecualian yang disahkan dalam pembina, hanya yang runtime. Untuk sebab-sebab ini, saya fikir pengecualian tidak mempunyai tempat di dalam pembina dan saya mengelakkan mereka. pattern yang diterangkan dalam seksyen pertama, tetapi seperti yang dinyatakan, ia banyak kod; Saya tidak fikir ia perlu. . Pembinaan Kaedah kilang 
 
 
 
 
 
 cubaan Tentukan antara muka untuk mencipta objek, tetapi biarkan subkelas memutuskan kelas mana yang akan diinstansi. kegunaan Gunakan model Kaedah Kilang apabila: 
 
 
 
 sebuah kelas tidak boleh meramalkan kelas objek yang mesti dicipta. sebuah kelas mahu subkelasnya untuk menentukan objek yang dicipta. Kelas mengalihkan tanggungjawab kepada salah satu daripada beberapa subkelas penolong, dan anda ingin menubuhkan pengetahuan yang subkelas penolong adalah delegat. Intent Tentukan antara muka untuk mencipta objek, tetapi biarkan subkelas memutuskan kelas mana yang akan diinstansi. Applicability Gunakan model Kaedah Kilang apabila: 
 
 
 
 sebuah kelas tidak boleh meramalkan kelas objek yang mesti dicipta. sebuah kelas mahu subkelasnya untuk menentukan objek yang dicipta. Kelas mengalihkan tanggungjawab kepada salah satu daripada beberapa subkelas penolong, dan anda ingin menubuhkan pengetahuan yang subkelas penolong adalah delegat. Sila ambil perhatian bahawa dalam kes ini, kami menggunakannya untuk sebab yang berbeza. Berikut ialah kod yang dikemas kini: public class Stuff {

    private final UUID uuid;
    
    private Stuff(UUID uuid) {                               //1
        this.uuid = uuid;
    }

    public static Stuff create(UuidService uuidService, FallbackUuidService fallbackUuidService) throws CannotGetUuidException {
    
        try {
            return new Stuff(uuidService.getUuid());
        } catch(CannotGetUuidException e) {
            return new Stuff(fallbackUuidService.getUuid()); //2
        }
    }
}
 
 
 
 Mencegah penyelewengan luar Jika ia gagal, ia melemparkan CannotGetUuidException baru Yang di atas boleh dipanggil seperti ini: var stuff = Stuff.create(uuidService, fallbackUuidService);  //1
 
 
 Perlu untuk menangkap CannotGetUuidException Pada titik ini, kami yakin bahawa objek ini sepenuhnya dimulakan jika panggilan berjaya. Kesimpulan Dalam post ini, saya telah menerangkan dua penggunaan corak kreatif GoF, yang tidak disenaraikan dalam buku ini: meningkatkan penyelenggaraan dan memastikan objek sepenuhnya dimulakan. mengetahui klasik anda membolehkan anda menggunakannya dalam kes yang sesuai, tetapi tidak disenaraikan pada mulanya. To go further: 
 
 
 
 GoF Reka Bentuk Pattern Memasuki Pattern Pembina Pattern Builder ialah sebuah mesin keadaan terbatas! Awalnya diterbitkan di A Java Geek pada 31st August, 2025 Tag: java geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Audio ini dihasilkan dalam bahasa asal cerita!

Terlalu panjang; Untuk membaca

Make resilience your competitive advantage

Penciptaan objek: isu-isu yang saya hadapi dan corak yang membantu saya

About Author

KOMEN

GANTUNG TANDA

ARTIKEL INI DIBENTANGKAN DALAM

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps