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

หากคุณมีคลาสที่สืบทอดมาจากคลาสที่แตกต่างกันสองคลาสนี่หมายความว่าคลาสย่อยของคุณทำสิ่งต่าง ๆ โดยอัตโนมัติ (อย่างน้อย) 2 อย่างสิ่งหนึ่งจากคลาสซุปเปอร์แต่ละอัน? ฉันเชื่อว่าไม่มีความแตกต่างหากคุณมีการสืบทอดหลายอินเตอร์เฟส แก้ไข: เพื่อความชัดเจนฉันเชื่อว่าหากคลาสย่อยหลายคลาสละเมิด SRP จากนั้นใช้หลายอินเทอร์เฟซ (ไม่ใช่ตัวทำเครื่องหมายหรืออินเทอร์เฟซพื้นฐาน (เช่นที่เปรียบเทียบได้)) ละเมิด SRP ด้วย

18 object-oriented  object-oriented-design  single-responsibility  multiple-inheritance 

ภาพนี้นำมาจากการใช้การออกแบบและรูปแบบที่ใช้โดเมนขับเคลื่อน: พร้อมตัวอย่างใน C # และ. NET นี่คือแผนภาพคลาสสำหรับรูปแบบสถานะที่ a SalesOrderสามารถมีสถานะต่างกันในช่วงเวลาของชีวิต อนุญาตให้ช่วงการเปลี่ยนภาพบางอย่างระหว่างรัฐที่แตกต่างกัน ตอนนี้OrderStateคลาสเป็นabstractคลาสและวิธีการทั้งหมดได้รับการสืบทอดไปยังคลาสย่อย หากเราพิจารณาคลาสย่อยCancelledซึ่งเป็นสถานะสุดท้ายที่ไม่อนุญาตให้มีการเปลี่ยนสถานะเป็นสถานะอื่นเราจะต้องoverrideใช้วิธีการทั้งหมดในคลาสนี้เพื่อโยนข้อยกเว้น ตอนนี้ไม่ได้เป็นการละเมิดหลักการทดแทนของ Liskov เนื่องจาก sublcass ไม่ควรเปลี่ยนพฤติกรรมของผู้ปกครองหรือไม่ การเปลี่ยนคลาสนามธรรมเป็นอินเตอร์เฟสแก้ไขสิ่งนี้หรือไม่? จะแก้ไขได้อย่างไร?

17 java  c#  design-patterns  object-oriented-design  liskov-substitution 

พิจารณานักออกแบบ UI สองคนที่ต้องการออกแบบการออกแบบที่“ ดึงดูดผู้ใช้” "การดึงดูดผู้ใช้" เป็นแนวคิดที่ไม่ได้มีวัตถุประสงค์และอยู่ในใจของนักออกแบบเท่านั้น ดังนั้นผู้ออกแบบสามารถยกตัวอย่างเช่นสีแดงในขณะที่นักออกแบบ B เลือกสีน้ำเงิน นักออกแบบ A สร้างเลย์เอาต์ที่แตกต่างอย่างสิ้นเชิงจากดีไซเนอร์ B และอื่น ๆ ฉันอ่านเกี่ยวกับ SRP (Single Responsibility Principle) และสิ่งที่ฉันเข้าใจคือการวิเคราะห์เชิงอัตวิสัยหรือการแยกความรับผิดชอบที่อาจแตกต่างจากนักออกแบบ OO ถึงผู้ออกแบบ OO คนอื่น ฉันถูกไหม? กล่าวอีกนัยหนึ่งเป็นไปได้หรือไม่ที่จะมีตัววิเคราะห์เชิงวัตถุสองตัวที่ยอดเยี่ยมและผู้ออกแบบที่มาพร้อมกับการออกแบบที่แตกต่างกันสองแบบสำหรับหนึ่งระบบโดยยึดตามหลักการ SRP

17 object-oriented  object-oriented-design  single-responsibility  ooda 

