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

ฉันเป็นวิศวกรไฟฟ้าและฉันไม่รู้ว่าฉันทำอะไรอยู่ โปรดบันทึกผู้ดูแลรหัสของฉันในอนาคต เมื่อเร็ว ๆ นี้ฉันได้ทำงานกับโปรแกรมขนาดเล็กจำนวนมาก (ใน C #) ซึ่งฟังก์ชั่นการใช้งานเป็น "ขั้นตอน" ตามหลักเหตุผล ตัวอย่างเช่นหนึ่งในนั้นคือโปรแกรมที่รวบรวมข้อมูลจากฐานข้อมูลต่าง ๆ ใช้ข้อมูลนั้นเพื่อสร้างเรียงลำดับของหน้าสรุปพิมพ์และจากนั้นออก ตรรกะที่จำเป็นสำหรับทั้งหมดนั้นอยู่ที่ประมาณ 2,000 บรรทัด แน่นอนฉันไม่ต้องการสิ่งทั้งหมดในที่เดียวmain()แล้ว "ทำความสะอาด" กับ#regions เป็นนักพัฒนาก่อนหน้านี้ได้ทำ (ตัวสั่น) นี่คือบางสิ่งที่ฉันได้ลองไปแล้วโดยที่ไม่พึงพอใจมาก: สร้างยูทิลิตี้แบบคงที่สำหรับการใช้งานแต่ละบิตอย่างคร่าวๆเช่น DatabaseInfoGetter, SummaryPageGenerator และ PrintUtility ทำให้ฟังก์ชั่นหลักดูเหมือนว่า: int main() { var thisThing = DatabaseInfoGetter.GetThis(); var thatThing = DatabaseInfoGetter.GetThat(); var summary = SummaryPageGenerator.GeneratePage(thisThing, thatThing); PrintUtility.Print(summary); } สำหรับโปรแกรมหนึ่งฉันยังไปกับอินเตอร์เฟส int main() …

12 c#  object-oriented  code-quality  code-smell  procedural 

สมมติว่าเรากำลังแยกวิเคราะห์ การใช้งานอย่างหนึ่งอาจ: public sealed class Parser1 { public string Parse(string text) { ... } } หรือเราสามารถส่งข้อความไปยังผู้สร้างได้: public sealed class Parser2 { public Parser2(string text) { this.text = text; } public string Parse() { ... } } การใช้งานเป็นเรื่องง่ายในทั้งสองกรณี แต่การเปิดใช้งานพารามิเตอร์อินพุตเมื่อเปรียบเทียบกับกรณีอื่น ๆหมายความว่าParser1อย่างไร ฉันได้ส่งข้อความอะไรถึงเพื่อนนักเขียนโปรแกรมเมื่อพวกเขาดู API นอกจากนี้ยังมีข้อดี / ข้อเสียด้านเทคนิคในบางกรณีหรือไม่? คำถามอื่นเกิดขึ้นเมื่อฉันตระหนักว่าอินเทอร์เฟซจะค่อนข้างไม่มีความหมายในการใช้งานที่สอง: public interface IParser { string …

12 object-oriented  interfaces  methods  construction 

สมมติว่ามีPageคลาสซึ่งแสดงชุดคำสั่งสำหรับตัวแสดงผลหน้า และสมมติว่ามีRendererคลาสที่รู้วิธีแสดงหน้าบนหน้าจอ เป็นไปได้ที่จะจัดโครงสร้างโค้ดด้วยวิธีที่ต่างกันสองวิธี: /* * 1) Page Uses Renderer internally, * or receives it explicitly */ $page->renderMe(); $page->renderMe($renderer); /* * 2) Page is passed to Renderer */ $renderer->renderPage($page); ข้อดีและข้อเสียของแต่ละวิธีคืออะไร เมื่อใดจะดีกว่า คนอื่นจะดีกว่าเมื่อไหร่? พื้นหลัง เมื่อต้องการเพิ่มพื้นหลังเพิ่มเติมเล็กน้อย - ฉันค้นหาตัวเองโดยใช้วิธีการทั้งสองในรหัสเดียวกัน ฉันกำลังใช้ห้องสมุดของบุคคลที่ 3 รูปแบบไฟล์ PDF TCPDFที่เรียกว่า บางแห่งในรหัสของฉันฉันต้องมีสิ่งต่อไปนี้เพื่อให้การแสดงผล PDF ทำงานได้ $pdf = new TCPDF(); $html = "some …

11 object-oriented  php  language-agnostic 

ฉันเห็นประโยชน์ของการทำให้วัตถุในโปรแกรมของฉันไม่เปลี่ยนรูป เมื่อฉันคิดอย่างลึกซึ้งเกี่ยวกับการออกแบบที่ดีสำหรับแอปพลิเคชันของฉันฉันมักจะมาถึงวัตถุหลายอย่างของฉันที่ไม่เปลี่ยนรูป บ่อยครั้งที่มันมาถึงจุดที่ฉันต้องการให้วัตถุทั้งหมดของฉันไม่เปลี่ยนรูป คำถามนี้เกี่ยวกับความคิดเดียวกัน แต่ไม่มีคำตอบแนะนำว่าอะไรคือวิธีที่ดีในการเปลี่ยนรูปแบบไม่ได้และเมื่อใดจะใช้งานจริง มีรูปแบบการออกแบบที่เปลี่ยนแปลงไม่ได้บ้างไหม? แนวคิดทั่วไปดูเหมือนจะ "ทำให้วัตถุไม่เปลี่ยนรูปเว้นแต่คุณต้องการเปลี่ยนอย่างแน่นอน" ซึ่งไม่มีประโยชน์ในทางปฏิบัติ ประสบการณ์ของฉันคือการไม่เปลี่ยนรูปไดรฟ์รหัสของฉันมากขึ้นในกระบวนทัศน์การทำงานและความก้าวหน้านี้เกิดขึ้นเสมอ: ฉันเริ่มต้องการโครงสร้างข้อมูลแบบถาวร (ในแง่การใช้งาน) เช่นรายการแผนที่เป็นต้น มันไม่สะดวกอย่างยิ่งที่จะทำงานกับการอ้างอิงข้าม (เช่นโหนดต้นไม้ที่อ้างถึงลูกของมันในขณะที่เด็กที่อ้างอิงถึงพ่อแม่ของพวกเขา) ซึ่งทำให้ฉันไม่ได้ใช้การอ้างอิงไขว้เลยซึ่งทำให้โครงสร้างข้อมูลและรหัสของฉันทำงานได้อีก การรับมรดกหยุดที่จะทำให้ความรู้สึกใด ๆ และฉันเริ่มที่จะใช้องค์ประกอบแทน แนวคิดพื้นฐานทั้งหมดของ OOP เช่นการห่อหุ้มเริ่มที่จะกระจุยและวัตถุของฉันเริ่มดูเหมือนฟังก์ชั่น ณ จุดนี้ฉันแทบจะไม่ใช้อะไรเลยจากกระบวนทัศน์ของ OOP อีกต่อไปและสามารถเปลี่ยนเป็นภาษาที่ใช้งานได้อย่างหมดจด ดังนั้นคำถามของฉัน: มีวิธีการที่สอดคล้องกับการออกแบบ OOP ที่ไม่เปลี่ยนรูปแบบที่ดีหรือเป็นกรณีที่เมื่อคุณใช้ความคิดที่ไม่เปลี่ยนรูปแบบให้ได้เต็มศักยภาพคุณมักจะจบลงด้วยการเขียนโปรแกรมในภาษาที่ใช้งานได้ มีแนวทางที่ดีหรือไม่ในการตัดสินใจว่าคลาสใดควรไม่เปลี่ยนรูปแบบและควรจะอยู่ในรูปแบบใดเพื่อให้แน่ใจว่า OOP ไม่แตกสลาย? เพื่อความสะดวกฉันจะยกตัวอย่าง มาChessBoardเป็นคอลเล็กชั่นหมากรุกที่ไม่เปลี่ยนรูปแบบกันเถอะ(ขยายคลาสนามธรรม)Piece) จากมุมมองของ OOP ชิ้นส่วนมีหน้าที่สร้างการเคลื่อนไหวที่ถูกต้องจากตำแหน่งบนกระดาน แต่เพื่อสร้างการเคลื่อนไหวชิ้นส่วนจำเป็นต้องมีการอ้างอิงถึงคณะกรรมการในขณะที่คณะกรรมการจะต้องมีการอ้างอิงถึงชิ้นส่วนของมัน มีเทคนิคบางอย่างในการสร้างการอ้างอิงโยงที่ไม่เปลี่ยนรูปแบบเหล่านี้ขึ้นอยู่กับภาษา OOP ของคุณ แต่พวกเขามีความเจ็บปวดในการจัดการดีกว่าไม่มีชิ้นส่วนที่จะอ้างอิงบอร์ดของมัน แต่ชิ้นส่วนนั้นไม่สามารถสร้างการเคลื่อนไหวได้เนื่องจากมันไม่ทราบสถานะของบอร์ด จากนั้นชิ้นส่วนจะกลายเป็นเพียงโครงสร้างข้อมูลที่เก็บประเภทชิ้นส่วนและตำแหน่งของชิ้นงาน จากนั้นคุณสามารถใช้ฟังก์ชัน polymorphic เพื่อสร้างการเคลื่อนไหวสำหรับชิ้นส่วนทุกประเภท สิ่งนี้สามารถทำได้อย่างสมบูรณ์แบบในการเขียนโปรแกรมใช้งานได้ แต่แทบจะเป็นไปไม่ได้ใน …

11 object-oriented  functional-programming  immutability 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน2 ปีที่ผ่านมา การอ่านบทความที่เหยียดหยามเกี่ยวกับข้อเสียของ OOP เพื่อสนับสนุนกระบวนทัศน์อื่น ๆ ที่ฉันพบเจอตัวอย่างที่ฉันไม่สามารถหาข้อผิดพลาดได้มากเกินไป ฉันต้องการที่จะเปิดให้มีการโต้แย้งของผู้เขียนและแม้ว่าฉันสามารถเข้าใจประเด็นทางทฤษฎีของพวกเขาตัวอย่างหนึ่งโดยเฉพาะอย่างยิ่งฉันมีเวลายากที่จะลองจินตนาการว่ามันจะนำมาใช้ที่ดีขึ้นในการพูดภาษา FP จาก: http://www.smashcompany.com/technology/object-oriented-programming-is-an- ราคา-disaster-which-must-end // Consider the case where “SimpleProductManager” is a child of // “ProductManager”: public class SimpleProductManager implements ProductManager { private List products; public List getProducts() { return products; } public void increasePrice(int percentage) { …

11 object-oriented  functional-programming 

ฉันได้อ่านว่าเมื่อโปรแกรมของคุณจำเป็นต้องรู้ว่าคลาสคืออะไรวัตถุมักจะบ่งบอกถึงข้อบกพร่องในการออกแบบดังนั้นฉันจึงต้องการที่จะรู้ว่าอะไรคือวิธีปฏิบัติที่ดีในการจัดการกับสิ่งนี้ ฉันกำลังใช้รูปร่างคลาสที่มีคลาสย่อยต่าง ๆ ซึ่งสืบทอดมาจากมันเช่นวงกลมโพลีกอนหรือสี่เหลี่ยมผืนผ้าและฉันได้อัลกอริธึมที่แตกต่างกันเพื่อทราบว่าวงกลมชนกับรูปหลายเหลี่ยมหรือสี่เหลี่ยมผืนผ้า จากนั้นสมมติว่าเรามีสองอินสแตนซ์ของรูปร่างและต้องการทราบว่าหนึ่งชนกันในวิธีที่ฉันจะอนุมานประเภท subclass เป็นวัตถุที่ฉันกำลังชนกันเพื่อที่จะรู้ว่าอัลกอริทึมที่ฉันควรจะเรียก แต่นี่คือ การออกแบบหรือการปฏิบัติที่ไม่ดี? นี่คือวิธีที่ฉันแก้ไขมัน abstract class Shape { ShapeType getType(); bool collide(Shape other); } class Circle : Shape { getType() { return Type.Circle; } bool collide(Shape other) { if(other.getType() == Type.Rect) { collideCircleRect(this, (Rect) other); } else if(other.getType() == Type.Polygon) { collideCirclePolygon(this, (Polygon) other); …

11 design  object-oriented  class 

ฉันได้รับรหัส Java เพื่อดูซึ่งจำลองการแข่งรถซึ่งรวมถึงการใช้เครื่องรัฐขั้นพื้นฐาน นี่ไม่ใช่เครื่องคำนวณทางวิทยาศาสตร์คอมพิวเตอร์แบบดั้งเดิม แต่เป็นเพียงวัตถุที่มีหลายสถานะและสามารถสลับระหว่างสถานะต่าง ๆ ตามชุดการคำนวณ เพื่ออธิบายเพียงแค่ปัญหาฉันมีคลาสรถยนต์พร้อมคลาส enum ซ้อนกันซึ่งกำหนดค่าคงที่สำหรับสถานะของรถยนต์ (เช่น OFF, IDLE, DRIVE, REVERSE และอื่น ๆ ) ภายในคลาสรถยนต์เดียวกันนี้ฉันมีฟังก์ชั่นการอัปเดตซึ่งโดยทั่วไปประกอบด้วยคำสั่งสวิตช์ขนาดใหญ่ซึ่งเปลี่ยนสถานะปัจจุบันของรถยนต์ทำการคำนวณบางอย่างและเปลี่ยนสถานะรถยนต์ เท่าที่ฉันเห็นรัฐ Cars ใช้ในชั้นเรียนของตัวเองเท่านั้น คำถามของฉันคือนี่เป็นวิธีที่ดีที่สุดในการจัดการกับการใช้งานกลไกสถานะตามธรรมชาติที่อธิบายไว้ข้างต้นหรือไม่? มันฟังดูเหมือนโซลูชันที่ชัดเจนที่สุด แต่ก่อนหน้านี้ฉันเคยได้ยินมาเสมอว่า ปัญหาหลักที่ฉันเห็นที่นี่คือคำสั่ง switch อาจมีขนาดใหญ่มากเมื่อเราเพิ่มสถานะเพิ่มเติม (ถ้าจำเป็น) และรหัสอาจไม่สะดวกและยากต่อการบำรุงรักษา อะไรจะเป็นทางออกที่ดีกว่าสำหรับปัญหานี้?

11 design  design-patterns  object-oriented  switch-statement 

ฉันกำลังพยายามสร้างโปรแกรมสำหรับจัดการพนักงาน อย่างไรก็ตามฉันไม่สามารถหาวิธีออกแบบEmployeeชั้นเรียนได้ เป้าหมายของฉันคือการสามารถสร้างและจัดการข้อมูลพนักงานในฐานข้อมูลโดยใช้Employeeวัตถุ การใช้งานขั้นพื้นฐานที่ฉันคิดว่าเป็นเรื่องง่าย ๆ นี้: class Employee { // Employee data (let's say, dozens of properties). Employee() {} Create() {} Update() {} Delete() {} } ด้วยการใช้งานนี้ฉันพบปัญหาหลายประการ IDของพนักงานจะได้รับจากฐานข้อมูลดังนั้นหากผมใช้วัตถุสำหรับการอธิบายเป็นพนักงานใหม่จะไม่มีIDการจัดเก็บเลยในขณะที่วัตถุที่เป็นตัวแทนของพนักงานที่มีอยู่จะIDมี ดังนั้นฉันจึงมีคุณสมบัติที่บางครั้งอธิบายวัตถุและบางครั้งก็ไม่ (ซึ่งอาจบ่งบอกว่าเราละเมิดSRPเนื่องจากเราใช้คลาสเดียวกันสำหรับตัวแทนพนักงานใหม่และพนักงานปัจจุบัน ... ) Createวิธีการที่ควรจะสร้างการทำงานของพนักงานในฐานข้อมูลได้ในขณะที่UpdateและDeleteควรจะดำเนินการกับพนักงานที่มีอยู่ (อีกครั้งSRP ... ) วิธีการ 'สร้าง' ควรมีพารามิเตอร์ใด มีพารามิเตอร์หลายสิบสำหรับข้อมูลพนักงานทั้งหมดหรืออาจเป็นEmployeeวัตถุ? ชั้นควรจะไม่เปลี่ยนรูป? จะUpdateทำงานอย่างไร จะใช้คุณสมบัติและอัปเดตฐานข้อมูลหรือไม่ หรืออาจจะใช้วัตถุสองชิ้น - อันเก่าและอันใหม่และอัพเดทฐานข้อมูลด้วยความแตกต่างระหว่างพวกมัน (ฉันคิดว่าคำตอบเกี่ยวข้องกับคำตอบเกี่ยวกับความไม่แน่นอนของชั้นเรียน) อะไรคือความรับผิดชอบของผู้สร้าง? สิ่งที่จะเป็นพารามิเตอร์ที่ใช้? มันจะดึงข้อมูลพนักงานจากฐานข้อมูลโดยใช้idพารามิเตอร์และเติมคุณสมบัติหรือไม่ …

11 object-oriented  class-design  class 

บางครั้งผู้ใช้เริ่มการดำเนินการด้านเทคนิคเพิ่มเติมซึ่งใช้เวลาสักครู่ในการดำเนินการ ในกรณีเหล่านี้มักจะแสดงแถบความคืบหน้าพร้อมกับข้อมูลเกี่ยวกับงานที่กำลังดำเนินการอยู่ในขณะนี้ เพื่อหลีกเลี่ยงการมีเพศสัมพันธ์อย่างใกล้ชิดกับ UI และเลเยอร์ตรรกะมันเป็นการดีที่สุดที่จะเกิดการสื่อสารผ่านพร็อกซีบางประเภท นั่นคือแบ็คเอนด์ไม่ควรจัดการองค์ประกอบ UI ของตัวเองหรือแม้กระทั่งโต้ตอบกับเลเยอร์ตัวกลางโดยตรง เห็นได้ชัดว่าจะต้องมีการโทรกลับบางแห่งเพื่อให้งานนี้ ฉันได้นำไปใช้โดยทั่วไปด้วยหนึ่งในสองวิธี: ส่งผ่านวัตถุที่ไม่แน่นอนไปยังส่วนหลังและให้ส่วนหลังเปลี่ยนแปลงอยู่ระหว่างดำเนินการ วัตถุแจ้ง Front-end เมื่อมีการเปลี่ยนแปลงเกิดขึ้น ผ่านฟังก์ชั่นโทรกลับของแบบฟอร์มvoid f(ProgressObject)หรือProgressObject -> unitว่าส่วนหลังเรียกใช้ ในกรณีนี้ back-end สร้างProgressObjectและมันแฝงอย่างสมบูรณ์ มันจะต้องสร้างวัตถุใหม่ทุกครั้งที่ต้องการรายงานความคืบหน้าฉันถือว่า ข้อเสียและข้อดีของวิธีการเหล่านี้คืออะไร? มีวิธีใช้ที่ดีที่สุดตามที่ตกลงกันไว้หรือไม่? มีสถานการณ์ที่แตกต่างกันสำหรับการใช้งานของพวกเขา? มีเทคนิคที่แตกต่างอย่างสิ้นเชิงจากการรายงานความก้าวหน้าที่ฉันมองข้ามไปหรือไม่?

11 design  object-oriented  gui 

ฉันพยายามทำตามหลักการ DRY ในการเขียนโปรแกรมของฉันอย่างหนักที่สุดเท่าที่จะทำได้ เมื่อไม่นานมานี้ฉันได้เรียนรู้รูปแบบการออกแบบใน OOP แล้วและฉันก็ทำซ้ำตัวเองค่อนข้างมาก ฉันสร้างรูปแบบ Repository พร้อมกับรูปแบบ Factory และ Gateway เพื่อจัดการกับความคงทนของฉัน ฉันใช้ฐานข้อมูลในแอปพลิเคชันของฉัน แต่ไม่ควรทำเช่นนี้เพราะฉันควรจะสามารถสลับเกตเวย์และเปลี่ยนไปใช้ความพยายามชนิดอื่นได้หากฉันต้องการ ปัญหาที่ฉันสร้างเพื่อตัวเองคือฉันสร้างวัตถุเดียวกันสำหรับจำนวนตารางที่ฉันมี commentsตัวอย่างเหล่านี้จะเป็นวัตถุที่ฉันต้องการที่จะจัดการกับตาราง class Comment extends Model { protected $id; protected $author; protected $text; protected $date; } class CommentFactory implements iFactory { public function createFrom(array $data) { return new Comment($data); } } class CommentGateway implements iGateway …

11 design-patterns  object-oriented  php 

รับคลาส Python ซึ่งจะถูกสร้างอินสแตนซ์เพียงครั้งเดียวคือจะมีเพียงวัตถุเดียวของคลาส ฉันสงสัยในกรณีที่เหมาะสมที่จะสร้างอินสแตนซ์ของคลาสเดียวแทนที่จะทำงานโดยตรงกับคลาสแทน มีคำถามที่คล้ายกันแต่มีจุดเน้นที่แตกต่าง: มันเกี่ยวกับการจัดกลุ่มตัวแปรส่วนกลางและฟังก์ชันในคลาสและ มันไม่ได้เป็นงูหลามที่เฉพาะเจาะจง หลังหมายถึงมันไม่ได้พิจารณาความจริงที่ว่าคลาส (ใน Python) เป็นวัตถุด้วย UPDATE: ใน Python ฉันสามารถทำสิ่งต่อไปนี้กับทั้งคลาสและวัตถุ: class A(object): pass A.some_state_var = True # Then later A.some_state_var = False my_a = A() my_a.some_state_var = True # Then later my_a.some_state_var = False ดังนั้นฉันไม่เห็นวิธีการเลือกระหว่างคลาสและอินสแตนซ์ของคลาสนั้นเกี่ยวกับสถานะ (ใน Python) ฉันสามารถรักษาสถานะด้วยสองอย่างใดอย่างหนึ่ง นอกจากนี้แรงจูงใจในการสร้างคลาส / คลาสอินสแตนซ์ของฉันไม่ได้เกี่ยวกับการบังคับใช้ข้อกำหนดแบบซิงเกิล นอกจากนี้ยังไม่มากนักเกี่ยวกับการสร้างประเภทใหม่ แรงจูงใจคือการจัดกลุ่มรหัสและข้อมูลที่เกี่ยวข้องและมีส่วนต่อประสานกับมัน นี่คือเหตุผลที่ฉันเริ่มต้นแบบเป็นคลาสในแผนภาพคลาส เมื่อพูดถึงการนำไปใช้ฉันเริ่มสงสัยว่าจะยกตัวอย่างชั้นเรียนนี้หรือไม่

11 design  object-oriented  python  object-oriented-design  class-design 

พิจารณาอินเทอร์เฟซ: interface IWaveGenerator { SoundWave GenerateWave(double frequency, double lengthInSeconds); } อินเทอร์เฟซนี้ถูกใช้งานโดยคลาสที่สร้างคลื่นของรูปร่างที่แตกต่างกัน (ตัวอย่างเช่นSineWaveGeneratorและSquareWaveGenerator) ฉันต้องการใช้คลาสที่สร้างSoundWaveจากข้อมูลดนตรีไม่ใช่ข้อมูลเสียงดิบ มันจะได้รับชื่อของโน้ตและระยะเวลาในแง่ของการเต้น (ไม่กี่วินาที) ที่และภายในใช้IWaveGeneratorฟังก์ชั่นในการสร้างSoundWaveตาม คำถามคือควรNoteGeneratorประกอบด้วยIWaveGeneratorหรือควรได้รับมรดกจากการIWaveGeneratorดำเนินการ? ฉันเอนตัวไปยังองค์ประกอบเนื่องจากเหตุผลสองประการ: 1- มันช่วยให้ฉันสามารถฉีดใด ๆIWaveGeneratorไปยังNoteGeneratorแบบไดนามิก นอกจากนี้ฉันต้องการเพียงหนึ่งNoteGeneratorชั้นแทนSineNoteGenerator, SquareNoteGeneratorฯลฯ 2- มีความต้องการไม่ได้ที่จะเปิดเผยอินเตอร์เฟซในระดับต่ำกว่าที่กำหนดโดยNoteGeneratorIWaveGenerator อย่างไรก็ตามฉันโพสต์คำถามนี้เพื่อฟังความคิดเห็นอื่น ๆ เกี่ยวกับเรื่องนี้อาจเป็นจุดที่ฉันไม่ได้คิด BTW: ฉันจะบอกว่าNoteGenerator เป็นแนวคิดIWaveGeneratorเพราะมันสร้างSoundWaves

11 object-oriented  object-oriented-design  inheritance  composition 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ในหนึ่งในเสียงต่อต้านโอโอพีหลายเรื่องที่ cat-v.orgฉันพบข้อความโดยโจอาร์มสตรองยกการคัดค้านหลายรูปแบบกับ OOP ซึ่งหนึ่งในนั้นคือ: คัดค้าน 4 - วัตถุมีสถานะส่วนตัว รัฐเป็นรากฐานของความชั่วร้ายทั้งหมด ในฟังก์ชั่นเฉพาะที่มีผลข้างเคียงควรหลีกเลี่ยง ในขณะที่สถานะในการเขียนโปรแกรมภาษาไม่พึงประสงค์ในรัฐโลกแห่งความจริงมากมาย ฉันสนใจสถานะบัญชีธนาคารของฉันเป็นอย่างมากและเมื่อฉันฝากหรือถอนเงินจากธนาคารฉันคาดว่าสถานะบัญชีธนาคารของฉันจะได้รับการอัปเดตอย่างถูกต้อง เมื่อพิจารณาจากสถานะที่มีอยู่ในโลกแห่งความเป็นจริงสิ่งอำนวยความสะดวกที่ควรใช้ภาษาโปรแกรมสำหรับการจัดการกับรัฐ? OOPL พูดว่า "ซ่อนสถานะจากโปรแกรมเมอร์" สถานะถูกซ่อนและมองเห็นได้ผ่านฟังก์ชั่นการเข้าถึงเท่านั้น ภาษาโปรแกรมทั่วไป (C, Pascal) บอกว่าการมองเห็นของตัวแปรสถานะถูกควบคุมโดยกฎขอบเขตของภาษา ภาษาที่ประกาศอย่างบริสุทธิ์บอกว่าไม่มีรัฐ สถานะโกลบอลของระบบนั้นจะถูกนำไปใช้กับทุกฟังก์ชั่น กลไกเช่น monads (สำหรับ FPLs) และ DCGs (ภาษาลอจิก) ถูกใช้เพื่อซ่อนสถานะจากโปรแกรมเมอร์ดังนั้นพวกเขาจึงสามารถเขียนโปรแกรม“ ราวกับว่ารัฐไม่สำคัญ” แต่มีการเข้าถึงสถานะของระบบได้อย่างเต็มที่หากจำเป็น ตัวเลือก“ ซ่อนสถานะจากโปรแกรมเมอร์” ที่เลือกโดย OOPL เป็นตัวเลือกที่แย่ที่สุด แทนที่จะเปิดเผยสถานะและพยายามหาวิธีที่จะลดความน่ารำคาญของรัฐพวกเขาก็ซ่อนมันออกไป นี่หมายถึงอะไรกันแน่? ฉันมีประสบการณ์น้อยในขั้นตอนหรือขั้นตอนที่น้อยมากซึ่งส่วนใหญ่เป็น OOP ดังนั้นอาจอธิบายได้ว่าฉันไม่คุ้นเคยกับเรื่องนี้อย่างไร …

11 object-oriented  state 

โปรดพิจารณาคลาสนี้: class ClassA{ private Thing[] things; // stores data // stuff omitted public Thing[] getThings(){ return things; } } คลาสนี้จะเปิดเผยอาร์เรย์ที่ใช้ในการจัดเก็บข้อมูลรหัสลูกค้าใด ๆ ที่สนใจ ฉันทำสิ่งนี้ในแอปที่ฉันทำงานอยู่ ฉันมีChordProgressionคลาสที่เก็บลำดับของChords (และทำสิ่งอื่น) มันมีChord[] getChords()วิธีที่คืนค่าอาร์เรย์ของคอร์ด เมื่อโครงสร้างข้อมูลต้องเปลี่ยน (จากอาร์เรย์เป็น ArrayList) รหัสไคลเอ็นต์ทั้งหมดจะพัง นี่ทำให้ฉันคิดว่า - วิธีต่อไปนี้อาจจะดีกว่า: class ClassA{ private Thing[] things; // stores data // stuff omitted public Thing[] getThing(int index){ return …

11 design  object-oriented  encapsulation 

นี่เป็นคำถามที่ค่อนข้างคลุมเครือ แต่เป็นสิ่งที่ฉันไม่เคยรู้สึกว่าได้รับคำตอบอย่างน่าพอใจเมื่ออ่านเกี่ยวกับการออกแบบที่เหมาะสม โดยทั่วไปเมื่อเรียนรู้เกี่ยวกับการเขียนโปรแกรมเชิงวัตถุ, นามธรรม, แยกตัวประกอบ ฯลฯ จอกศักดิ์สิทธิ์ของการออกแบบ - และเหตุผลที่พวกเขาอ้างเสมอว่าคุณใช้เทคนิคการพัฒนาที่เป็นปัญหา - คือมันจะทำให้โปรแกรมของคุณ "ง่ายต่อการเปลี่ยนแปลง" , "maintainable", "ยืดหยุ่น" หรือคำพ้องความหมายใด ๆ ที่ใช้เพื่อแสดงแนวคิดเกี่ยวกับการผลิตที่ทำให้เกิดเสียงดังกล่าว ด้วยการทำเครื่องหมายส่วนตัวของ ivars ให้แยกรหัสออกเป็นวิธีเล็ก ๆ ที่มีอยู่ในตัวเองทำให้อินเตอร์เฟสทั่วไปทำให้คุณสามารถปรับเปลี่ยนโปรแกรมของคุณได้อย่างง่ายดาย สำหรับการเปลี่ยนแปลงที่ค่อนข้างเล็กสิ่งนี้ใช้ได้ดีสำหรับฉัน การเปลี่ยนแปลงโครงสร้างข้อมูลภายในที่ใช้โดยคลาสเพื่อเพิ่มประสิทธิภาพไม่เคยมีความยุ่งยากที่สำคัญและไม่มีการเปลี่ยนแปลงส่วนท้ายของส่วนต่อประสานผู้ใช้ที่เป็นอิสระจาก API เช่นการออกแบบระบบป้อนข้อความใหม่หรือปรับปรุงกราฟิกสำหรับองค์ประกอบการเล่นเกม . การเปลี่ยนแปลงทั้งหมดเหล่านี้ดูเหมือนมีอยู่ในตัวเองโดยเนื้อแท้ ไม่มีสิ่งใดที่เกี่ยวข้องกับการเปลี่ยนแปลงพฤติกรรมหรือการออกแบบองค์ประกอบของโปรแกรมของคุณที่ได้รับการแก้ไขตราบใดที่รหัสภายนอกเกี่ยวข้อง ไม่ว่าคุณจะเขียนขั้นตอนหรือในสไตล์ OO ที่มีฟังก์ชั่นขนาดใหญ่หรือขนาดเล็กการเปลี่ยนแปลงเหล่านี้ง่ายต่อการเปลี่ยนแปลงแม้ว่าคุณจะมีการออกแบบที่ดีพอสมควรก็ตาม อย่างไรก็ตามเมื่อใดก็ตามที่การเปลี่ยนแปลงมีขนาดใหญ่และมีขนฟูนั่นคือการเปลี่ยนแปลง API - ไม่มีรูปแบบ "อันมีค่า" ของฉันเลยที่จะช่วยเหลือ การเปลี่ยนแปลงครั้งใหญ่ยังคงใหญ่รหัสที่ได้รับผลกระทบยังคงได้รับผลกระทบและงานการวางไข่หลายชั่วโมงอยู่ข้างหน้าฉัน ดังนั้นคำถามของฉันคือสิ่งนี้ การออกแบบที่เหมาะสมนั้นมีการเปลี่ยนแปลงขนาดใหญ่เพียงใดเพื่อให้สามารถอำนวยความสะดวกได้? มีเทคนิคการออกแบบเพิ่มเติมบางอย่างไม่เป็นที่รู้จักสำหรับฉันหรือฉันล้มเหลวในการใช้งานที่ทำให้การปรับเปลี่ยนที่ทำให้เกิดเสียงง่าย ๆ หรือเป็นสัญญานั้น (ซึ่งฉันได้ยินจากกระบวนทัศน์ที่แตกต่างกันมากมาย) เป็นแนวคิดที่ดี ตัดการเชื่อมต่ออย่างสมบูรณ์จากความจริงที่ไม่เปลี่ยนรูปแบบของการพัฒนาซอฟต์แวร์? มี "เครื่องมือเปลี่ยน" …

11 design  object-oriented  maintenance  abstraction  changes