โหมดวิธีโรงงาน
แรงจูงใจในการสร้างวัตถุมักจะต้องใช้กระบวนการที่ซับซ้อนดังนั้นจึงไม่เหมาะสำหรับการรวมในโรงงานคอมโพสิต เมื่อมีผลิตภัณฑ์ใหม่โรงงานคอมโพสิตจะต้องมีการแก้ไขซึ่งไม่เอื้อต่อการขยายตัว
นอกจากนี้การสร้างวัตถุบางอย่างอาจต้องการข้อมูลที่ไม่สามารถเข้าถึงได้โดยโรงงานคอมโพสิต ดังนั้นกำหนดอินเทอร์เฟซโรงงานและกำหนดว่าผลิตภัณฑ์ใดที่สร้างอินสแตนซ์โดยการใช้อินเทอร์เฟซนี้ นี่คือรูปแบบวิธีการของโรงงานซึ่งทำให้การสร้างอินสแตนซ์ของคลาสเป็นคลาสย่อย
วัตถุประสงค์
1. กำหนดอินเทอร์เฟซและให้คลาสย่อยตัดสินใจว่าผลิตภัณฑ์ใดที่จะสร้างอินสแตนซ์
2. สร้างวัตถุผ่านอินเทอร์เฟซทั่วไป
ทำให้สำเร็จ
1. อินเทอร์เฟซผลิตภัณฑ์และผลิตภัณฑ์เฉพาะเข้าใจง่าย
2. คลาสโรงงานให้วิธีการโรงงานที่ส่งคืนวัตถุผลิตภัณฑ์ แต่วิธีการโรงงานนี้เป็นนามธรรม
3. ใช้วิธีการโรงงานในโรงงานเฉพาะและสร้างผลิตภัณฑ์เฉพาะให้เสร็จสมบูรณ์
// ปุ่มคลาสคลาสหลายปุ่ม {/* ...*/} คลาส WinButton ขยายปุ่ม {/* ...*/} คลาส MacButton ขยายปุ่ม {/* ...*/} // คลาสโรงงานของพวกเขาอินเตอร์เฟส buttonfactory {ปุ่มนามธรรม CreateButton (); } คลาส WinButtonFactory ใช้ ButtonFactory {ปุ่ม CreateButton () {ส่งคืน WinButton ใหม่ (); }} คลาส MACBUTTONFACTORY ใช้ ButtonFactory {ปุ่ม CreateButton () {ส่งคืน MacButton ใหม่ (); - สถานการณ์ที่เกี่ยวข้อง
1. เมื่อมีรหัสที่ซ้ำกันมากขึ้นเมื่อสร้างวัตถุคุณสามารถพิจารณาใช้รูปแบบวิธีการโรงงานเพื่อเรียกใช้ส่วนที่ซ้ำกันเหล่านี้
2. การสร้างวัตถุต้องมีการเข้าถึงข้อมูลบางอย่างซึ่งไม่ควรรวมอยู่ในคลาสโรงงาน จากนั้นคลาสย่อยสามารถใช้การสร้างวัตถุ
3. เมื่อคุณต้องการจัดการการสร้างวัตถุเพื่อรักษาความสอดคล้องของโปรแกรม
รูปแบบโรงงานนามธรรม
การกำหนดรูปแบบโรงงานนามธรรมให้วิธีการห่อหุ้มชุดของโรงงานแยกต่างหากด้วยชุดรูปแบบเดียวกัน ในการใช้งานปกติโปรแกรมไคลเอนต์จำเป็นต้องสร้างการใช้งานที่เป็นรูปธรรมของโรงงานนามธรรมแล้วใช้โรงงานนามธรรมเป็นอินเทอร์เฟซเพื่อสร้างวัตถุคอนกรีตสำหรับหัวข้อนี้ โปรแกรมไคลเอนต์ไม่จำเป็นต้องรู้ (หรือใส่ใจ) ว่าได้รับประเภทของวัตถุเฉพาะจากวิธีการโรงงานภายในเหล่านี้เนื่องจากโปรแกรมไคลเอนต์ใช้อินเทอร์เฟซทั่วไปของวัตถุเหล่านี้เท่านั้น รูปแบบของโรงงานนามธรรมจะแยกรายละเอียดการใช้งานของชุดวัตถุออกจากการใช้งานทั่วไป
"โรงงาน" เป็นที่ที่ผลิตภัณฑ์ (วัตถุ) ถูกสร้างขึ้นและวัตถุประสงค์ของมันคือการแยกการสร้างผลิตภัณฑ์ออกจากการใช้งาน วัตถุประสงค์ของแบบจำลองโรงงานนามธรรมคือการแยกอินเทอร์เฟซของผลิตภัณฑ์นามธรรมหลายอย่างจากการใช้งานเฉพาะของผลิตภัณฑ์ธีมที่แตกต่างกัน ด้วยวิธีนี้เมื่อเพิ่มโรงงานเฉพาะใหม่คุณไม่จำเป็นต้องแก้ไขรหัสลูกค้าที่อ้างอิงโรงงานนามธรรม
การใช้รูปแบบโรงงานนามธรรมช่วยให้คุณสามารถเปลี่ยนโรงงานเฉพาะโดยไม่ต้องแก้ไขรหัสไคลเอนต์โดยใช้โรงงานแม้ในเวลารันไทม์ อย่างไรก็ตามการใช้รูปแบบนี้หรือรูปแบบการออกแบบที่คล้ายกันอาจนำมาซึ่งความซับซ้อนที่ไม่จำเป็นและงานเพิ่มเติมในการเขียนโค้ด การใช้รูปแบบการออกแบบที่เหมาะสมสามารถชดเชย "งานพิเศษ" ดังกล่าว
ทำให้สำเร็จ
1. AbstractFactory - กำหนดวิธีการเชื่อมต่อสำหรับการสร้างผลิตภัณฑ์นามธรรม
2. คอนกรีตฟิล์ม - ใช้วิธีการเพื่อสร้างผลิตภัณฑ์เฉพาะ
3. AbstractProduct - อินเทอร์เฟซที่ประกาศผลิตภัณฑ์ประเภทต่างๆ
4. ผลิตภัณฑ์ - กำหนดผลิตภัณฑ์เฉพาะที่สอดคล้องกับคอนกรีตฟิล์มและใช้ส่วนต่อประสานนามธรรม
5. ไคลเอนต์ - ใช้คลาส AbstractFactory และ AbstractProduct
บทคัดย่อคลาส AbstractProducta {Public Abstract Void OperationA1 (); บทคัดย่อสาธารณะเป็นโมฆะ Public OperationA2 (); } คลาส producta1 ขยาย AbstractProducta {producta1 (string arg) {system.out.println ("hello"+arg); } // ใช้รหัสที่นี่โมฆะสาธารณะ Public OperationA1 () {}; โมฆะสาธารณะ OperationA2 () {}; } คลาส producta2 ขยาย AbstractProducta {producta2 (string arg) {system.out.println ("hello"+arg); } // ใช้รหัสที่นี่โมฆะสาธารณะ Public OperationA1 () {}; โมฆะสาธารณะ OperationA2 () {}; } บทคัดย่อคลาส AbstractProductB {// Public Abtract Void Operationb1 (); // บทคัดย่อสาธารณะ Public Void Operationb2 (); } คลาส ProductB1 ขยาย AbstractProductB {ProductB1 (String arg) {system.out.println ("hello"+arg); } // ใช้รหัสที่นี่} คลาส ProductB2 ขยาย AbstractProductB {ProductB2 (String arg) {system.out.println ("hello"+arg); } // ใช้รหัสที่นี่} คลาสบทคัดย่อบทคัดย่อ {บทคัดย่อ AbstractProducta createProducta (); บทคัดย่อบทคัดย่อ createProductb () บทคัดย่อ; } คลาส ConcreteFactory1 ขยาย AbstractFactory {AbstractProducta createProducta () {ส่งคืน producta1 ใหม่ ("producta1"); } AbstractProductB createProductB () {ส่งคืน ProductB1 ใหม่ ("ProductB1"); }} คลาส ConcreteFactory2 ขยายบทคัดย่อ {AbstractProducta createProducta () {ส่งคืน producta2 ใหม่ ("producta2"); } AbstractProductB createProductB () {ส่งคืน ProductB2 ใหม่ ("ProductB2"); }} // ผู้สร้างโรงงาน - วิธีทางอ้อมในการสร้างอินสแตนซ์ของโรงงานโรงงานโรงงาน {ส่วนตัวคงที่นามธรรม pf = null; นามธรรมแบบคงที่ getFactory (ตัวเลือกสตริง) {ถ้า (ตัวเลือก. equals ("a")) {pf = ใหม่ concreteFactory1 (); } อื่นถ้า (ตัวเลือก. equals ("b")) {pf = ใหม่ concreteFactory2 (); } return pf; }} // ไคลเอนต์คลาสสาธารณะไคลเอนต์ {โมฆะคงที่สาธารณะหลัก (สตริง args []) {AbstractFactory pf = fatorymaker.getFactory ("A"); AbstractProducta Product = Pf.CreateProducta (); // การเรียกใช้ฟังก์ชันเพิ่มเติมเกี่ยวกับผลิตภัณฑ์}}คลาสผู้ผลิตโรงงานใช้โหมดโรงงานอย่างง่ายในขณะที่การใช้งานโรงงานเฉพาะใช้โหมดวิธีการโรงงาน
สถานการณ์ที่เกี่ยวข้อง
1. ระบบเป็นอิสระจากการสร้างองค์ประกอบและการเป็นตัวแทนของผลิตภัณฑ์
2. เมื่อระบบได้รับการกำหนดค่าโดยหนึ่งในหลายครอบครัวผลิตภัณฑ์
3. จำเป็นต้องเน้นการออกแบบชุดของวัตถุผลิตภัณฑ์ที่เกี่ยวข้องสำหรับการใช้งานร่วมกัน
4. จัดเตรียมไลบรารีผลิตภัณฑ์และต้องการแสดงอินเทอร์เฟซแทนการใช้งานเท่านั้น
ข้อได้เปรียบ
1. ผลิตภัณฑ์เฉพาะถูกแยกออกจากรหัสลูกค้า
2. ซีรีส์ที่สามารถเปลี่ยนแปลงได้อย่างง่ายดาย
3. สร้างชุดของครอบครัวผลิตภัณฑ์ด้วยกัน
ข้อบกพร่อง
1. เป็นการยากที่จะขยายผลิตภัณฑ์ใหม่ในตระกูลผลิตภัณฑ์มันต้องมีการปรับเปลี่ยนอินเทอร์เฟซของโรงงานนามธรรมและโรงงานเฉพาะ