คำถามติดแท็ก object-oriented-design

ฉันมีสามคลาสที่เป็นแบบวงกลมขึ้นอยู่กับซึ่งกันและกัน: TestExecuter ดำเนินการตามคำขอของ TestScenario และบันทึกไฟล์รายงานโดยใช้คลาส ReportGenerator ดังนั้น: TestExecuter ขึ้นอยู่กับ ReportGenerator เพื่อสร้างรายงาน ReportGenerator ขึ้นอยู่กับ TestScenario และพารามิเตอร์ที่กำหนดจาก TestExecuter TestScenario ขึ้นอยู่กับ TestExecuter ไม่สามารถหาวิธีที่จะลบการอ้างอิงเหล่านั้นได้ public class TestExecuter { ReportGenerator reportGenerator; public void getReportGenerator() { reportGenerator = ReportGenerator.getInstance(); reportGenerator.setParams(this.params); /* this.params several parameters from TestExecuter class example this.owner */ } public void setTestScenario (TestScenario ts) …

33 design  object-oriented-design  circular-dependency  dependency-analysis 

ฉันต้องเขียนผู้จัดการระบบการแจ้งเตือน นี่คือข้อกำหนดของฉัน: ฉันต้องสามารถส่งการแจ้งเตือนบนแพลตฟอร์มที่แตกต่างกันซึ่งอาจแตกต่างกันโดยสิ้นเชิง (สำหรับตัวอย่างฉันต้องสามารถส่ง SMS หรืออีเมลได้) บางครั้งการแจ้งเตือนอาจเหมือนกันสำหรับผู้รับทุกคนสำหรับแพลตฟอร์มที่กำหนด แต่บางครั้งอาจเป็นการแจ้งเตือนต่อผู้รับ (หรือหลายคน) ต่อแพลตฟอร์ม การแจ้งเตือนแต่ละครั้งสามารถมีส่วนของข้อมูลเฉพาะแพลตฟอร์มได้ (สำหรับตัวอย่าง MMS ที่มีเสียงหรือภาพ) ระบบจำเป็นต้องปรับขนาดได้ฉันต้องสามารถส่งการแจ้งเตือนจำนวนมากโดยไม่ต้องหยุดทำงานทั้งแอปพลิเคชันหรือเซิร์ฟเวอร์ มันเป็นกระบวนการสองขั้นตอนแรกที่ลูกค้าอาจพิมพ์ข้อความและเลือกแพลตฟอร์มที่จะส่งไปและควรสร้างการแจ้งเตือนเพื่อประมวลผลแบบเรียลไทม์ในภายหลัง จากนั้นระบบจะต้องส่งการแจ้งเตือนไปยังผู้ให้บริการแพลตฟอร์ม สำหรับตอนนี้ฉันจบลงด้วยบางอย่าง แต่ฉันไม่รู้ว่ามันจะปรับขนาดได้หรือถ้ามันเป็นการออกแบบที่ดี ฉันว่าวัตถุต่อไปนี้ (ในภาษาเทียม): Notificationวัตถุทั่วไป: class Notification { String $message; Payload $payload; Collection<Recipient> $recipients; } ปัญหาเกี่ยวกับวัตถุต่อไปนี้จะเกิดอะไรขึ้นถ้าฉันมีผู้รับ 1,000,000? แม้ว่าRecipientวัตถุนั้นจะเล็กมากมันก็จะใช้หน่วยความจำมากเกินไป ฉันสามารถสร้างการแจ้งเตือนได้หนึ่งรายการต่อผู้รับ แต่ผู้ให้บริการแพลตฟอร์มบางรายกำหนดให้ฉันส่งเป็นชุดซึ่งหมายความว่าฉันต้องกำหนดหนึ่งการแจ้งเตือนที่มีผู้รับหลายคน การแจ้งเตือนที่สร้างขึ้นแต่ละครั้งสามารถเก็บไว้ในที่เก็บข้อมูลถาวรเช่น DB หรือ Redis มันจะเป็นการดีหรือไม่ที่จะรวมกันในภายหลังเพื่อให้แน่ใจว่าสามารถปรับขนาดได้หรือไม่? ในขั้นตอนที่สองฉันต้องดำเนินการการแจ้งเตือนนี้ แต่ฉันจะแยกแยะการแจ้งเตือนกับผู้ให้บริการแพลตฟอร์มที่เหมาะสมได้อย่างไร ฉันควรใช้วัตถุเช่นMMSNotificationขยายabstract Notificationหรือไม่ หรือสิ่งที่ต้องการNotification.setType('MMS')? เพื่อให้สามารถประมวลผลการแจ้งเตือนจำนวนมากในเวลาเดียวกันฉันคิดว่าระบบคิวการส่งข้อความเช่น RabbitMQ อาจเป็นเครื่องมือที่เหมาะสม …

32 design  architecture  performance  object-oriented-design  scalability 

ฉันมีรหัสบางส่วนที่ฉันทำซ้ำแผนที่จนกว่าเงื่อนไขบางอย่างจะเป็นจริงและต่อมาก็ใช้เงื่อนไขนั้นเพื่อทำบางสิ่งเพิ่มเติม ตัวอย่าง: Map<BigInteger, List<String>> map = handler.getMap(); if(map != null && !map.isEmpty()) { for (Map.Entry<BigInteger, List<String>> entry : map.entrySet()) { fillUpList(); if(list.size() > limit) { limitFlag = true; break; } } } else { logger.info("\n>>>>> \n\t 6.1 NO entries to iterate over (for given FC and target) \n"); } if(!limitFlag) …

30 design-patterns  object-oriented  object-oriented-design  clean-code 

ฉันกำลังทำงานบนฐานรหัสที่มีหลายคลาสที่ใช้วิธีการเริ่มต้น ดูเหมือนว่าการก่อสร้างแบบสองเฟสสำหรับฉันซึ่งฉันถือว่าเป็นการปฏิบัติที่ไม่ดีอยู่เสมอ ฉันไม่สามารถบอกความแตกต่างระหว่างสิ่งนี้กับตัวสร้างได้ เมื่อใดจึงเหมาะสมที่จะใช้วิธีการเริ่มต้นแทนการสร้างวัตถุปกติ เมื่อใดฉันจึงควรใช้ตัวสร้าง แก้ไข: ฉันไม่คิดว่ามันเป็นสิ่งที่เกี่ยวข้อง แต่ภาษาการเขียนโปรแกรมคือ C # ซึ่งสามารถนำไปใช้กับ Java หรือ C ++ ได้อย่างเท่าเทียมกัน

30 object-oriented-design  construction  constructors 

ในหน้า 839 ของรุ่นที่สอง Steve McConnell กำลังพูดถึงวิธีการทั้งหมดที่โปรแกรมเมอร์สามารถ "พิชิตความซับซ้อน" ในโปรแกรมขนาดใหญ่ เคล็ดลับของเขาถึงจุดสูงสุดด้วยข้อความนี้: "การเขียนโปรแกรมเชิงวัตถุให้ระดับของนามธรรมที่ใช้กับอัลกอริธึมและข้อมูลในเวลาเดียวกันซึ่งเป็นนามธรรมชนิดหนึ่งที่การสลายตัวของฟังก์ชั่นเพียงอย่างเดียวไม่ได้ให้" เมื่อรวมกับข้อสรุปของเขาว่า "การลดความซับซ้อนนั้นเป็นกุญแจสำคัญที่สุดในการเป็นโปรแกรมเมอร์ที่มีประสิทธิภาพ" (หน้าเดียวกัน) สิ่งนี้ดูเหมือนจะเป็นความท้าทายอย่างมากสำหรับการเขียนโปรแกรมเชิงหน้าที่ การถกเถียงกันระหว่าง FP และ OO มักถูกนำเสนอโดย FP proponents เกี่ยวกับปัญหาของความซับซ้อนที่เกิดขึ้นโดยเฉพาะจากความท้าทายของการเกิดพร้อมกันหรือการขนาน แต่การทำงานพร้อมกันนั้นไม่ได้เป็นเพียงความซับซ้อนของโปรแกรมเมอร์ซอฟต์แวร์เท่านั้นที่จะต้องมีชัย บางทีการมุ่งเน้นไปที่การลดความซับซ้อนหนึ่งประเภทนั้นเพิ่มขึ้นอย่างมากในมิติอื่น ๆ เช่นในหลาย ๆ กรณีกำไรที่ได้ไม่คุ้มกับต้นทุน หากเราเปลี่ยนเงื่อนไขของการเปรียบเทียบระหว่าง FP และ OO จากประเด็นเฉพาะเช่นการเห็นพ้องด้วยหรือนำกลับมาใช้ใหม่เพื่อการจัดการความซับซ้อนระดับโลกการอภิปรายนั้นจะมีลักษณะอย่างไร แก้ไข ความแตกต่างที่ฉันต้องการเน้นคือ OO ดูเหมือนว่าจะห่อหุ้มและเป็นนามธรรมห่างจากความซับซ้อนของข้อมูลและอัลกอริทึมในขณะที่ฟังก์ชั่นการเขียนโปรแกรมฟังก์ชั่นดูเหมือนสนับสนุนให้รายละเอียดการดำเนินงานของโครงสร้างข้อมูล ดูตัวอย่างเช่น Stuart Halloway (ผู้เสนอชื่อ Clojure FP) ที่นี่บอกว่า "ข้อมูลจำเพาะของประเภทข้อมูล" เป็น "ผลลัพธ์เชิงลบของลักษณะ OO แบบใช้สำนวน" และนิยมวางแนวคิด …

30 object-oriented  functional-programming  object-oriented-design 

พื้นหลัง ฉันไม่ใช่แฟนตัวยงของสิ่งที่เป็นนามธรรม ฉันจะยอมรับว่าสามารถได้รับประโยชน์จากความสามารถในการปรับตัวความสะดวกในการพกพาและการใช้งานอินเทอร์เฟซอีกครั้ง ฯลฯ มีประโยชน์ที่แท้จริงอยู่ที่นั่นและฉันไม่ต้องการตั้งคำถามนั้น มี "ประโยชน์" ที่สำคัญอื่น ๆ ของสิ่งที่เป็นนามธรรมซึ่งคือการซ่อนตรรกะการใช้งานและรายละเอียดจากผู้ใช้สิ่งที่เป็นนามธรรมนี้ เหตุผลก็คือคุณไม่จำเป็นต้องรู้รายละเอียดและควรให้ความสำคัญกับตรรกะของตนเองในตอนนี้ ทำให้รู้สึกในทางทฤษฎี อย่างไรก็ตามเมื่อใดก็ตามที่ฉันดูแลแอพพลิเคชั่นขององค์กรขนาดใหญ่ฉันจำเป็นต้องทราบรายละเอียดเพิ่มเติมอยู่เสมอ มันกลายเป็นความยุ่งยากครั้งใหญ่ที่ขุดลึกลงไปในสิ่งที่เป็นนามธรรมในทุก ๆ รอบเพื่อที่จะได้รู้ว่าสิ่งใดที่ทำ คือต้องทำ "open declaration" ประมาณ 12 ครั้งก่อนที่จะค้นหาโพรซีเดอร์ที่เก็บไว้ที่ใช้ นี่ 'ซ่อนรายละเอียด' ความคิดดูเหมือนว่าจะได้รับในทาง ฉันต้องการอินเทอร์เฟซที่โปร่งใสมากขึ้นและเป็นนามธรรมน้อยกว่าเสมอ ฉันสามารถอ่านซอร์สโค้ดระดับสูงและรู้ว่ามันทำอะไร แต่ฉันจะไม่มีทางรู้ว่ามันจะทำอย่างไรเมื่อมันเป็นเช่นนั้นคือสิ่งที่ฉันต้องรู้ เกิดอะไรขึ้นที่นี่? ทุกระบบที่ฉันเคยทำงานออกแบบมาไม่ดี (จากมุมมองนี้อย่างน้อย) หรือไม่? ปรัชญาของฉัน เมื่อฉันพัฒนาซอฟต์แวร์ฉันรู้สึกว่าฉันพยายามทำตามปรัชญาที่ฉันรู้สึกว่าเกี่ยวข้องกับปรัชญาของ ArchLinux : Arch Linux ยังคงความซับซ้อนโดยธรรมชาติของระบบ GNU / Linux ในขณะที่ยังคงความเป็นระเบียบและโปร่งใส ผู้พัฒนาและผู้ใช้ Arch Linux เชื่อว่าการพยายามซ่อนความซับซ้อนของระบบจริง ๆ แล้วจะส่งผลให้เกิดระบบที่ซับซ้อนยิ่งขึ้นดังนั้นจึงควรหลีกเลี่ยง ดังนั้นฉันไม่เคยพยายามซ่อนความซับซ้อนของซอฟต์แวร์ไว้เบื้องหลังเลเยอร์สิ่งที่เป็นนามธรรม …

30 object-oriented-design  abstraction 

เพื่อนร่วมงานของฉันและฉันมีความเห็นต่างกันเกี่ยวกับความสัมพันธ์ระหว่างคลาสพื้นฐานและอินเทอร์เฟซ ฉันเชื่อว่าคลาสไม่ควรใช้อินเทอร์เฟซเว้นแต่ว่าคลาสนั้นสามารถใช้ได้เมื่อต้องการการใช้อินเทอร์เฟซ กล่าวอีกนัยหนึ่งฉันชอบที่จะเห็นรหัสเช่นนี้: interface IFooWorker { void Work(); } abstract class BaseWorker { ... base class behaviors ... public abstract void Work() { } protected string CleanData(string data) { ... } } class DbWorker : BaseWorker, IFooWorker { public void Work() { Repository.AddCleanData(base.CleanData(UI.GetDirtyData())); } } DbWorker คือสิ่งที่ได้รับอินเตอร์เฟส IFooWorker เนื่องจากเป็นการใช้งานอินเทอร์เฟซที่รวดเร็ว สมบูรณ์ตามสัญญา …

30 design-patterns  object-oriented  object-oriented-design  interfaces 

สมมติว่าฉันเริ่มพัฒนาเกมสวมบทบาทกับตัวละครที่โจมตีตัวละครอื่นและสิ่งต่าง ๆ ใช้ TDD ฉันสร้างกรณีทดสอบเพื่อทดสอบตรรกะภายในCharacter.receiveAttack(Int)วิธี บางสิ่งเช่นนี้ @Test fun healthIsReducedWhenCharacterIsAttacked() { val c = Character(100) //arg is the health c.receiveAttack(50) //arg is the suffered attack damage assertThat(c.health, is(50)); } บอกว่าผมมี 10 วิธีการทดสอบreceiveAttackวิธีการ ตอนนี้ผมเพิ่มวิธีการCharacter.attack(Character)(ที่โทรreceiveAttackวิธี) และหลังจากที่บางรอบ TDD ทดสอบนั้นผมตัดสินใจ: ควรจะเป็นCharacter.receiveAttack(Int)private จะเกิดอะไรขึ้นกับ 10 กรณีทดสอบก่อนหน้า? ฉันควรจะลบมันเหรอ? ฉันควรรักษาวิธีpublic(ฉันไม่คิดอย่างนั้น)? คำถามนี้ไม่ได้เกี่ยวกับวิธีการทดสอบวิธีการส่วนตัว แต่วิธีการจัดการกับพวกเขาหลังจากการออกแบบใหม่เมื่อใช้ TDD

29 object-oriented-design  tdd 

กฎหมายของ Demeterกล่าวต่อไปนี้: แต่ละหน่วยควรมีความรู้ที่ จำกัด เฉพาะเกี่ยวกับหน่วยอื่น ๆ : เฉพาะหน่วย "อย่างใกล้ชิด" ที่เกี่ยวข้องกับหน่วยปัจจุบัน แต่ละหน่วยควรคุยกับเพื่อนเท่านั้น อย่าคุยกับคนแปลกหน้า พูดคุยกับเพื่อนของคุณทันที C # 6.0 แนะนำผู้ประกอบการใหม่ที่เรียกว่าผู้ประกอบการ null เงื่อนไข IMHO ทำให้การเข้ารหัสง่ายขึ้นและปรับปรุงความสามารถในการอ่าน แต่มันยังทำให้ง่ายต่อการเขียนรหัสคู่มากขึ้นเนื่องจากง่ายต่อการเลื่อนดูฟิลด์คลาสและตรวจสอบค่าว่าง (เช่นvar x = A?.B?.C?.D?.E?.F?) ถูกต้องหรือไม่หากระบุว่าผู้ประกอบการรายใหม่นี้ขัดต่อกฎหมายของ Demeter

29 c#  design-patterns  object-oriented-design 

สมมติว่าเราต้องการให้มี "บัญชี" ที่เป็นนามธรรมในธนาคาร นี่คือวิธีหนึ่งโดยใช้functionวัตถุใน Python: def account(): """Return a dispatch dictionary representing a bank account. >>> a = account() >>> a['deposit'](100) 100 >>> a['withdraw'](90) 10 >>> a['withdraw'](90) 'Insufficient funds' >>> a['balance'] 10 """ def withdraw(amount): if amount > dispatch['balance']: return 'Insufficient funds' dispatch['balance'] -= amount return dispatch['balance'] def deposit(amount): dispatch['balance'] …

29 design  object-oriented  python  object-oriented-design  object 

ฉันจะบันทึกส่วนของข้อมูลสตริงในฐานข้อมูล ฉันมีการกำหนดค่าระดับโลกสองแบบ: การเข้ารหัส การอัด สิ่งเหล่านี้สามารถเปิดใช้งานหรือปิดการใช้งานโดยใช้การกำหนดค่าในลักษณะที่เปิดใช้งานเพียงอย่างเดียวเท่านั้นทั้งสองถูกเปิดใช้งานหรือทั้งสองอย่างถูกปิดใช้งาน การใช้งานปัจจุบันของฉันคือ: if (encryptionEnable && !compressEnable) { encrypt(data); } else if (!encryptionEnable && compressEnable) { compress(data); } else if (encryptionEnable && compressEnable) { encrypt(compress(data)); } else { data; } ฉันกำลังคิดเกี่ยวกับลวดลายมัณฑนากร มันเป็นตัวเลือกที่ถูกต้องหรืออาจเป็นทางเลือกที่ดีกว่า

28 design  design-patterns  object-oriented-design  refactoring 

มีบทความคลาสสิกชื่อตามเกณฑ์ที่จะใช้ในการย่อยสลายระบบเป็นโมดูลที่ฉันเพิ่งอ่านเป็นครั้งแรก มันสมเหตุสมผลดีสำหรับฉันและอาจเป็นหนึ่งในบทความที่ OOP อ้างอิง ข้อสรุปของมัน: เราพยายามสาธิตโดยตัวอย่างเหล่านี้ว่ามันไม่ถูกต้องเสมอไปที่จะเริ่มการสลายตัวของระบบเป็นโมดูลบนพื้นฐานของแผนผังลำดับงาน ... แต่ละโมดูลได้รับการออกแบบมาเพื่อซ่อนการตัดสินใจจากสิ่งอื่น ในความเห็นที่ไม่มีการศึกษาและไม่มีประสบการณ์ของฉันการเขียนโปรแกรมฟังก์ชั่นใช้คำแนะนำตรงข้ามแน่นอนของบทความนี้ ความเข้าใจของฉันคือการเขียนโปรแกรมการทำงานทำให้การไหลของข้อมูลเป็นสำนวน ข้อมูลถูกส่งผ่านจากฟังก์ชั่นหนึ่งไปยังอีกฟังก์ชั่นแต่ละฟังก์ชั่นจะรับรู้ข้อมูลอย่างใกล้ชิดและ"เปลี่ยน"ไปพร้อมกัน และฉันคิดว่าฉันเคยเห็น Rich Hickey คุยกันในที่ที่เขาพูดถึงว่าการซ่อนข้อมูลนั้นเกินจริงหรือไม่จำเป็นหรืออะไร แต่ฉันจำไม่ได้แน่นอน ก่อนอื่นฉันต้องการทราบว่าการประเมินของฉันถูกต้องหรือไม่ กระบวนทัศน์ของ FP และบทความนี้ขัดแย้งกับปรัชญาหรือไม่? สมมติว่าพวกเขาไม่เห็นด้วย FP จะ "ชดเชย" อย่างไรหากไม่มีการซ่อนข้อมูล บางทีพวกเขาอาจเสียสละการซ่อนข้อมูล แต่ได้รับ X, Y และ Z ฉันต้องการทราบเหตุผลว่าทำไม X, Y และ Z จึงถือว่าเป็นประโยชน์มากกว่าการซ่อนข้อมูล หรือสมมติว่าพวกเขาไม่เห็นด้วย FP อาจรู้สึกว่าการซ่อนข้อมูลไม่ดี ถ้าเป็นเช่นนั้นทำไมจึงคิดว่าการซ่อนข้อมูลไม่ดี สมมติว่าพวกเขาเห็นด้วยฉันต้องการทราบว่าการนำ FPs ไปปฏิบัติใช้ของการซ่อนข้อมูลคืออะไร เห็นได้ชัดใน OOP คุณสามารถมีprivateฟิลด์ที่ไม่มีใครนอกชั้นเรียนสามารถเข้าถึงได้ ไม่มีสิ่งใดที่เปรียบเทียบกับฉันใน FP ฉันรู้สึกว่ามีคำถามอื่น …

27 design  object-oriented  functional-programming  object-oriented-design 

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

27 object-oriented  object-oriented-design  solid  design-principles  liskov-substitution 

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

27 design  object-oriented-design  inheritance 

การเป็นนักวิเคราะห์และนักออกแบบที่ดีจะเป็นประโยชน์อย่างมากต่อผู้พัฒนา แต่มีอุปสรรคสำหรับเรื่องนี้อย่างแน่นอน ไม่ใช่ทุกคนที่สนใจ OOAD และไม่ใช่ทุกคนที่สนใจรู้เส้นทาง OOAD ที่ดีควรรู้ภาษา OO หลายภาษาหรือไม่ หรือเขา / เธอควรทำโครงการล้มเหลว เราจะเป็น OOAD ที่ดีได้อย่างไร?

26 design  object-oriented-design