รูปแบบโรงงานและกลยุทธ์แตกต่างกันอย่างไร

มีใครอธิบายความแตกต่างระหว่างรูปแบบโรงงานและกลยุทธ์ได้หรือไม่?

สำหรับฉันทั้งสองดูเหมือนกันนอกเหนือจากคลาสโรงงานเพิ่มเติม (ซึ่งสร้างวัตถุของผลิตภัณฑ์ในรูปแบบโรงงาน)

รูปแบบโรงงานเป็นรูปแบบที่สร้างสรรค์ รูปแบบกลยุทธ์เป็นรูปแบบการดำเนินงาน อีกวิธีหนึ่งรูปแบบจากโรงงานถูกใช้เพื่อสร้างวัตถุประเภทเฉพาะ รูปแบบกลยุทธ์ถูกใช้เพื่อดำเนินการ (หรือชุดของการดำเนินการ) ในลักษณะเฉพาะ ในตัวอย่างแบบคลาสสิกโรงงานอาจสร้างสัตว์ประเภทต่าง ๆ : สุนัขแมวเสือในขณะที่รูปแบบกลยุทธ์จะดำเนินการบางอย่างเช่นย้าย; ใช้กลยุทธ์ Run, Walk หรือ Lope

ในความเป็นจริงทั้งสองสามารถใช้ร่วมกัน ตัวอย่างเช่นคุณอาจมีโรงงานที่สร้างวัตถุธุรกิจของคุณ อาจใช้กลยุทธ์ที่แตกต่างกันตามสื่อที่มีอยู่ หากข้อมูลของคุณถูกจัดเก็บไว้ใน XML มันจะใช้กลยุทธ์เดียว หากข้อมูลเป็นระยะไกลในฐานข้อมูลอื่นก็จะใช้อีก

รูปแบบกลยุทธ์ช่วยให้คุณเปลี่ยนพฤติกรรมที่หลากหลายของชั้นเรียน

รูปแบบจากโรงงานช่วยให้คุณสามารถสรุปการสร้างวัตถุ

แกรี่ทำให้เป็นจุดที่ดี หากคุณกำลังใช้หลักการของการเขียนรหัสไปยัง abstractions แทนที่จะเป็น "concretions" ดังนั้นรูปแบบจำนวนมากจะเริ่มดูเหมือนการเปลี่ยนแปลงในชุดรูปแบบ

เพียงเพิ่มสิ่งที่ tvanfosson พูดรูปแบบมากมายดูเหมือนว่าจะนำไปใช้งาน คุณได้สร้างอินเทอร์เฟซที่อาจไม่เคยมีมาก่อนในรหัสของคุณแล้วสร้างการใช้งานอินเทอร์เฟซนั้นมากมาย ความแตกต่างอยู่ในวัตถุประสงค์และวิธีการใช้งาน

• รูปแบบโรงงาน (วิธีการ)

สร้างตัวอย่างที่เป็นรูปธรรมเท่านั้น ข้อโต้แย้งที่แตกต่างกันอาจส่งผลให้วัตถุที่แตกต่างกัน มันขึ้นอยู่กับตรรกะ ฯลฯ

• รูปแบบกลยุทธ์

แค็ปซูลอัลกอริทึม (ขั้นตอน) เพื่อดำเนินการ ดังนั้นคุณสามารถเปลี่ยนกลยุทธ์และใช้อัลกอริทึมอื่น

ในขณะที่ทั้งคู่ดูเหมือนคล้ายกันมากจุดประสงค์ค่อนข้างต่างกันจุดประสงค์หนึ่งคือการสร้างอีกแบบหนึ่งเพื่อดำเนินการ

ดังนั้น. หากวิธีโรงงานของคุณได้รับการแก้ไขคุณอาจมีลักษณะเช่นนี้:

 public Command getCommand( int operatingSystem ) { 
      switch( operatingSystem ) { 
           case UNIX    :
           case LINUX   : return new UnixCommand();
           case WINDOWS : return new WindowsCommand();
           case OSX     : return new OSXCommand();
       }
  }

แต่สมมติว่าโรงงานของคุณต้องการการสร้างขั้นสูงหรือแบบไดนามิกมากขึ้น คุณสามารถเพิ่มกลยุทธ์และเปลี่ยนแปลงวิธีการในโรงงานโดยไม่ต้องทำการคอมไพล์ใหม่กลยุทธ์อาจเปลี่ยนเมื่อรันไทม์

