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

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

12 design-patterns  object-oriented  object-oriented-design  solid 

ฉันไม่สามารถหาทางออกที่ดีกว่าสำหรับปัญหาของฉัน ฉันมีตัวควบคุมมุมมองที่นำเสนอรายการองค์ประกอบ องค์ประกอบเหล่านั้นเป็นแบบจำลองที่สามารถเป็นตัวอย่างของ B, C, D, ฯลฯ และสืบทอดจาก A. ดังนั้นในตัวควบคุมมุมมองแต่ละรายการควรไปที่หน้าจอที่แตกต่างกันของแอปพลิเคชันและส่งผ่านข้อมูลบางส่วนเมื่อผู้ใช้เลือกหนึ่งในนั้น . ทางเลือกสองทางที่อยู่ในใจของฉันคือ (กรุณาเพิกเฉยไวยากรณ์ไม่ใช่ภาษาที่เฉพาะเจาะจง) 1) สวิตช์ (ฉันรู้ว่า sucks) //inside the view controller void onClickItem(int index) { A a = items.get(index); switch(a.type) { case b: B b = (B)a; go to screen X; x.v1 = b.v1; // fill X with b data …

12 object-oriented  mvc  object-oriented-design  polymorphism  switch-statement 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา ในขณะที่สืบทอดคลาสใน C ++ ผู้ใช้สามารถระบุตัวระบุการเข้าถึงเช่น class Base { public int mem1; protected in mem2; }; class Derived1 : **private** Base { // mem1 will be private here. // mem2 will be private here. }; class Derived2 : **protected** Base { // mem1 will …

12 java  object-oriented  inheritance 

เมื่อเร็ว ๆ นี้มีการปฏิวัติต่อต้านซิงเกิลบ้าง แต่มีอะไรผิดปกติกับพวกเขาไหมถ้าพวกเขาไร้สัญชาติ? ฉันรู้ว่าการพูดคุยที่มากเกินไปและทั้งหมด ... สิ่งนี้ใช้ได้กับทุกสิ่งที่ไม่ใช่แค่ซิงเกิลตัน

12 design-patterns  object-oriented  singleton  immutability 

ฉันเริ่มเขียนโปรแกรมใน C ++ 11 ที่จะวิเคราะห์คอร์ดเครื่องชั่งและความสามัคคี ปัญหาที่ใหญ่ที่สุดที่ฉันมีในขั้นตอนการออกแบบของฉันคือโน้ต 'C' คือโน้ตประเภทของคอร์ด (Cmaj, Cmin, C7, ฯลฯ ) และประเภทของคีย์ (คีย์ของ Cmajor, Cminor) ปัญหาเดียวกันเกิดขึ้นกับช่วงเวลา (เล็กน้อย 3, ใหญ่ 3) ฉันใช้คลาสพื้นฐานโทเค็นซึ่งเป็นคลาสพื้นฐานสำหรับ 'สัญลักษณ์' ทั้งหมดในโปรแกรม ตัวอย่างเช่น: class Token { public: typedef shared_ptr<Token> pointer_type; Token() {} virtual ~Token() {} }; class Command : public Token { public: Command() {} pointer_type execute(); …

12 c++  object-oriented  polymorphism 

ฉันอ่านคำถามนี้และทำให้ฉันคิดถึงสิ่งที่เพิ่งเกิดขึ้นเมื่อไม่นานมานี้ ภาษาเชิงวัตถุ ฉันไม่แน่ใจว่าเมื่อแรกสร้าง แต่ทำไมมันใช้เวลานานก่อนที่พวกเขาจะกลายเป็นกระแสหลัก? C กลายเป็นที่นิยมอย่างมากมาย แต่ไม่ได้กลายเป็น c ++ เชิงวัตถุเป็นเวลาหลายปี (ทศวรรษ) ในภายหลัง ไม่มีภาษาหลักก่อนยุค 90 ที่เป็นเชิงวัตถุ ดูเหมือนว่า Object oriented นั้นจะใช้งานได้กับ Java และ C ++ ในเวลาเดียวกัน ตอนนี้คำถามของฉันทำไมใช้เวลานานขนาดนี้? เหตุใด C จึงไม่เข้าใจว่าเป็นภาษาเชิงวัตถุ การใช้ชุดย่อย C ++ ขนาดเล็กมากจะไม่ส่งผลกระทบต่อภาษาหลักอย่างมากดังนั้นทำไมความคิดนี้จึงไม่เป็นที่นิยมจนถึงยุค 90

12 programming-languages  object-oriented  history 

ฉันกำลังพัฒนาแอพที่จะใช้ในการเปิดและปิดวาล์วในสภาพแวดล้อมอุตสาหกรรมและกำลังคิดถึงบางสิ่งที่เรียบง่ายเช่นนี้: - public static void ValveController { public static void OpenValve(string valveName) { // Implementation to open the valve } public static void CloseValve(string valveName) { // Implementation to close the valve } } (การนำไปใช้นั้นจะเขียนข้อมูลสองสามไบต์ไปยังพอร์ตอนุกรมเพื่อควบคุมวาล์ว - "ที่อยู่" ซึ่งได้มาจากชื่อของวาล์วและ "1" หรือ "0" เพื่อเปิดหรือปิดวาล์ว) นักพัฒนาอีกคนถามว่าเราควรสร้างคลาสแยกต่างหากสำหรับแต่ละวาล์วทางกายภาพซึ่งมีอยู่เป็นสิบหรือไม่ ฉันยอมรับว่ามันจะดีกว่าที่จะเขียนโค้ดเหมือนPlasmaValve.Open()มากกว่าValveController.OpenValve("plasma")แต่นี่เป็น overkill หรือไม่ นอกจากนี้ฉันยังสงสัยว่าวิธีที่ดีที่สุดในการจัดการกับการออกแบบโดยคำนึงถึงความต้องการในอนาคตของสมมุติสองสามข้อ: - เราได้รับการร้องขอให้สนับสนุนวาล์วชนิดใหม่ที่ต้องการค่าต่าง ๆ …

12 design  design-patterns  object-oriented 

ฉันกำลังจะเริ่มโครงการจำลองสถานการณ์ / การสร้างแบบจำลอง ฉันรู้อยู่แล้วว่า OOP ใช้สำหรับโครงการประเภทนี้ อย่างไรก็ตามการเรียน Haskell ทำให้ฉันพิจารณาใช้กระบวนทัศน์ของ FP สำหรับการสร้างแบบจำลองระบบของส่วนประกอบ ให้ฉันทำอย่างละเอียด: สมมติว่าฉันมีองค์ประกอบประเภท A ซึ่งมีลักษณะเป็นชุดข้อมูล (พารามิเตอร์เช่นอุณหภูมิหรือความดัน PDE และเงื่อนไขขอบเขต ฯลฯ ) และส่วนประกอบประเภท B ซึ่งมีชุดข้อมูลแตกต่างกัน (แตกต่างกัน หรือพารามิเตอร์เดียวกัน PDE และเงื่อนไขขอบเขตที่แตกต่างกัน) สมมติว่าฟังก์ชั่น / วิธีการที่จะนำไปใช้กับแต่ละองค์ประกอบเหมือนกัน (ตัวอย่างวิธี Galerkin) สถานะที่ไม่แน่นอนของวัตถุจะถูกใช้สำหรับพารามิเตอร์ที่ไม่คงที่ ถ้าฉันจะใช้วิธีการของ OOP ฉันจะสร้างวัตถุสองชนิดที่จะห่อหุ้มข้อมูลของแต่ละประเภทวิธีการในการแก้ไข PDE (การสืบทอดจะใช้ที่นี่เพื่อนำโค้ดกลับมาใช้ใหม่) และวิธีแก้ปัญหากับ PDE ในทางตรงกันข้ามถ้าฉันจะใช้วิธีการ FP แต่ละองค์ประกอบจะถูกแบ่งออกเป็นส่วนข้อมูลและฟังก์ชั่นที่จะดำเนินการกับข้อมูลเพื่อให้ได้โซลูชั่นสำหรับ PDE พารามิเตอร์ที่ไม่คงที่จะถูกส่งผ่านเป็นฟังก์ชั่นของอย่างอื่น (เวลาเช่น) หรือแสดงโดยความไม่แน่นอนบางอย่าง (การเลียนแบบความไม่แน่นอน ฯลฯ ) …

12 c++  object-oriented  functional-programming  haskell  modeling 

ฉันกำลังคิดเกี่ยวกับส่วนต่อประสานกับชั้นเรียนที่ฉันกำลังเขียน คลาสนี้มีสไตล์สำหรับตัวละครตัวอย่างเช่นตัวละครเป็นตัวหนาตัวเอียงขีดเส้นใต้และอื่น ๆ ฉันได้ถกเถียงกับตัวเองเป็นเวลาสองวันว่าฉันควรใช้ getters / setters หรือชื่อโลจิคัลสำหรับวิธีที่เปลี่ยนค่าเป็น สไตล์เหล่านี้ ในขณะที่ฉันมักจะชอบชื่อแบบลอจิคัลมันหมายถึงการเขียนรหัสที่ไม่มีประสิทธิภาพและไม่เป็นแบบลอจิคัล ให้ฉันยกตัวอย่างให้คุณ ฉันมีชั้นเรียนCharacterStylesที่มีตัวแปรสมาชิกbold, italic, underline(และอื่น ๆ บางอย่าง แต่ฉันจะปล่อยให้พวกเขาออกไปให้มันง่าย) วิธีที่ง่ายที่สุดที่จะช่วยให้ส่วนอื่น ๆ ของโปรแกรมที่จะเข้าถึงตัวแปรเหล่านี้จะเขียนวิธีการ getter / หมาเพื่อให้คุณสามารถทำและstyles.setBold(true)styles.setItalic(false) แต่ฉันไม่ชอบสิ่งนี้ ไม่เพียงเพราะผู้คนจำนวนมากพูดว่าผู้ได้รับ / setters ทำลายการห่อหุ้ม (มันเลวร้ายจริงๆเหรอ?) แต่ส่วนใหญ่เป็นเพราะมันไม่สมเหตุสมผล ฉันคาดหวังที่จะจัดสไตล์ตัวละครผ่านวิธีการหนึ่งstyles.format("bold", true)หรือบางอย่างเช่นนั้น แต่ไม่ผ่านวิธีเหล่านี้ทั้งหมด แม้ว่าจะมีปัญหาหนึ่งข้อ เนื่องจากคุณไม่สามารถเข้าถึงตัวแปรสมาชิกวัตถุโดยเนื้อหาของสตริงใน C ++ ฉันจะต้องเขียนคอนเทนเนอร์ if-statement / switch ขนาดใหญ่สำหรับสไตล์ทั้งหมดหรือฉันจะต้องเก็บสไตล์ไว้ในอาเรย์แบบเชื่อมโยง ( แผนที่). ฉันไม่สามารถเข้าใจได้ว่าวิธีที่ดีที่สุดคืออะไร ช่วงเวลาหนึ่งฉันคิดว่าฉันควรเขียนตัวรับสัญญาณ / ผู้ตั้งค่าและช่วงเวลาถัดไปที่ฉันเอนตัวไปทางอื่น คำถามของฉันคือคุณจะทำอย่างไร แล้วทำไมคุณถึงทำอย่างนั้น?

12 c++  object-oriented  class-design 

ตัวอย่างเช่น: บอกฉันได้เรียนA, ,B Cฉันมีสองอินเตอร์เฟซที่ช่วยให้เรียกพวกเขาและIAnimal สืบทอดจาก และมีs ในขณะที่ไม่ได้ แต่มันก็เป็นIDogIDogIAnimalABIDogCIAnimal ส่วนที่สำคัญคือIDogไม่มีการใช้งานเพิ่มเติม มันใช้เพื่ออนุญาตAและBไม่Cผ่านการโต้แย้งเป็นวิธีการบางอย่าง นี่คือการปฏิบัติที่ไม่ดีหรือไม่?

12 object-oriented  interfaces 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน2 ปีที่ผ่านมา ฉันรู้ว่าฉันมีปัญหาในการสร้างการออกแบบ OOP ฉันใช้เวลาตัดสินใจหลายครั้งว่าคุณสมบัตินี้ตั้งค่าเป็นคลาส X อย่างถูกต้องหรือไม่ ตัวอย่างเช่นนี่คือโพสต์ที่มีสองสามวัน: /codereview/8041/how-to-improve-my-factory-design ฉันไม่มั่นใจในรหัสของฉัน ดังนั้นฉันต้องการที่จะปรับปรุงการออกแบบของฉันใช้เวลาน้อยลงในการสร้างมันขึ้นมา คุณเรียนรู้การสร้างงานออกแบบที่ดีได้อย่างไร หนังสือบางเล่มที่คุณสามารถแนะนำฉันได้ไหม

12 design  object-oriented 

สมมติว่าเรามีบริการที่เรียกกระบวนการทางธุรกิจ กระบวนการนี้จะเรียกใช้ในชั้นข้อมูลเพื่อสร้างวัตถุประเภท A ในฐานข้อมูล หลังจากนั้นเราต้องเรียกอีกครั้งในคลาสข้อมูลอีกชั้นหนึ่งเพื่อสร้างอินสแตนซ์ของประเภท B ในฐานข้อมูล เราจำเป็นต้องส่งข้อมูลบางอย่างเกี่ยวกับ A สำหรับคีย์ต่างประเทศ ในวิธีแรกเราสร้างวัตถุ (แก้ไขสถานะ) และคืนค่าเป็น ID (แบบสอบถาม) ในวิธีการเดียว ในวิธีที่สองเรามีสองวิธีหนึ่ง (createA) สำหรับการบันทึกและอื่น ๆ (getId) สำหรับแบบสอบถาม public void FirstMethod(Info info) { var id = firstRepository.createA(info); secondRepository.createB(id); } public void SecondMethod(Info info) { firstRepository.createA(info); var key = firstRepository.getID(info); secondRepository.createB(key); } จากความเข้าใจของฉันวิธีที่สองดังนี้แยกแบบสอบถามคำสั่งอย่างเต็มที่มากขึ้น แต่ฉันคิดว่ามันสิ้นเปลืองและตอบโต้ง่าย ๆ เพื่อสืบค้นฐานข้อมูลเพื่อให้ได้วัตถุที่เราเพิ่งสร้างขึ้น คุณจะกระทบยอด …

12 object-oriented 

เรากำลังพยายามย้ายข้อมูลจากเลเยอร์บริการที่ป่องของเราไปยังเลเยอร์โดเมนของเราโดยใช้วิธี DDD ขณะนี้เรามีตรรกะทางธุรกิจจำนวนมากในบริการของเราซึ่งกระจายไปทั่วสถานที่และไม่ได้รับประโยชน์จากการสืบทอด เรามีโดเมนระดับกลางซึ่งเป็นจุดสนใจของงานส่วนใหญ่ของเรา - การค้าขาย วัตถุการค้าจะรู้วิธีกำหนดราคาตัวเองวิธีประเมินความเสี่ยงตรวจสอบตัวเอง ฯลฯ จากนั้นเราสามารถแทนที่เงื่อนไขด้วย polymorphism เช่น SimpleTrade จะตั้งราคาเองทางเดียว แต่ ComplexTrade จะกำหนดราคาอีกทางหนึ่ง อย่างไรก็ตามเรามีความกังวลว่าสิ่งนี้จะขยายชั้นการค้า มันควรจะเป็นหน้าที่ของการประมวลผลของตัวเอง แต่ขนาดของชั้นเรียนจะเพิ่มขึ้นแบบทวีคูณเมื่อมีการเพิ่มคุณสมบัติมากขึ้น ดังนั้นเราจึงมีทางเลือก: ใส่ตรรกะการประมวลผลในระดับการค้า ตรรกะการประมวลผลตอนนี้เป็นแบบ polymorphic ตามประเภทของการค้า แต่ขณะนี้ชั้นการค้ามีความรับผิดชอบหลายอย่าง (การกำหนดราคาความเสี่ยง ฯลฯ ) และมีขนาดใหญ่ ใส่ตรรกะการประมวลผลลงในคลาสอื่นเช่น TradePricingService ไม่มี polymorphic อีกต่อไปกับแผนภูมิการสืบทอดการค้า แต่คลาสมีขนาดเล็กและง่ายต่อการทดสอบ อะไรคือแนวทางที่แนะนำ

12 object-oriented  design  domain-driven-design 

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

12 object-oriented 

ใน C ++ และภาษาอิทธิพลอื่น ๆ ที่มีการสร้างโครงสร้างที่เรียกว่า ( struct) classและอื่นที่เรียกว่า ทั้งสองมีความสามารถในการเก็บฟังก์ชั่นและตัวแปร ความแตกต่างบางประการคือ: คลาสจะได้รับหน่วยความจำในฮีปและstructได้รับหน่วยความจำในสแต็ก (หมายเหตุ: นี่คือสิ่งที่ผิดสำหรับ C ++ แต่อาจถูกต้องในสิ่งที่ OP เรียกว่า "ภาษาที่มีอิทธิพล") ตัวแปรคลาสเป็นค่าเริ่มต้นและstructเป็นแบบสาธารณะ คำถามของฉันคือ: ถูกstructยกเลิกอย่างใดสำหรับชั้นเรียน? ถ้าเป็นเช่นนั้นทำไม นอกเหนือจากความแตกต่างข้างต้น a structสามารถทำสิ่งเดียวกับที่ชั้นเรียนทำได้ เหตุใดจึงต้องละทิ้งมัน

12 c++  object-oriented