Pengenalan Corak Reka Bentuk Penciptaan

Pengaturcaraan

1. Pengenalan

Dalam kejuruteraan perisian, Pola Reka bentuk menerangkan penyelesaian yang mantap untuk masalah yang paling sering dihadapi dalam reka bentuk perisian. Ini mewakili amalan terbaik yang dikembangkan dalam jangka masa panjang melalui percubaan dan kesilapan oleh pembangun perisian yang berpengalaman.

Design Patterns mendapat populariti setelah buku Design Patterns: Elements of Reusable Object-Oriented Software diterbitkan pada tahun 1994 oleh Erich Gamma, John Vlissides, Ralph Johnson, dan Richard Helm (juga dikenal sebagai Gang of Four atau GoF).

Dalam artikel ini, kita akan meneroka corak reka bentuk dan jenisnya. Kami juga akan melihat beberapa contoh kod dan membincangkan situasi ketika corak ini sesuai dengan reka bentuk kami.

2. Corak Reka Cipta

Corak Reka Bentuk Penciptaan berkaitan dengan cara pembuatan objek. Mereka mengurangkan kerumitan dan ketidakstabilan dengan membuat objek secara terkawal.

Yang baru operator sering dianggap berbahaya kerana ia mencerai-beraikan objek seluruh permohonan. Lama kelamaan boleh menjadi sukar untuk mengubah pelaksanaan kerana kelas menjadi gandingan erat.

Pola Reka Bentuk Penciptaan menangani masalah ini dengan melepaskan pelanggan sepenuhnya dari proses permulaan yang sebenarnya.

Dalam artikel ini, kita akan membincangkan empat jenis Corak Reka Bentuk Penciptaan:

  1. Singleton - Memastikan bahawa hanya terdapat satu contoh objek yang wujud sepanjang aplikasi
  2. Kaedah Kilang - Membuat objek dari beberapa kelas yang berkaitan tanpa menentukan objek yang tepat untuk dibuat
  3. Abstrak Kilang - Membuat keluarga dari objek bergantung yang berkaitan
  4. Pembina - Membina objek yang kompleks menggunakan pendekatan langkah demi langkah

Mari kita bincangkan setiap corak ini secara terperinci.

3. Corak Reka Bentuk Singleton

Pola Reka Bentuk Singleton bertujuan untuk mengawasi inisialisasi objek dari kelas tertentu dengan memastikan hanya satu contoh objek yang ada di seluruh Mesin Virtual Java.

Kelas Singleton juga menyediakan satu titik akses global yang unik ke objek sehingga setiap panggilan berikutnya ke titik akses hanya mengembalikan objek tertentu.

3.1. Contoh Corak Singleton

Walaupun corak Singleton diperkenalkan oleh GoF, pelaksanaan asalnya diketahui bermasalah dalam senario multithreaded.

Jadi di sini, kita akan mengikuti pendekatan yang lebih optimum yang menggunakan kelas dalaman yang statik:

public class Singleton { private Singleton() {} private static class SingletonHolder { public static final Singleton instance = new Singleton(); } public static Singleton getInstance() { return SingletonHolder.instance; } }

Di sini, kami telah membuat kelas dalaman statik yang memegang contoh kelas Singleton . Ini membuat contoh hanya apabila seseorang memanggil kaedah getInstance () dan bukan ketika kelas luar dimuat.

Ini adalah pendekatan yang digunakan secara meluas untuk kelas Singleton kerana ia tidak memerlukan penyegerakan, selamat menggunakan utas, menguatkan inisialisasi malas dan relatif tidak banyak lagi.

Juga, perhatikan bahawa pembina mempunyai pengubah akses peribadi . Ini adalah syarat untuk membuat Singleton kerana konstruktor awam bermaksud sesiapa sahaja dapat mengaksesnya dan mula membuat contoh baru.

Ingat, ini bukan pelaksanaan GoF yang asli. Untuk versi asal, sila kunjungi artikel Baeldung yang dipautkan di Singletons di Jawa ini.

3.2. Bilakah Menggunakan Corak Reka Bentuk Singleton

  • Untuk sumber yang mahal untuk dibuat (seperti objek sambungan pangkalan data)
  • Adalah amalan yang baik untuk menjadikan semua pembalak sebagai Singleton yang meningkatkan prestasi
  • Kelas yang menyediakan akses ke tetapan konfigurasi untuk aplikasi
  • Kelas yang mengandungi sumber yang diakses dalam mod bersama

4. Corak Reka Bentuk Kaedah Kilang

Corak Reka Bentuk Kilang atau Kaedah Pola Kaedah Pabrik adalah salah satu corak reka bentuk yang paling banyak digunakan di Jawa.

Menurut GoF, pola ini "mendefinisikan antara muka untuk membuat objek, tetapi biarkan subkelas memutuskan kelas mana yang akan dibuat. Kaedah Factory membolehkan kelas menangguhkan instansi kepada subkelas ”.

Corak ini menyerahkan tanggungjawab memulakan kelas dari klien ke kelas kilang tertentu dengan membuat sejenis pembina maya.