ก่อนอื่นต้องสร้างโรงงานธรรมดาและโรงงานนามธรรม อันแรกเป็นโรงงานธรรมดาที่คุณมีเพียงคลาสเดียวซึ่งทำหน้าที่เป็นโรงงานสำหรับการสร้างวัตถุในขณะที่คุณเชื่อมต่อกับอินเทอร์เฟซโรงงาน (ซึ่งกำหนดชื่อเมธอด) จากนั้นเรียกโรงงานอื่นที่ใช้อินเทอร์เฟซนี้ ควรจะมีการใช้งานที่แตกต่างกันของวิธีการเดียวกันตามเกณฑ์บางอย่าง ตัวอย่างเช่นเรามีอินเตอร์เฟซ ButtonCreationFactory ซึ่งดำเนินการโดยสองโรงงาน WindowsButtonCreationFactory แรก (สร้างปุ่มที่มีรูปลักษณ์และความรู้สึกของ Windows) และ LinuxButtonCreationFactory ตัวที่สอง (สร้างปุ่มที่มีรูปลักษณ์ Linux) ดังนั้นทั้งสองโรงงานจึงมีวิธีการสร้างที่เหมือนกันโดยมีการใช้งานที่แตกต่างกัน (อัลกอริทึม)

ตัวอย่างเช่นหากคุณต้องการปุ่มที่มีรูปลักษณ์และความรู้สึกของ Linux:

ButtonCreationFactory myFactory = new LinuxButtonCreationFactory();
Button button1 = myFactory.createButton(...);

หรือถ้าคุณต้องการปุ่ม Windows

ButtonCreationFactory myFactory = new WindowsButtonCreationFactory();
Button button1 = myFactory.createButton(...);

ในกรณีนี้มันส่งผลในรูปแบบของกลยุทธ์เนื่องจากมันสร้างอัลกอริทึมที่แตกต่างสำหรับการสร้างบางอย่าง อย่างไรก็ตามมันแตกต่างจากความหมายเพราะใช้สำหรับการสร้าง OBJECT มากกว่าอัลกอริธึมการทำงาน ดังนั้นโดยทั่วไปกับโรงงานนามธรรมคุณมีการสร้างวัตถุโดยใช้กลยุทธ์ที่แตกต่างกันซึ่งทำให้คล้ายกับรูปแบบกลยุทธ์ อย่างไรก็ตาม AbstractFactory นั้นสร้างสรรค์ในขณะที่รูปแบบกลยุทธ์นั้นเปิดใช้งาน การนำไปใช้อย่างชาญฉลาดพวกเขาส่งผลให้เหมือนกัน

โรงงาน (และวิธีการส่งคืนจากโรงงาน) :

1. รูปแบบ Creational
2. ขึ้นอยู่กับมรดก
3. โรงงานส่งคืนวิธีการโรงงาน (อินเทอร์เฟซ) ซึ่งจะส่งคืนวัตถุคอนกรีต
4. คุณสามารถทดแทน Concrete Objects ใหม่สำหรับอินเทอร์เฟซและไคลเอนต์ (ผู้โทร) ไม่ควรรับรู้ถึงการใช้งานคอนกรีตทั้งหมด
5. ไคลเอนต์เข้าถึงอินเทอร์เฟซเท่านั้นและคุณสามารถซ่อนรายละเอียดการสร้างวัตถุในวิธีการของโรงงาน

ดูที่บทความวิกิพีเดียนี้และบทความ javarevisited

รูปแบบกลยุทธ์:

1. มันเป็นรูปแบบพฤติกรรม
2. มันขึ้นอยู่กับการมอบหมาย
3. มันเปลี่ยนความกล้าของวัตถุโดยการปรับเปลี่ยนพฤติกรรมวิธีการ
4. มันใช้เพื่อสลับระหว่างตระกูลของอัลกอริทึม
5. มันเปลี่ยนพฤติกรรมของวัตถุในเวลาทำงาน

ตัวอย่าง:

คุณสามารถกำหนดค่ากลยุทธ์ส่วนลดสำหรับรายการเฉพาะ (ตั๋ว AirFare หรือรายการ ShoppingCart) ในตัวอย่างนี้คุณจะเสนอส่วนลด 25% สำหรับรายการในช่วงเดือนกรกฎาคม - ธันวาคมและไม่มีส่วนลดสำหรับรายการระหว่าง Jaunary - มิถุนายน

กระทู้ที่เกี่ยวข้อง:

ตัวอย่างโลกแห่งความจริงของรูปแบบกลยุทธ์

รูปแบบการออกแบบ: โรงงานกับวิธีการของโรงงานเทียบกับบทคัดย่อจากโรงงาน

เพื่อขยายสิ่งที่ Oscar พูดและอ้างอิงถึงรหัสของเขา:

getCommand คือ Factory และคลาส UnixCommand, WindowsCommand และ OSXCommand เป็นกลยุทธ์