ฉันกำลังพยายามที่จะเข้าใจเบื้องหลังม่าน Javascript และชนิดของการติดอยู่ในการทำความเข้าใจการสร้างสร้างขึ้นในวัตถุโดยเฉพาะวัตถุและฟังก์ชั่นและความสัมพันธ์ระหว่างพวกเขา เมื่อฉันอ่านว่าวัตถุในตัวทั้งหมดเช่น Array, String ฯลฯ เป็นส่วนขยาย (สืบทอด) จาก Object ฉันคิดว่า Object เป็นวัตถุแรกที่สร้างขึ้นในวัตถุที่สร้างขึ้นและส่วนที่เหลือของวัตถุสืบทอดมาจากมัน แต่มันก็ไม่สมเหตุสมผลเมื่อคุณรู้ว่า Object สามารถสร้างได้โดยฟังก์ชั่นเท่านั้น แต่ฟังก์ชั่นนั้นก็ไม่ได้มี แต่วัตถุของ Function มันเริ่มที่จะฟังดูลำบากเช่นไก่และไก่ สิ่งที่สับสนอย่างยิ่งคือถ้าฉันconsole.log(Function.prototype)พิมพ์ฟังก์ชั่น แต่เมื่อฉันพิมพ์console.log(Object.prototype)มันจะพิมพ์วัตถุ ทำไมFunction.prototypeฟังก์ชั่นเมื่อมันถูกหมายถึงเป็นวัตถุ? นอกจากนี้ตามเอกสาร Mozilla ทุก javascript functionเป็นส่วนขยายของFunctionวัตถุ แต่เมื่อคุณconsole.log(Function.prototype.constructor)เป็นอีกฟังก์ชั่น ตอนนี้คุณจะใช้บางสิ่งเพื่อสร้างมันเองได้อย่างไร (Mind = blown) สิ่งสุดท้ายFunction.prototypeคือฟังก์ชั่น แต่ฉันสามารถเข้าถึงconstructorฟังก์ชั่นที่ใช้Function.prototype.constructorหมายความว่าFunction.prototypeเป็นฟังก์ชั่นที่ส่งกลับprototypeวัตถุ

16 javascript  object-oriented-design  functions  object 

ฉันกำลังทำงานในโครงการเดี่ยวขนาดใหญ่ขึ้นและตอนนี้และฉันมีหลายชั้นเรียนซึ่งฉันไม่เห็นเหตุผลที่จะสร้างตัวอย่างของ ตัวอย่างเช่นคลาสลูกเต๋าของฉันตอนนี้เก็บข้อมูลทั้งหมดของมันแบบสแตติกและวิธีการทั้งหมดของมันก็คงที่เช่นกัน Dice.roll()ผมไม่จำเป็นต้องเริ่มต้นมันเพราะเมื่อฉันต้องการที่จะม้วนลูกเต๋าและได้รับค่าใหม่ฉันเพียงแค่การใช้งาน ฉันมีหลายคลาสที่คล้ายกันซึ่งมีฟังก์ชั่นหลักเพียงอย่างเดียวเช่นนี้และฉันกำลังจะเริ่มทำงานกับคลาส "คอนโทรลเลอร์" ที่จะรับผิดชอบกิจกรรมทั้งหมด (เช่นเมื่อผู้เล่นเคลื่อนตัวและสิ่งที่เกิดขึ้นในปัจจุบัน) เป็น) และฉันพบว่าฉันสามารถทำตามแนวคิดเดียวกันสำหรับชั้นเรียนนี้ได้ ฉันไม่เคยวางแผนที่จะสร้างวัตถุหลายรายการสำหรับคลาสที่เฉพาะเจาะจงเหล่านี้ดังนั้นจึงเป็นความคิดที่ดีหรือไม่ที่จะทำให้พวกมันคงที่? ฉันสงสัยว่าสิ่งนี้ถือเป็น "การปฏิบัติที่ไม่ดี" เมื่อพูดถึงจาวา จากสิ่งที่ฉันได้เห็นชุมชนดูเหมือนจะแยกในหัวข้อนี้? ต่อไปฉันจะรักการอภิปรายเกี่ยวกับเรื่องนี้และการเชื่อมโยงไปยังแหล่งข้อมูลจะดีเช่นกัน!

16 java  design  design-patterns  object-oriented-design  static-access 

