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

บางคนบอกว่าถ้าคุณนำหลักการของ SOLID มาใช้กับสุดขั้วคุณก็จะจบลงด้วยการเขียนโปรแกรมที่ใช้งานได้ ฉันเห็นด้วยกับบทความนี้ แต่ฉันคิดว่าซีแมนทิกส์บางอย่างหายไปจากการเปลี่ยนจากส่วนต่อประสาน / วัตถุไปเป็นฟังก์ชัน / ปิดและฉันต้องการทราบว่า Function Programming สามารถลดความสูญเสียได้อย่างไร จากบทความ: นอกจากนี้หากคุณใช้หลักการแยกส่วนต่อประสาน (ISP) อย่างจริงจังคุณจะเข้าใจว่าคุณควรใช้การเชื่อมต่อแบบสวมบทบาทแทนการเชื่อมต่อส่วนหัว หากคุณผลักดันการออกแบบของคุณไปสู่อินเทอร์เฟซที่เล็กลงเรื่อย ๆ ในที่สุดคุณจะมาถึงสุดยอด Role Interface: อินเทอร์เฟซด้วยวิธีการเดียว เรื่องนี้เกิดขึ้นกับฉันมาก นี่คือตัวอย่าง: public interface IMessageQuery { string Read(int id); } ถ้าฉันใช้การพึ่งพาIMessageQueryส่วนหนึ่งของสัญญาโดยนัยคือการโทรRead(id)จะค้นหาและส่งคืนข้อความด้วย ID ที่กำหนด เปรียบเทียบสิ่งนี้กับการพึ่งพาของลายเซ็นการทำงานที่เทียบเท่า, int -> string. โดยไม่ต้องชี้นำใด ๆ ToString()เพิ่มเติมฟังก์ชั่นนี้อาจจะง่าย หากคุณดำเนินการIMessageQuery.Read(int id)ด้วยToString()ฉันอาจกล่าวหาว่าคุณถูกโค่นล้มโดยเจตนา! ดังนั้นโปรแกรมเมอร์ฟังก์ชันสามารถทำอะไรได้เพื่อรักษาซีแมนทิกส์ของอินเตอร์เฟสที่มีชื่อดี ยกตัวอย่างเช่นมันเป็นเรื่องธรรมดาที่จะสร้างประเภทเรคคอร์ดโดยมีสมาชิกคนเดียวหรือไม่? type MessageQuery = { …

16 object-oriented  functional-programming  solid 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา อยู่มาวันหนึ่งฉันไปที่แชทสแต็คล้นล้นและเห็นวลีที่ระบุว่ามรดก incapsulation และ polymorphism เป็นเสาหลักของ OOP (ในแง่ที่ว่าพวกเขาเป็นพื้นฐานการก่อสร้างเพียงอย่างเดียว) นอกจากนี้ยังมีคำถามที่คล้ายกันที่ฉันถูกถามบ่อยมากในการสอบวิทยาลัยและการสัมภาษณ์งานและคำตอบที่ถูกต้องเสมอคือข้อความที่ออกเสียงในชื่อของคำถาม ("ใช่มรดกการห่อหุ้มและ polymorphism เป็นเสาหลักของ OOP ) แต่ในการแชทล้นมากเกินไปฉันถูกเยาะเย้ยอย่างรุนแรงผู้เข้าร่วมไม่เห็นด้วยอย่างยิ่งกับคำแถลงดังกล่าว ดังนั้นมีอะไรผิดปกติกับคำสั่งนี้ โปรแกรมเมอร์ดูเหมือนจะได้รับการฝึกฝนในสิ่งต่าง ๆ ในวิทยาลัยหลังโซเวียตและสหรัฐอเมริกาหรือไม่? การสืบทอดการห่อหุ้มและ polymorphism ไม่ถือเป็นเสาหลักของ OOP โดยโปรแกรมเมอร์ของสหรัฐฯ / อังกฤษหรือไม่?

16 object-oriented 

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

16 object-oriented  functional-programming 

ฉันพยายามที่จะเข้าใจความหมายของ 'abstraction' ใน OOP ฉันได้เจอคำจำกัดความหลักสองสามข้อ พวกเขาทั้งหมดถูกต้องหรือไม่ เป็นหนึ่งในพวกเขาผิดหรือเปล่า? ฉันสับสน (ฉันเขียนคำจำกัดความใหม่ด้วยคำพูดของตัวเอง) คำจำกัดความ 1: สิ่งที่เป็นนามธรรมเป็นแนวคิดของการหยิบวัตถุบางอย่างจากโลกแห่งความเป็นจริงและแปลงเป็นเงื่อนไขการเขียนโปรแกรม เช่นการสร้างHumanการเรียนและให้มันint health, int age, String nameฯลฯ คุณสมบัติและeat()วิธีการอื่น ๆ คำจำกัดความ 2: คำจำกัดความทั่วไปมากขึ้น Abstraction เป็นแนวคิดที่เกิดขึ้นได้ทุกที่ในระบบซอฟต์แวร์ที่เกี่ยวข้องกับ'การทำให้สิ่งต่าง ๆเป็นเรื่องธรรมดา/ ง่ายขึ้น / เป็นนามธรรม' ตัวอย่างบางส่วน: ลำดับชั้นการสืบทอดที่คลาสที่สูงกว่าง่ายกว่าหรือทั่วไปกว่าและกำหนดการใช้งานทั่วไปและนามธรรมมากขึ้น ในขณะที่คลาสที่ต่ำกว่าในลำดับชั้นนั้นเป็นรูปธรรมมากขึ้นและกำหนดการใช้งานที่มีรายละเอียดมากขึ้น การใช้การห่อหุ้มเพื่อซ่อนรายละเอียดของการใช้คลาสจากคลาสอื่น ๆ จึงทำให้คลาส 'นามธรรม' (ง่ายกว่า) สู่โลกของซอฟต์แวร์ภายนอก คำจำกัดความ 3 นิยามทั่วไปอีกประการหนึ่ง: Abstraction เป็นแนวคิดของการย้ายโฟกัสจากรายละเอียดและการใช้สิ่งต่าง ๆ อย่างเป็นรูปธรรมกับประเภทของสิ่งต่าง ๆ (เช่นคลาส) การดำเนินการที่มีอยู่ (เช่นวิธีการ) ฯลฯ …

16 object-oriented  abstraction 

ฉันกำลังทำงานกับรหัส UI ที่ฉันมีActionชั้นเรียนเช่นนี้ - public class MyAction extends Action { public MyAction() { setText("My Action Text"); setToolTip("My Action Tool tip"); setImage("Some Image"); } } เมื่อคลาส Action นี้ถูกสร้างขึ้นมันค่อนข้างจะสันนิษฐานได้ว่าActionคลาสนั้นจะไม่สามารถปรับแต่งได้ (ในความหมาย - ข้อความคำแนะนำเครื่องมือหรือรูปภาพจะไม่สามารถเปลี่ยนแปลงได้ทุกที่ในรหัส) ตอนนี้เราต้องการเปลี่ยนข้อความการกระทำในบางตำแหน่งในโค้ด ดังนั้นฉันแนะนำเพื่อนร่วมงานของฉันให้ลบข้อความการกระทำที่ฮาร์ดโค้ดออกจากตัวสร้างและยอมรับว่าเป็นอาร์กิวเมนต์เพื่อให้ทุกคนถูกบังคับให้ส่งข้อความการกระทำ บางอย่างเช่นรหัสด้านล่าง - public class MyAction extends Action { public MyAction(String actionText) { setText(actionText); setTooltip("My Action tool tip"); setImage("My …

16 java  design  object-oriented  refactoring 

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

16 object-oriented 

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

16 web-development  object-oriented  zend-framework  technique  mind-mapping 

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

16 design-patterns  object-oriented  inheritance 

แค่อ่านบรรทัดเหล่านี้ - หากข้อมูลของคุณเป็นวัตถุโดยทั่วไปให้ใช้ที่เก็บวัตถุ ("NoSQL") มันจะเร็วกว่าฐานข้อมูลเชิงสัมพันธ์ หากข้อมูลของคุณเป็นแบบเชิงสัมพันธ์ค่าใช้จ่ายของฐานข้อมูลเชิงสัมพันธ์จะคุ้มค่า จาก- http://seldo.com/weblog/2011/06/15/orm_is_an_antipattern ดังนั้นฉันจะรู้ได้อย่างไรว่าข้อมูลของฉันสัมพันธ์ในลักษณะเชิงวัตถุหรือไม่?

16 object-oriented  database  relational-database 

ฉันอ่านการทำงานอย่างมีประสิทธิภาพด้วย Legacy CodeและClean Codeโดยมีเป้าหมายของกลยุทธ์การเรียนรู้เกี่ยวกับวิธีเริ่มทำความสะอาดโค้ด - ฐานที่มีอยู่ของแอปพลิเคชัน ASP.NET webforms ขนาดใหญ่ ระบบนี้มีมาตั้งแต่ปีพ. ศ. 2548 และตั้งแต่นั้นมาก็มีการปรับปรุงหลายอย่าง แต่เดิมรหัสมีโครงสร้างดังนี้ (และยังคงเป็นโครงสร้างส่วนใหญ่ด้วยวิธีนี้): ASP.NET (aspx / ascx) รหัส - หลัง (c #) ชั้นตรรกะทางธุรกิจ (c #) ชั้นการเข้าถึงข้อมูล (c #) ฐานข้อมูล (Oracle) ปัญหาหลักคือรหัสคือการปลอมแปลงตามขั้นตอนเป็นเชิงวัตถุ มันเป็นการละเมิดแนวทางทั้งหมดที่อธิบายไว้ในหนังสือทั้งสองเล่ม นี่คือตัวอย่างของคลาสทั่วไปใน Business Logic Layer: public class AddressBO { public TransferObject GetAddress(string addressID) { if (StringUtils.IsNull(addressID)) { …

16 c#  .net  unit-testing  object-oriented 

อะไรคือกลยุทธ์ของ OOP สำหรับการทำงานกับฐานข้อมูล แต่ทำให้สิ่งต่าง ๆ ที่หน่วยทดสอบได้? ว่าฉันมีคลาสผู้ใช้และสภาพแวดล้อมการผลิตของฉันทำงานกับ MySQL ฉันเห็นแนวทางที่เป็นไปได้สองสามข้อแสดงที่นี่โดยใช้ PHP: ส่งผ่าน $ data_source พร้อมอินเทอร์เฟซสำหรับload()และsave()เป็นนามธรรมแหล่งข้อมูลเบื้องหลัง เมื่อทำการทดสอบให้ส่งผ่านแหล่งข้อมูลอื่น $ user = ผู้ใช้ใหม่ ($ mysql_data_source); $ user-> load ('bob'); $ user-> setNickname ('Robby'); $ ที่ผู้ใช้> บันทึก (); ใช้โรงงานที่เข้าถึงฐานข้อมูลและส่งผ่านแถวผลลัพธ์ไปยังตัวสร้างของผู้ใช้ เมื่อทำการทดสอบให้สร้างพารามิเตอร์ $ row หรือจำลองวัตถุใน UserFactory :: $ data_source ด้วยตนเอง (ฉันจะบันทึกการเปลี่ยนแปลงในระเบียนได้อย่างไร) class UserFactory { static $data_source; public …

16 architecture  unit-testing  object-oriented  database 

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

16 object-oriented  domain-driven-design 

ฉันไม่ได้กำลังมองหาความคิดเห็นเกี่ยวกับความหมาย แต่เพียงสำหรับกรณีที่มีการใช้ getters อย่างสมเหตุสมผลเป็นอุปสรรคจริง บางทีมันอาจทำให้ฉันกลายเป็นเกลียวที่ไม่มีที่สิ้นสุดของการพึ่งพาพวกเขาบางทีอาจเป็นทางเลือกที่สะอาดและจัดการกับผู้ได้รับโดยอัตโนมัติ ฯลฯ บางอย่างเป็นรูปธรรม ฉันได้ยินข้อโต้แย้งทั้งหมดฉันได้ยินมาว่าพวกเขาไม่ดีเพราะพวกเขาบังคับให้คุณปฏิบัติต่อวัตถุในฐานะแหล่งข้อมูลว่าพวกเขาละเมิด "สถานะบริสุทธิ์" ของ "วัตถุ" อย่าให้มากเกินไป แต่เตรียมที่จะ ยอมรับมาก " แต่ไม่มีเหตุผลที่สมเหตุสมผลสำหรับเหตุผลที่getDataเป็นสิ่งที่ไม่ดีในความเป็นจริงไม่กี่คนที่เป็นที่ถกเถียงกันอยู่ว่ามันเป็นเรื่องเกี่ยวกับความหมาย, getters อย่างดีต่อ se แต่เพียงแค่ไม่ได้ตั้งชื่อพวกเขาgetXให้ฉันนี้อย่างน้อยตลก . อะไรคือสิ่งที่ไม่มีความคิดเห็นที่จะทำลายถ้าฉันใช้ตัวรับสัญญาณอย่างสมเหตุสมผลและสำหรับข้อมูลที่ชัดเจนว่าความสมบูรณ์ของวัตถุไม่แตกถ้ามันทำให้เกิดขึ้น แน่นอนว่าการอนุญาตให้ getter สำหรับสตริงที่ใช้ในการเข้ารหัสบางอย่างนั้นเกินกว่าจะเป็นใบ้ แต่ฉันกำลังพูดถึงข้อมูลที่ระบบของคุณต้องการใช้งาน บางทีข้อมูลของคุณจะถูกดึงผ่านProviderจากวัตถุ แต่ยังคงวัตถุยังคงต้องการที่จะช่วยให้Providerการทำ$provider[$object]->getDataมีวิธีรอบ ๆ มันไม่มี ทำไมฉันขอ: ฉัน getters เมื่อใช้อย่างสมเหตุสมผลและข้อมูลที่จะถือว่าเป็น "ปลอดภัย" จะถูกพระเจ้าส่ง 99% ของ getters ฉันจะใช้ในการระบุวัตถุในขณะที่ฉันถามรหัสผ่านObject, what is your name? Object, what is your identifier?, ทุกคนที่ทำงานกับวัตถุควรรู้สิ่งเหล่านี้เกี่ยวกับวัตถุเพราะเกือบทุกอย่างเกี่ยวกับการเขียนโปรแกรมเป็นตัวตนและใครอื่นรู้ดีกว่ามันคืออะไรตัวเอง? …

15 object-oriented 

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

15 object-oriented  architecture  functional-programming 

ฉันกำลังเขียนแอปพลิเคชัน OOP ขนาดกลางใน C ++ เป็นวิธีฝึกหลักการ OOP ฉันมีหลายคลาสในโครงการของฉันและบางส่วนจำเป็นต้องเข้าถึงพารามิเตอร์การกำหนดค่าใช้งาน พารามิเตอร์เหล่านี้อ่านจากแหล่งต่าง ๆ ในระหว่างการเริ่มต้นแอปพลิเคชัน บางไฟล์ถูกอ่านจากไฟล์ปรับแต่งในผู้ใช้ที่บ้านบางคนเป็นอาร์กิวเมนต์บรรทัดคำสั่ง (argv) ConfigBlockดังนั้นผมจึงสร้างชั้นเรียน คลาสนี้อ่านแหล่งพารามิเตอร์ทั้งหมดและเก็บไว้ในโครงสร้างข้อมูลที่เหมาะสม ตัวอย่างคือชื่อพา ธ และชื่อไฟล์ที่ผู้ใช้สามารถเปลี่ยนได้ในไฟล์กำหนดค่าหรือ - --verbose CLI flag จากนั้นหนึ่งสามารถโทรConfigBlock.GetVerboseLevel()เพื่ออ่านพารามิเตอร์เฉพาะนี้ คำถามของฉัน: เป็นการดีหรือไม่ที่จะรวบรวมข้อมูลการกำหนดค่ารันไทม์ทั้งหมดในชั้นเดียว? จากนั้นชั้นเรียนของฉันต้องการเข้าถึงพารามิเตอร์เหล่านี้ทั้งหมด ฉันสามารถคิดหลายวิธีในการบรรลุเป้าหมายนี้ แต่ฉันไม่แน่ใจว่าควรใช้วิธีใด คอนสตรัคเตอร์ของคลาสสามารถอ้างอิงถึง ConfigBlock ของฉันได้ public: MyGreatClass(ConfigBlock &config); หรือพวกเขาเพียงแค่รวมส่วนหัว "CodingBlock.h" ซึ่งมีคำจำกัดความของ CodingBlock ของฉัน: extern CodingBlock MyCodingBlock; จากนั้นไฟล์คลาส. cpp เท่านั้นที่ต้องรวมและใช้สิ่งที่ ConfigBlock ไฟล์. h ไม่แนะนำอินเทอร์เฟซนี้กับผู้ใช้ของคลาส อย่างไรก็ตามอินเทอร์เฟซสำหรับ …

15 design-patterns  object-oriented  c++