รูปแบบกลยุทธ์ในแง่ง่าย ๆ คือการสร้างพฤติกรรมที่คุณไม่ต้องกังวลกับการใช้คลาส ที่อื่น ๆ มีโรงงานคือการสร้างรันไทม์ของอินสแตนซ์คลาสที่เป็นรูปธรรมและขึ้นอยู่กับคุณที่จะใช้พฤติกรรม (วิธีการ) ใด ๆ ที่เปิดเผยโดยอินเตอร์เฟสที่ใช้งาน

คุณไม่สามารถเข้าใจความแตกต่างได้ง่ายๆโดยดูที่รหัสหรือการจัดหมวดหมู่ หากต้องการเข้าใจรูปแบบ GoF อย่างถูกต้องให้มองหาจุดประสงค์ของพวกเขา:

กลยุทธ์: "กำหนดตระกูลอัลกอริธึม, แค็ปซูลแต่ละอันและทำให้พวกมันใช้แทนกันได้กลยุทธ์ทำให้อัลกอริทึมนั้นแตกต่างจากลูกค้าที่ใช้มัน"

วิธีการจากโรงงาน: "กำหนดอินเทอร์เฟซสำหรับการสร้างวัตถุ แต่ให้คลาสย่อยตัดสินใจว่าคลาสใดจะสร้างอินสแตนซ์ Factory Method ให้คลาสเลื่อนการอินสแตนซ์ไปที่คลาสย่อย"

และนี่คือคำอธิบายอย่างละเอียดเกี่ยวกับความตั้งใจและความแตกต่างระหว่างสองรูปแบบ: ความแตกต่างระหว่างวิธีการของโรงงานและรูปแบบการออกแบบกลยุทธ์

ฉันอาจพูดนอกเรื่องกับออสการ์ในตัวอย่างของการใช้งานในโรงงานของเขานั้นค่อนข้างแน่นหนาและปิดสนิทไม่น่าแปลกใจที่คุณเลือกเป็นรูปแบบกลยุทธ์ การใช้งานจากโรงงานไม่ควรขึ้นอยู่กับจำนวนชั้นเรียนเฉพาะที่ถูกทำให้เป็นอินสแตนซ์ตัวอย่างเช่น:

public Command getCommand( int operatingSystem ) {        
   return commandTable.get(operatingSystem); 
}

...

public class WindowsCommand implements Command {
    ...
    static {
        CommandTable.getInstance().registerCommand(WIN_COMMAND_ID, new WindowsCommand());
    }

}

ฉันเดาว่าเกณฑ์ที่เหมาะสมที่สุดในการเลือกอย่างใดอย่างหนึ่งส่วนใหญ่เป็นคำศัพท์ที่คุณใช้ในการตั้งชื่อชั้นเรียนและวิธีการของคุณโดยคำนึงถึงเราทุกคนควรมีแนวโน้มที่จะตั้งโปรแกรมให้กับส่วนต่อประสานและไม่ใช่ชั้นเรียน รหัสใดจะรันบนรันไทม์ ที่กล่าวว่าเราสามารถบรรลุเป้าหมายโดยใช้ทั้งสองรูปแบบ

กลยุทธ์และโรงงานมีวัตถุประสงค์ที่แตกต่างกัน ในกลยุทธ์คุณได้กำหนดวิธีใช้รูปแบบนี้คุณสามารถแลกเปลี่ยนพฤติกรรม (อัลกอริทึม) การมาที่โรงงานมีความหลากหลายรอบตัว แต่รูปแบบดั้งเดิมจาก GO4 ระบุว่าโรงงานทิ้งการสร้างวัตถุไปยังระดับเด็ก ที่นี่กับโรงงานที่คุณกำลังเปลี่ยนอินสแตนซ์ที่สมบูรณ์ไม่ใช่พฤติกรรมที่คุณสนใจโดยสิ่งนี้คุณจะแทนที่ระบบที่สมบูรณ์ไม่ใช่อัลกอริทึม

รูปแบบจากโรงงานเป็นรูปแบบการสร้างสรรค์ซึ่งถูกสร้างขึ้นด้วยคุณสมบัติที่ระบุ (พฤติกรรม) ในขณะที่รันไทม์หลังจากการสร้างคุณไม่ได้เปลี่ยนคุณสมบัติ (พฤติกรรม) ดังนั้นหากคุณต้องการคุณสมบัติที่แตกต่างกัน (พฤติกรรม) คุณต้องลบวัตถุและสร้างวัตถุใหม่ที่มีคุณสมบัติที่จำเป็น (พฤติกรรม) ซึ่งไม่ได้เป็นความคิดที่ดี ในขณะที่ในกรณีของรูปแบบกลยุทธ์คุณสามารถเปลี่ยนคุณสมบัติ (พฤติกรรม) ในขณะใช้งาน