พื้นหลัง นี่คือปัญหาที่เกิดขึ้นจริงผมทำงานเกี่ยวกับ: ฉันต้องการวิธีที่จะเป็นตัวแทนของบัตรในเกมบัตรเวทมนตร์: กลุ่ม การ์ดส่วนใหญ่ในเกมเป็นการ์ดที่ดูธรรมดา แต่บางการ์ดก็แบ่งออกเป็นสองส่วนแต่ละการ์ดมีชื่อเป็นของตัวเอง ครึ่งหนึ่งของการ์ดสองส่วนเหล่านี้ถือว่าเป็นการ์ด ดังนั้นเพื่อความชัดเจนฉันจะใช้Cardเพื่ออ้างถึงสิ่งที่เป็นการ์ดปกติหรือครึ่งหนึ่งของการ์ดสองส่วน (ในคำอื่น ๆ บางสิ่งที่มีเพียงชื่อเดียว) ดังนั้นเราจึงมีฐานเป็นการ์ด วัตถุประสงค์ของวัตถุเหล่านี้เป็นเพียงการเก็บคุณสมบัติของการ์ดเท่านั้น พวกเขาไม่ได้ทำอะไรด้วยตนเอง interface Card { String name(); String text(); // etc } มีคลาสย่อยสองชั้นCardซึ่งฉันกำลังเรียกPartialCard(ครึ่งหนึ่งของการ์ดสองส่วน) และWholeCard(การ์ดปกติ) PartialCardมีสองวิธีเพิ่มเติม: และPartialCard otherPart()boolean isFirstPart() สภาผู้แทนราษฎร ถ้าฉันมีดาดฟ้ามันควรจะประกอบด้วยWholeCards ไม่ใช่Cards อย่างที่Cardควรจะเป็นPartialCardและนั่นก็ไม่สมเหตุสมผล ดังนั้นฉันต้องการวัตถุที่แสดงถึง "บัตรทางกายภาพ" นั่นคือสิ่งที่สามารถเป็นตัวแทนหนึ่งWholeCardหรือสองPartialCards ฉันไม่แน่นอนโทรประเภทนี้Representativeและจะมีวิธีการที่Card จะให้ข้อมูลที่เกือบจะไม่มีโดยตรงบนบัตร (s) มันหมายถึงมันเท่านั้นที่จะชี้ไปที่มัน / พวกเขา ตอนนี้คิดที่ยอดเยี่ยม / บ้า / ใบ้ของฉัน (คุณตัดสินใจ) เป็นที่สืบทอด …

16 java  object-oriented-design  hierarchy 

ฉันมีลำดับชั้นของชั้นเรียนที่แสดงถึงการควบคุม GUI บางสิ่งเช่นนี้ Control->ContainerControl->Form ฉันต้องใช้ชุดของ algoritms ที่ทำงานกับวัตถุที่ทำสิ่งต่าง ๆ และฉันคิดว่ารูปแบบของผู้เข้าชมจะเป็นวิธีที่สะอาดที่สุด ลองยกตัวอย่างเช่นอัลกอริทึมที่สร้าง Xml Representaion ของลำดับชั้นของวัตถุ ใช้วิธี 'คลาสสิค' ฉันจะทำสิ่งนี้: public abstract class Control { public virtual XmlElement ToXML(XmlDocument document) { XmlElement xml = document.CreateElement(this.GetType().Name); // Create element, fill it with attributes declared with control return xml; } } public abstract class ContainerControl : …

16 c#  design-patterns  object-oriented-design 

ฉันพยายามเรียนรู้ GRASP และฉันพบสิ่งนี้อธิบาย ( ที่หน้า 3 ) เกี่ยวกับการมีเพศสัมพันธ์ต่ำและฉันรู้สึกประหลาดใจมากเมื่อฉันพบสิ่งนี้: พิจารณาวิธีการaddTrackสำหรับAlbumชั้นเรียนสองวิธีที่เป็นไปได้คือ: addTrack( Track t ) และ addTrack( int no, String title, double duration ) วิธีใดลดข้อต่อ อย่างที่สองทำเนื่องจากคลาสที่ใช้คลาส Album ไม่จำเป็นต้องทราบคลาส Track โดยทั่วไปพารามิเตอร์สำหรับเมธอดควรใช้ประเภทฐาน (int, char ... ) และคลาสจากแพ็กเกจ java. * ฉันมักจะพูดพล่ามกับเรื่องนี้; ฉันเชื่อว่าaddTrack(Track t)ดีกว่าaddTrack(int no, String title, double duration)เนื่องจากเหตุผลหลายประการ: มันจะดีกว่าเสมอสำหรับวิธีการที่จะทำให้พารามิเตอร์น้อยลงที่สุดเท่าที่จะเป็นไปได้ (ตาม Clean Code ของลุงบ็อบไม่มีหรืออย่างใดอย่างหนึ่งที่ดีกว่า, 2 ในบางกรณีและ …

16 design  object-oriented-design  coupling  design-principles 

การสืบทอดส่วนต่อประสานด้านล่างนั้นผิดกฎหมายใน PHP แต่ฉันคิดว่ามันจะมีประโยชน์พอสมควรในชีวิตจริง มี antipattern จริงหรือมีปัญหาเกี่ยวกับการออกแบบเอกสารด้านล่าง PHP นั้นปกป้องฉันหรือไม่ <?php /** * Marker interface */ interface IConfig {} /** * An api sdk tool */ interface IApi { public __construct(IConfig $cfg); } /** * Api configuration specific to http */ interface IHttpConfig extends IConfig { public getSomeNiceHttpSpecificFeature(); } /** * Illegal, …

16 php  object-oriented-design  interfaces 

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

15 design  design-patterns  object-oriented-design  patterns-and-practices  strategy 

เมื่อเร็ว ๆ นี้ฉันเริ่มคลุมหัวของฉันรอบ ๆ OOP และตอนนี้ฉันมาถึงจุดที่ยิ่งฉันอ่านความแตกต่างระหว่างคลาสนามธรรมและอินเทอร์เฟซมากเท่าไหร่ฉันก็ยิ่งสับสนมากขึ้น จนถึงตอนนี้ไม่สามารถยกตัวอย่างได้ อินเทอร์เฟซเป็นพิมพ์เขียวโครงสร้างมากขึ้นหรือน้อยลงที่กำหนดโครงกระดูกและบทคัดย่อต่างกันโดยสามารถใช้โค้ดบางส่วนได้ ฉันต้องการเรียนรู้เพิ่มเติมเกี่ยวกับสิ่งเหล่านี้ผ่านสถานการณ์เฉพาะของฉัน นี่คือลิงค์ไปยังคำถามแรกของฉันหากคุณต้องการข้อมูลพื้นฐานเพิ่มเติมเล็กน้อย: โมเดลการออกแบบที่ดีสำหรับคลาสใหม่ของฉันคืออะไร นี่คือสองคลาสที่ฉันสร้าง: class Ad { $title; $description $price; function get_data($website){ } function validate_price(){ } } class calendar_event { $title; $description $start_date; function get_data($website){ //guts } function validate_dates(){ //guts } } ดังนั้นอย่างที่คุณเห็นคลาสเหล่านี้เกือบจะเหมือนกัน ไม่ได้แสดงที่นี่ แต่มีฟังก์ชั่นอื่น ๆlike get_zip(), save_to_database()ที่มีร่วมกันข้ามชั้นเรียนของฉัน ฉันยังได้เพิ่มคลาสรถยนต์และสัตว์เลี้ยงอื่น ๆ ซึ่งมีวิธีการทั่วไปและคุณสมบัติของหลักสูตรเฉพาะสำหรับคลาสเหล่านั้น (เช่นระยะทางน้ำหนักและอื่น …

15 object-oriented-design  interfaces  abstract-class 

ฉันกำลังคิดเกี่ยวกับสิ่งนั้นและฉันมีข้อสงสัย เมื่อฉันประกาศอินเทอร์เฟซตัวอย่างเช่น: public interface MyInterface { public void method1(); public void method2(); } วิธีการอินเตอร์เฟสเหล่านี้ถือเป็นนามธรรมหรือไม่ สิ่งที่ฉันหมายถึงคือแนวคิดของวิธีนามธรรมคือ: วิธีนามธรรมเป็นวิธีการที่ประกาศ แต่ไม่มีการใช้งาน ดังนั้นวิธีการเหล่านี้ถือว่าเป็นนามธรรมหรือไม่ พวกเขาไม่ใช่วิธีนามธรรมที่ "บริสุทธิ์" เนื่องจากฉันไม่ได้ใช้abstractคำ แต่แนวคิด แต่ดูเหมือนว่าพวกเขาเป็น คุณบอกอะไรฉันได้บ้าง ขอบคุณ

15 object-oriented-design  interfaces  abstract-class 

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

15 testing  tdd  anti-patterns  object-oriented-design  mocking 

ฉันได้ยินรูปแบบที่เก็บจำนวนมาก แต่ฉันไม่เข้าใจว่าที่เก็บควรทำอะไร เมื่อฉันพูดว่า "พื้นที่เก็บข้อมูลควรทำอะไรจริงๆ" ฉันกังวลเกี่ยวกับวิธีการที่ควรใช้เป็นหลัก ตัวอย่างเช่นที่เก็บควรให้วิธีการ CRUD หรือควรให้วิธีการที่แตกต่างกัน? ฉันหมายถึงที่เก็บควรมีตรรกะทางธุรกิจหรือควรประกอบด้วยตรรกะในการสื่อสารกับแหล่งข้อมูลและจัดการเอนทิตีที่จะบันทึกหรือโหลด? นอกจากนี้ฉันเคยได้ยินว่าที่เก็บเป็นหน่วยของการคงอยู่ของมวลรวม แต่นั่นเป็นอย่างไร ฉันล้มเหลวที่จะเข้าใจวิธีการทำงานในทางปฏิบัติ ฉันคิดว่าเราควรมีเพียงหนึ่งอินเตอร์เฟสIRepositoryที่มีเมธอด CRUD และสำหรับเอนทิตีใด ๆ การใช้งานจะมีตรรกะในการบันทึกและดึงข้อมูลประเภทนั้นจากแหล่งข้อมูล

15 design-patterns  object-oriented-design  repository 

ฉันเข้าใจเจตนาของหลักการแบบเปิด มันหมายถึงการลดความเสี่ยงของการทำลายบางสิ่งบางอย่างที่ใช้งานได้แล้วในขณะที่แก้ไขโดยบอกให้คุณพยายามขยายโดยไม่ต้องแก้ไข อย่างไรก็ตามฉันมีปัญหาในการทำความเข้าใจวิธีการใช้หลักการนี้ในทางปฏิบัติ เพื่อความเข้าใจของฉันมีสองวิธีในการใช้มัน ก่อนและหลังการเปลี่ยนแปลงที่เป็นไปได้: ก่อน: โปรแกรมไปยัง abstractions และ 'ทำนายอนาคต' มากที่สุดเท่าที่จะทำได้ ตัวอย่างเช่นวิธีการdrive(Car car)จะต้องเปลี่ยนหาก Motorcycleมีการเพิ่ม s ในระบบในอนาคตดังนั้นจึงอาจละเมิด OCP แต่วิธีdrive(MotorVehicle vehicle)นี้มีแนวโน้มที่จะไม่เปลี่ยนแปลงในอนาคตดังนั้นจึงเป็นไปตาม OCP อย่างไรก็ตามมันค่อนข้างยากที่จะทำนายอนาคตและรู้ล่วงหน้าว่าการเปลี่ยนแปลงใดที่จะเกิดขึ้นกับระบบ หลังจาก: เมื่อต้องการการเปลี่ยนแปลงให้ขยายคลาสแทนการแก้ไขเป็นรหัสปัจจุบัน แบบฝึก # 1 ไม่ยากที่จะเข้าใจ อย่างไรก็ตามมันเป็นข้อปฏิบัติที่ 2 ที่ฉันมีปัญหาในการทำความเข้าใจวิธีการสมัคร ยกตัวอย่างเช่น (ฉันเอามันจากวิดีโอบน YouTube): ขอบอกว่าเรามีวิธีการในระดับที่ยอมรับได้วัตถุ:CreditCard makePayment(CraditCard card)หนึ่งวันVoucherจะถูกเพิ่มเข้าไปในระบบ วิธีนี้ไม่รองรับพวกมันดังนั้นจึงต้องมีการแก้ไข เมื่อนำวิธีการนี้ไปใช้ในตอนแรกเราไม่สามารถคาดการณ์อนาคตและโปรแกรมในแง่นามธรรมได้มากขึ้น (เช่นmakePayment(Payment pay)ดังนั้นตอนนี้เราต้องเปลี่ยนรหัสที่มีอยู่ แบบฝึกหัดที่ 2 กล่าวว่าเราควรเพิ่มฟังก์ชันการทำงานโดยขยายแทนการปรับเปลี่ยน นั่นหมายความว่าอย่างไร? ฉันควรคลาสย่อยคลาสที่มีอยู่แทนที่เพียงแค่เปลี่ยนเป็นรหัสเดิมหรือไม่ ฉันควรทำเสื้อคลุมบางอย่างเพื่อหลีกเลี่ยงการเขียนรหัสใหม่หรือไม่? หรือหลักการไม่ได้อ้างถึง 'วิธีการแก้ไข / เพิ่มฟังก์ชันการทำงานที่ถูกต้อง' …

14 design  object-oriented  object-oriented-design  solid