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

คลาสควรรู้เกี่ยวกับคลาสย่อยหรือไม่? คลาสควรทำสิ่งที่เฉพาะเจาะจงสำหรับคลาสย่อยที่กำหนดเช่น? สัญชาตญาณของฉันบอกฉันว่ามันเป็นการออกแบบที่ไม่ดีดูเหมือนว่าจะมีรูปแบบต่อต้านบางอย่าง

24 object-oriented  object-oriented-design  class-design  class 

ฉันสงสัยว่าอะไรจะดีไปในแง่ของการออกแบบ OOP ที่ดีทำความสะอาดโค้ดมีความยืดหยุ่นและหลีกเลี่ยงการดมกลิ่นของรหัสในอนาคต สถานการณ์รูปภาพที่คุณมีวัตถุที่คล้ายกันจำนวนมากที่คุณต้องการแสดงเป็นคลาส คลาสเหล่านี้ไม่มีฟังก์ชั่นเฉพาะใด ๆ เพียงแค่คลาสข้อมูลและแตกต่างกันตามชื่อ (และบริบท) ตัวอย่าง: Class A { String name; string description; } Class B { String name; String count; String description; } Class C { String name; String count; String description; String imageUrl; } Class D { String name; String count; } Class E { …

24 object-oriented  inheritance  dry 

วิธีง่าย ๆ ในการรักษาการตั้งค่าของแอปพลิเคชัน Java จะถูกแสดงด้วยไฟล์ข้อความที่มีนามสกุล ".properties" ที่มีตัวระบุของแต่ละการตั้งค่าที่เกี่ยวข้องกับค่าเฉพาะ (ค่านี้อาจเป็นตัวเลขสตริงวันที่ ฯลฯ ) . C # ใช้วิธีการที่คล้ายกัน แต่ไฟล์ข้อความจะต้องมีชื่อว่า "App.config" ในทั้งสองกรณีในซอร์สโค้ดคุณต้องเริ่มต้นคลาสเฉพาะสำหรับการอ่านการตั้งค่า: คลาสนี้มีวิธีการส่งคืนค่า (เป็นสตริง) ที่เกี่ยวข้องกับตัวระบุการตั้งค่าที่ระบุ // Java example Properties config = new Properties(); config.load(...); String valueStr = config.getProperty("listening-port"); // ... // C# example NameValueCollection setting = ConfigurationManager.AppSettings; string valueStr = setting["listening-port"]; // ... ในทั้งสองกรณีเราควรแยกสตริงที่โหลดจากไฟล์การกำหนดค่าและกำหนดค่าที่แปลงให้กับวัตถุที่พิมพ์ที่เกี่ยวข้อง (ข้อผิดพลาดในการแยกวิเคราะห์อาจเกิดขึ้นในช่วงนี้) …

24 java  c#  design-patterns  object-oriented 

สมมติว่าฉันมีขั้นตอนที่ทำสิ่งต่าง ๆ : void doStuff(initalParams) { ... } ตอนนี้ฉันค้นพบแล้วว่า ขั้นตอนที่จะมีขนาดใหญ่ผมแบ่งมันออกเป็นขั้นตอนขนาดเล็กหลาย ๆ และเร็ว ๆ นี้ฉันตระหนักดีว่ามีชนิดของรัฐจะเป็นประโยชน์ในขณะที่ทำสิ่งเพื่อที่ฉันจะต้องผ่านพารามิเตอร์น้อยระหว่างขั้นตอนเล็ก ๆ ดังนั้นฉันแยกมันออกเป็นคลาสของตัวเอง: class StuffDoer { private someInternalState; public Start(initalParams) { ... } // some private helper procedures here ... } แล้วฉันจะเรียกมันว่า: new StuffDoer().Start(initialParams); หรือเช่นนี้ new StuffDoer(initialParams).Start(); และนี่คือสิ่งที่รู้สึกผิด เมื่อใช้. NET หรือ Java API ฉันไม่เคยโทรnew SomeApiClass().Start(...);ซึ่งทำให้ฉันสงสัยว่าฉันทำผิด แน่นอนว่าฉันสามารถทำให้คอนสตรัคเตอร์ของ StuffDoer …

24 design-patterns  object-oriented  language-agnostic 

Builder Patternตัวอย่างมากมายทำให้Builderคลาสภายในของวัตถุที่สร้างขึ้น ทำให้รู้สึกบางอย่างเพราะมันบ่งบอกถึงสิ่งที่Builderสร้าง อย่างไรก็ตามในภาษาที่พิมพ์แบบคงที่เรารู้ว่าสิ่งที่Builderสร้าง ในทางตรงกันข้ามถ้าBuilderเป็นระดับชั้นที่คุณควรจะรู้ว่าสิ่งที่ชั้นสร้างโดยไม่ได้มองภายในของBuilderBuilder นอกจากนี้การมีตัวสร้างเป็นคลาสภายในจะลดจำนวนของการนำเข้าเนื่องจากสามารถอ้างอิงโดยคลาสภายนอก - หากคุณสนใจสิ่งนั้น แล้วมีตัวอย่างการปฏิบัติที่Builderอยู่ในแพคเกจเดียวกัน StringBuilderแต่ไม่ได้เป็นระดับชั้นเช่น คุณรู้ว่าBuilder ควรสร้างStringเพราะมันมีชื่อดังนั้น ที่ถูกกล่าวว่าเหตุผลที่ดีเท่านั้นที่ฉันสามารถคิดในการสร้างBuilderชั้นในคือคุณรู้ว่าสิ่งที่ชั้น ' Builderคือโดยไม่ทราบชื่อของมันหรืออาศัยการประชุมการตั้งชื่อ ตัวอย่างเช่นถ้าStringBuilderเป็นชั้นในของStringฉันอาจจะรู้ว่ามันมีอยู่เร็วกว่าที่ฉันทำ (เก็งกำไร) มีเหตุผลอื่นที่จะทำให้Builderชั้นในหรือไม่เพียงแค่ลงไปที่การตั้งค่าและพิธีกรรม?

24 java  design-patterns  object-oriented 

ฉันมีเว็บแอพพลิเคชั่น ฉันไม่เชื่อว่าเทคโนโลยีเป็นสิ่งสำคัญ โครงสร้างเป็นแอปพลิเคชันระดับ N ซึ่งแสดงในภาพทางด้านซ้าย มี 3 ชั้น UI (รูปแบบ MVC), Business Logic Layer (BLL) และ Data Access Layer (DAL) ปัญหาที่ฉันมีคือ BLL ของฉันมีขนาดใหญ่มากเนื่องจากมีตรรกะและเส้นทางผ่านการเรียกแอปพลิเคชันกิจกรรม โฟลว์ทั่วไปผ่านแอ็พพลิเคชันอาจเป็น: มีเหตุการณ์เกิดขึ้นใน UI ข้ามไปที่เมธอดใน BLL ดำเนินการกับลอจิก (อาจอยู่ในหลายส่วนของ BLL) ในที่สุดถึง DAL กลับไปที่ BLL (ซึ่งเป็นไปได้ว่ามีตรรกะมากกว่า) จากนั้นส่งคืนค่าบางค่าไปยัง UI BLL ในตัวอย่างนี้ยุ่งมากและฉันคิดว่าจะแยกออก ฉันมีตรรกะและวัตถุที่รวมกันซึ่งฉันไม่ชอบ เวอร์ชั่นด้านขวาคือความพยายามของฉัน เหตุผลยังคงเป็นวิธีการประยุกต์ไหลระหว่าง UI และ DAL แต่มีแนวโน้มที่คุณสมบัติไม่ ... เพียงวิธีการ (ส่วนใหญ่ของการเรียนในชั้นนี้อาจเป็นไปได้ที่จะเป็นแบบคงที่ที่พวกเขาไม่จัดเก็บใด …

23 object-oriented  architecture 

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

23 c#  design-patterns  object-oriented  methods 

ตามตรรกะโดเมน DDD ไม่ควรปนเปื้อนด้วยความกังวลทางเทคนิคเช่นการทำให้เป็นอันดับการทำแผนที่วัตถุสัมพันธ์ ฯลฯ ดังนั้นคุณจะทำให้เป็นอันดับหรือแมปสถานะของมวลรวมได้โดยไม่เปิดเผยต่อสาธารณะผ่านผู้ได้รับและ setters อย่างไร ฉันได้เห็นตัวอย่างมากมายสำหรับการใช้งานของที่เก็บ แต่ในทางปฏิบัติทั้งหมดนั้นอาศัยการเข้าถึงสาธารณะบนเอนทิตีและวัตถุค่าสำหรับการทำแผนที่ เราสามารถใช้การสะท้อนเพื่อหลีกเลี่ยงการเข้าถึงสาธารณะ แต่ IMO วัตถุโดเมนเหล่านี้จะยังคงขึ้นอยู่กับข้อกังวลเกี่ยวกับการทำให้เป็นอนุกรม เช่นคุณไม่สามารถเปลี่ยนชื่อหรือลบฟิลด์ส่วนตัวโดยไม่ต้องปรับแต่งการกำหนดค่าอนุกรม / การแมป ดังนั้นคุณต้องพิจารณาการทำให้เป็นอันดับซึ่งคุณควรเน้นไปที่ตรรกะของโดเมนแทน ดังนั้นการประนีประนอมที่ดีที่สุดที่จะทำตามที่นี่คืออะไร? อยู่กับ accessors สาธารณะ แต่หลีกเลี่ยงการใช้สิ่งอื่นนอกจากรหัสการแมป หรือว่าฉันเพิ่งพลาดอะไรบางอย่างที่ชัดเจน? ฉันสนใจอย่างชัดเจนในการซีเรียลไลซ์สถานะของวัตถุโดเมน DDD (การรวมที่ประกอบด้วยเอนทิตีและวัตถุค่า) สิ่งนี้ไม่เกี่ยวกับการทำให้เป็นอนุกรมในสถานการณ์สคริปต์ทั่วไปหรือการแปลงรหัสที่บริการไร้สัญชาติทำงานบนวัตถุคอนเทนเนอร์ข้อมูลอย่างง่าย

23 object-oriented  domain-driven-design  orm  serialization 

เนื่องจากภาษาการเขียนโปรแกรมแบบไดนามิกค่อนข้างมากมีคุณสมบัติในการพิมพ์เป็ดและพวกเขายังสามารถเปิดและแก้ไขวิธีการเรียนหรืออินสแตนซ์ได้ตลอดเวลา (เช่นRubyและPython ) ดังนั้น ... คำถามที่ 1) ความต้องการห้องเรียนในภาษาแบบไดนามิกคืออะไร ทำไมภาษาจึงออกแบบวิธีการใช้คลาสเป็น“ เทมเพลต” บางชนิดแทนที่จะเป็นแบบต้นแบบและใช้แค่วัตถุ? จาวาสคริปต์ยังเป็นรุ่นต้นแบบ แต่CoffeeScript (เวอร์ชันปรับปรุงของจาวาสคริปต์) จะเลือกวิธีที่อิงกับคลาส และมันก็เหมือนกันสำหรับLua (รุ่นต้นแบบ) และMoonScript (ตามคลาส) นอกจากนี้ยังมีคลาสใน ES 6 ดังนั้น ... คำถามที่ 2) มีการแนะนำหรือไม่ว่าถ้าคุณพยายามปรับปรุงภาษาที่ใช้ต้นแบบเป็นต้นคุณควรเปลี่ยนเป็นแบบเรียนหรือไม่ ถ้าไม่ทำไมมันถูกออกแบบมาอย่างนั้น?

23 object-oriented  programming-languages  duck-typing  dynamic-languages 

สมมติว่าคุณมีสิ่งต่อไปนี้: +--------+ +------+ | Animal | | Food | +-+------+ +----+-+ ^ ^ | | | | +------+ +-------+ | Deer | | Grass | +------+ +-------+ DeerสืบทอดจากAnimalและสืบทอดจากGrassFood จนถึงตอนนี้ดีมาก AnimalวัตถุสามารถกินFoodวัตถุ ทีนี้ลองผสมกันหน่อย ช่วยเพิ่มซึ่งสืบทอดมาจากLionAnimal +--------+ +------+ | Animal | | Food | +-+-----++ +----+-+ ^ ^ ^ | | | | | …

23 object-oriented  object-oriented-design 

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

23 design  object-oriented  javascript  uml 

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

23 object-oriented 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันได้อ่านบทความโต้เถียงการสอน FP ให้กับนักศึกษาที่โพสต์โดย Robert Harper ผู้เป็นศาสตราจารย์ในมหาวิทยาลัยเชียงใหม่ เขาอ้างว่า CMU จะไม่สอนการเขียนโปรแกรมเชิงวัตถุอีกต่อไปในหลักสูตรเบื้องต้นเพราะมันไม่เหมาะสมสำหรับหลักสูตร CS สมัยใหม่ และเขาอ้างว่า: การเขียนโปรแกรมเชิงวัตถุจะถูกลบออกจากหลักสูตรการแนะนำเพราะมันเป็นทั้งแบบแยกส่วนและต่อต้านแบบขนานโดยธรรมชาติ เหตุใดจึงต้องพิจารณาว่า OOP เป็นแบบแยกส่วนและป้องกันแบบขนาน?

23 education  object-oriented  functional-programming  parallelism 

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

23 object-oriented  functional-programming  class 

ฉันไม่ใช่วิศวกรซอฟต์แวร์ ฉันเป็นนักเรียนปริญญาเอกในสาขาธรณีศาสตร์ เกือบสองปีที่แล้วฉันเริ่มเขียนโปรแกรมซอฟต์แวร์เชิงวิทยาศาสตร์ ฉันไม่เคยใช้การรวมอย่างต่อเนื่อง (CI) ส่วนใหญ่เป็นเพราะในตอนแรกฉันไม่รู้ว่ามันมีอยู่จริงและฉันเป็นคนเดียวที่ทำงานกับซอฟต์แวร์นี้ ในขณะนี้เนื่องจากฐานของซอฟต์แวร์กำลังเรียกใช้คนอื่นเริ่มสนใจและต้องการมีส่วนร่วมกับซอฟต์แวร์ แผนดังกล่าวคือบุคคลอื่น ๆ ในมหาวิทยาลัยอื่นกำลังนำส่วนเพิ่มเติมไปใช้กับซอฟต์แวร์หลัก (ฉันกลัวว่าพวกเขาสามารถแนะนำข้อบกพร่อง) นอกจากนี้ซอฟต์แวร์นั้นค่อนข้างซับซ้อนและยากที่จะทดสอบและฉันก็วางแผนที่จะทำงานต่อไป ด้วยเหตุผลสองประการนี้ฉันจึงคิดจะใช้ CI มากขึ้นเรื่อย ๆ เนื่องจากฉันไม่เคยมีการศึกษาวิศวกรซอฟต์แวร์และไม่มีใครรอบตัวฉันเคยได้ยินเกี่ยวกับ CI (เราเป็นนักวิทยาศาสตร์ไม่มีโปรแกรมเมอร์) ฉันพบว่ามันยากที่จะเริ่มต้นสำหรับโครงการของฉัน ฉันมีคำถามสองสามข้อที่ฉันต้องการคำแนะนำ: ก่อนอื่นคำอธิบายสั้น ๆ เกี่ยวกับการทำงานของซอฟต์แวร์: ซอฟต์แวร์ถูกควบคุมโดยไฟล์. xml ไฟล์เดียวที่มีการตั้งค่าที่จำเป็นทั้งหมด คุณเริ่มซอฟต์แวร์โดยเพียงแค่ส่งพา ธ ไปยังไฟล์. xml เป็นอาร์กิวเมนต์อินพุตและรันและสร้างไฟล์สองสามไฟล์ที่มีผลลัพธ์ การวิ่งครั้งเดียวสามารถใช้เวลา ~ 30 วินาที มันเป็นซอฟต์แวร์ทางวิทยาศาสตร์ ฟังก์ชั่นเกือบทั้งหมดมีพารามิเตอร์อินพุตหลายค่าซึ่งชนิดส่วนใหญ่เป็นคลาสที่ค่อนข้างซับซ้อน ฉันมีไฟล์. txt หลายไฟล์ที่มีแค็ตตาล็อกขนาดใหญ่ซึ่งใช้สร้างอินสแตนซ์ของคลาสเหล่านี้ ตอนนี้มาคำถามของฉัน: การทดสอบหน่วยการทดสอบบูรณาการการทดสอบแบบครบวงจร? : ซอฟต์แวร์ของฉันมีโค้ดประมาณ 30,000 บรรทัดพร้อมฟังก์ชั่นนับร้อยและ ~ 80 คลาส …

22 object-oriented  c++  testing  continuous-integration