Artikel ini menjelaskan model pabrik pola desain java. Bagikan untuk referensi Anda, sebagai berikut:
1. Pabrik sederhana
Mari kita pikirkan pertanyaan terlebih dahulu. Ketika kami menulis program, akan ada situasi seperti itu. Objek A perlu memanggil metode objek B. Pada saat ini, kami biasanya menggunakan kata kunci baru untuk membuat instance B dan kemudian memanggil metode instance B. Kerugian dari pendekatan ini adalah bahwa metode kelas A secara langsung memanggil nama kelas kelas B (metode ini juga disebut kopling hard-coded). Setelah sistem perlu di -refactored: Ketika kelas C perlu digunakan sebagai pengganti Kelas B, program harus memodifikasi kode Kelas A. Jika 100 atau 10.000 kelas dalam aplikasi ini adalah kode keras, 100 atau 10.000 tempat perlu dimodifikasi, yang jelas merupakan hal yang sangat mengerikan.
Looking at this problem from another perspective: for an object already A, it only needs to call the method of object B, and does not care about the implementation and creation process of object B, consider letting class B implement an IB interface, while class A only needs to be coupled with the IB interface - Class A does not directly use the new keyword to create B instances, but redefines a factory class: IBFactory, which is responsible for creating IB instances, and Class A uses the method menelepon pabrik ibfactory untuk mendapatkan instance IB. Melalui desain di atas: Jika Anda perlu menggunakan kelas C alih -alih Kelas B, Anda hanya perlu membiarkan Kelas C mengimplementasikan antarmuka IB dan menulis ulang kode implementasi untuk membuat instance IB di pabrik IBFactory, sehingga pabrik dapat menghasilkan instance C. Metode desain untuk menyerahkan beberapa objek kelas ini ke kelas pabrik untuk generasi disebut pola pabrik sederhana.
Berikut ini kode untuk pola pabrik sederhana:
/*** Mode Pabrik Sederhana* Antarmuka Umum Yang Membutuhkan Instance Objek yang Diproduksi Pabrik* Antarmuka Gaya Rambut* Administrator @Author**/Antarmuka Publik Rambut {/*** Gambar gaya rambut*/public void draw ();}/*** Rambut Left-Distribution Hairstyle* @Author Administrator*/Kelas Publik LeftAir @Anover @Author Rambut @Anover @Author Void @Author Rambut @Author @Anover @Author Void @Author @Anover @Author Rambut @Anover @Author LeftAir @Anover @Author B. System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- * */public class RightHair mengimplementasikan rambut {@override public void draw () { System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Administrator */kelas publik Hairtest {public static void main (string [] args) {hairfactory factory = new hairfactory ();Seperti yang Anda lihat, jika Anda ingin mengubah lefthair yang dihasilkan di Haittest ke Righthair, Anda hanya perlu memodifikasi implementasi metode GetHair di Hairfactory.
Keuntungan menggunakan mode pabrik sederhana adalah bahwa ia memisahkan penelepon objek dan proses pembuatan objek. Ketika penelepon objek membutuhkan suatu objek, ia dapat secara langsung memintanya dari pabrik, sehingga menghindari penelepon objek dan kelas implementasi objek yang digabungkan dengan cara yang sulit untuk meningkatkan pemeliharaan dan skalabilitas sistem. Tentu saja, model pabrik juga memiliki cacat kecil. Ketika produk dimodifikasi, kelas pabrik juga perlu dimodifikasi sesuai. Di sini Anda dapat menggunakan model kebijakan untuk menyelesaikannya. Berikut ini adalah kodenya.
Public Interface HairBuilder { / *** Buat Gaya Rambut* @Return* / Public Hair GetHair ();} Kelas Publik LefthairBuilder mengimplementasikan hairbuilder {@override public hair gethair () {return new lefthair (); }} kelas publik RightHairBuilder mengimplementasikan hairbuilder {@override public hair getHair () {return new righthair (); }} hairfactory kelas publik {private hairbuilder hairbuilder; hairfactory publik (hairbuilder hairbuilder) {this.hairbuilder = hairbuilder; } public void setHairBuilder (hairbuilder hairbuilder) {this.hairbuilder = hairbuilder; } public hair getHair () {return hairbuilder.getHair (); }} kelas publik haittest {public static void main (string [] args) {// hairbuilder builder = new lefthairbuilder (); Pembangun hairbuilder = righthairbuilder baru (); Factory Hairfactory = Hairfactory baru (pembangun); Rambut rambut = factory.gethair (); hair.draw (); }}Keuntungan dari pendekatan ini adalah bahwa tidak perlu memodifikasi kelas pabrik lagi, dan abstrak logika penciptaan di pabrik sesuai dengan strategi yang berbeda. Objek apa yang perlu dibuat program? Lewati saja pembangun yang sesuai ke pabrik jaringan.
2. Metode pabrik
Dalam model pabrik yang sederhana, sistem menggunakan kelas pabrik untuk menghasilkan semua contoh produk, dan kelas pabrik memutuskan kelas contoh mana yang akan diproduksi, yaitu, kelas pabrik bertanggung jawab atas semua penilaian logis, pembuatan instance dan karya lainnya.
Jika Anda tidak ingin membuat penilaian logis di kelas pabrik, program ini dapat menyediakan pabrik yang berbeda untuk kategori produk yang berbeda, dan kelas pabrik yang berbeda menghasilkan produk yang berbeda, tanpa membuat penilaian logis yang kompleks di kelas pabrik. Ini agak mirip dengan model pabrik sederhana yang dikombinasikan dengan model strategi di atas. Perbedaannya adalah bahwa yang pertama hanya memiliki satu pabrik, sedangkan yang terakhir membutuhkan banyak pabrik. Di bawah ini adalah kode untuk pola metode pabrik.
/*** Pola Metode Pabrik* Antarmuka Umum Diperlukan untuk diimplementasikan oleh Contoh Objek yang Diproduksi oleh Pabrik* @Author Administrator**/Public Interface Person {public void drawperson ();} Public Class Man mengimplementasikan orang {@Override public drawperson () { System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @Author Administrator */Kelas Publik WomenFactory mengimplementasikan Personfactory {@Override Public Person GetPerson () {Return New Women () orang = factory.getPerson ();Fitur khas dari jenis ini adalah bahwa ia menghasilkan produk yang sesuai menurut berbagai pabrik dalam kode klien, dan tidak perlu memasukkan semua logika kompleks ke dalam kelas pabrik untuk menilai. Ada cacat yang jelas dalam implementasi ini, yaitu klien digabungkan dengan kelas pabrik.
3. Pabrik abstrak
Menggunakan arsitektur desain di atas dari metode pabrik, kode klien berhasil dipisahkan dari kelas implementasi objek yang disebut, tetapi membawa kopling lain: kode klien digabungkan dengan kelas pabrik yang berbeda. Untuk menyelesaikan masalah kopling ini, pertimbangkan untuk menambahkan kelas pabrik untuk menghasilkan contoh pabrik dan memisahkan pabrik dari klien untuk memproduksi produk. Metode desain ini disebut model pabrik abstrak. Di bawah ini adalah kode untuk pola pabrik abstrak
/*** Pola Pabrik Abstrak* Pabrik yang memproduksi Personfactory* @Author Administrator**/Public Class PersonFactoryFactory {public static personfactory getPersonFactory (string type) {if (type.equalsignorecase ("man")) {return new mancactory (); } else {return new WomenFactory (); }}}/** * kelas tes klien * @Author Administrator * */kelas publik personTest {public static void main (string [] args) {personfactory factory = personfactoryFactory.getPersonFactory ("man"); Orang orang = factory.getPerson (); orang.drawperson (); }}Untuk konten yang lebih terkait dengan Java, pembaca yang tertarik dengan situs ini dapat melihat topik: "Tutorial Struktur Data Java dan Algoritma", "Ringkasan Java Operation Dom Node Tips", "Ringkasan Tips Operasi Java File dan Direktori" dan "Ringkasan Java Cache Tips"
Saya harap artikel ini akan membantu pemrograman Java semua orang.