Untuk mencapainya, kami bergantung pada kilang yang menyediakan kami objek, menyembunyikan perincian pelaksanaan yang sebenarnya. Objek yang dibuat diakses menggunakan antara muka biasa.

4.1. Contoh Corak Kaedah Kaedah Kilang

Dalam contoh ini, kami akan membuat antara muka Polygon yang akan dilaksanakan oleh beberapa kelas konkrit. A PolygonFactory akan digunakan untuk mengambil objek dari keluarga ini:

Mari buat dahulu antara muka Polygon :

public interface Polygon { String getType(); }

Seterusnya, kami akan membuat beberapa implementasi seperti Square , Triangle, dll. Yang melaksanakan antaramuka ini dan mengembalikan objek jenis Polygon .

Sekarang kita dapat membuat sebuah kilang yang menganggap bilangan sisi sebagai argumen dan mengembalikan pelaksanaan antara muka ini yang sesuai:

public class PolygonFactory { public Polygon getPolygon(int numberOfSides) { if(numberOfSides == 3) { return new Triangle(); } if(numberOfSides == 4) { return new Square(); } if(numberOfSides == 5) { return new Pentagon(); } if(numberOfSides == 7) { return new Heptagon(); } else if(numberOfSides == 8) { return new Octagon(); } return null; } }

Perhatikan bagaimana pelanggan boleh bergantung pada kilang ini untuk memberi kita Poligon yang sesuai , tanpa harus menginisialisasi objek secara langsung.

4.2. Bilakah Menggunakan Corak Reka Bentuk Kaedah Kilang

  • Apabila pelaksanaan antara muka atau kelas abstrak diharapkan sering berubah
  • Apabila pelaksanaan semasa tidak dapat menampung perubahan baru dengan selesa
  • Apabila proses inisialisasi agak mudah, dan konstruktor hanya memerlukan segelintir parameter

5. Abstract Factory Design Pattern

In the previous section, we saw how the Factory Method design pattern could be used to create objects related to a single family.

By contrast, the Abstract Factory Design Pattern is used to create families of related or dependent objects. It's also sometimes called a factory of factories.

For a detailed explanation, check out our Abstract Factory tutorial.

6. Builder Design Pattern

The Builder Design Pattern is another creational pattern designed to deal with the construction of comparatively complex objects.

When the complexity of creating object increases, the Builder pattern can separate out the instantiation process by using another object (a builder) to construct the object.

This builder can then be used to create many other similar representations using a simple step-by-step approach.

6.1. Builder Pattern Example

The original Builder Design Pattern introduced by GoF focuses on abstraction and is very good when dealing with complex objects, however, the design is a little complicated.

Joshua Bloch, in his book Effective Java, introduced an improved version of the builder pattern which is clean, highly readable (because it makes use of fluent design) and easy to use from client's perspective. In this example, we'll discuss that version.

This example has only one class, BankAccount which contains a builder as a static inner class:

public class BankAccount { private String name; private String accountNumber; private String email; private boolean newsletter; // constructors/getters public static class BankAccountBuilder { // builder code } }

Note that all the access modifiers on the fields are declared private since we don't want outer objects to access them directly.

The constructor is also private so that only the Builder assigned to this class can access it. All of the properties set in the constructor are extracted from the builder object which we supply as an argument.

We've defined BankAccountBuilder in a static inner class:

public static class BankAccountBuilder { private String name; private String accountNumber; private String email; private boolean newsletter; public BankAccountBuilder(String name, String accountNumber) { this.name = name; this.accountNumber = accountNumber; } public BankAccountBuilder withEmail(String email) { this.email = email; return this; } public BankAccountBuilder wantNewsletter(boolean newsletter) { this.newsletter = newsletter; return this; } public BankAccount build() { return new BankAccount(this); } }

Notice we've declared the same set of fields that the outer class contains. Any mandatory fields are required as arguments to the inner class's constructor while the remaining optional fields can be specified using the setter methods.

This implementation also supports the fluent design approach by having the setter methods return the builder object.

Finally, the build method calls the private constructor of the outer class and passes itself as the argument. The returned BankAccount will be instantiated with the parameters set by the BankAccountBuilder.

Let's see a quick example of the builder pattern in action:

BankAccount newAccount = new BankAccount .BankAccountBuilder("Jon", "22738022275") .withEmail("[email protected]") .wantNewsletter(true) .build();

6.2. When to Use Builder Pattern

  1. When the process involved in creating an object is extremely complex, with lots of mandatory and optional parameters
  2. When an increase in the number of constructor parameters leads to a large list of constructors
  3. When client expects different representations for the object that's constructed

7. Conclusion

Dalam artikel ini, kami belajar mengenai corak reka bentuk kreasi di Java. Kami juga membincangkan empat jenisnya, iaitu, Singleton, Kaedah Kilang, Corak Abstrak dan Pembina, kelebihan mereka, contoh dan kapan kita harus menggunakannya.

Seperti biasa, coretan kod lengkap boleh didapati di GitHub.