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

ฉันจะใช้คำอธิบายภาษาที่ไม่เชื่อเรื่องพระเจ้าของ monads เช่นนี้ก่อนอธิบาย monoids: หนังสือคือ ( ๆ ) ชุดของฟังก์ชั่นที่ใช้บางชนิดเป็นพารามิเตอร์และส่งกลับชนิดเดียวกัน monadเป็น ( ๆ ) ชุดของฟังก์ชั่นที่ใช้เป็นกระดาษห่อประเภทเป็นพารามิเตอร์และส่งกลับชนิดกระดาษห่อเดียว หมายเหตุเหล่านั้นคือคำอธิบายไม่ใช่คำจำกัดความ รู้สึกอิสระที่จะโจมตีคำอธิบายนั้น! ดังนั้นในภาษา OO monad อนุญาตให้มีองค์ประกอบการดำเนินการเช่น: Flier<Duck> m = new Flier<Duck>(duck).takeOff().flyAround().land() โปรดทราบว่า monad กำหนดและควบคุมซีแมนทิกส์ของการดำเนินการเหล่านั้นมากกว่าคลาสที่มีอยู่ ตามเนื้อผ้าในภาษา OO เราจะใช้ลำดับชั้นและการสืบทอดเพื่อให้ความหมายเหล่านั้น ดังนั้นเราจึงต้องการมีBirdระดับด้วยวิธีการtakeOff(), flyAround()และland()และเป็ดจะได้รับมรดกเหล่านั้น แต่แล้วเราก็มีปัญหากับนกที่บินไม่ได้เพราะpenguin.takeOff()ล้มเหลว เราต้องหันไปใช้ข้อยกเว้นในการขว้างและจัดการ นอกจากนี้เมื่อเราบอกว่าเพนกวินเป็นเราทำงานเป็นปัญหากับมรดกหลายตัวอย่างเช่นถ้าเรายังมีลำดับชั้นของBirdSwimmer โดยพื้นฐานแล้วเรากำลังพยายามที่จะใส่คลาสเป็นหมวดหมู่ (ด้วยการขอโทษกับหมวดหมู่ทฤษฎีพวก) และกำหนดความหมายตามหมวดหมู่มากกว่าในแต่ละชั้นเรียน แต่พระสงฆ์ดูเหมือนจะเป็นกลไกที่ชัดเจนกว่าสำหรับการทำเช่นนั้นมากกว่าลำดับชั้น ดังนั้นในกรณีนี้เราจะมีFlier<T>monad เหมือนตัวอย่างด้านบน: Flier<Duck> m = new Flier<Duck>(duck).takeOff().flyAround().land() ... Flier<Penguin>และเราจะไม่ยกตัวอย่าง เราสามารถใช้การพิมพ์แบบคงที่เพื่อป้องกันสิ่งนั้นไม่ให้เกิดขึ้นด้วยอินเทอร์เฟซของตัวทำเครื่องหมาย …

20 object-oriented  monad 

ใน Java โดยเฉพาะ แต่มีแนวโน้มในภาษาอื่นเช่นกัน: เมื่อใดจะมีประโยชน์ที่จะมีสองการอ้างอิงไปยังวัตถุเดียวกัน ตัวอย่าง: Dog a = new Dog(); Dob b = a; มีสถานการณ์ที่สิ่งนี้จะเป็นประโยชน์หรือไม่? ทำไมนี้จะเป็นทางออกที่ต้องการที่จะใช้aเมื่อใดก็ตามที่คุณต้องการที่จะมีปฏิสัมพันธ์กับวัตถุที่แสดงโดยa?

20 object-oriented  object-oriented-design  object 

สมมติว่าคุณมีสองอินเตอร์เฟส: interface Readable { public void read(); } interface Writable { public void write(); } ในบางกรณีวัตถุที่ใช้งานสามารถรองรับหนึ่งในสิ่งเหล่านี้ แต่ในหลายกรณีการใช้งานจะสนับสนุนทั้งสองอินเตอร์เฟส ผู้ใช้อินเทอร์เฟซจะต้องทำสิ่งที่ชอบ: // can't write to it without explicit casting Readable myObject = new MyObject(); // can't read from it without explicit casting Writable myObject = new MyObject(); // tight coupling to actual implementation …

20 java  object-oriented 

เป็นสถาปัตยกรรมระบบตัวแทน Entityเชิงวัตถุโดยความหมาย? ดูเหมือนว่าฉันหรือขั้นตอนการทำงานมากขึ้น ความคิดเห็นของฉันคือมันไม่ได้ป้องกันคุณจากการใช้งานในภาษา OO แต่มันจะไม่เป็นเรื่องแปลกที่จะทำเช่นนั้นในทาง OO อย่างแข็งขัน ดูเหมือนว่า ECS จะแยกข้อมูล (E & C) ออกจากพฤติกรรม (S) เป็นหลักฐาน : แนวคิดคือไม่มีวิธีการฝังเกมในเอนทิตี และ : ส่วนประกอบประกอบด้วยชุดข้อมูลขั้นต่ำที่จำเป็นสำหรับวัตถุประสงค์เฉพาะ ระบบคือฟังก์ชั่นวัตถุประสงค์เดียวที่ใช้ชุดของเอนทิตีที่มีองค์ประกอบเฉพาะ ฉันคิดว่านี่ไม่ใช่เชิงวัตถุเพราะส่วนใหญ่ของการมุ่งเน้นวัตถุคือการรวมข้อมูลและพฤติกรรมของคุณเข้าด้วยกัน เป็นหลักฐาน : ในทางตรงกันข้ามวิธีการเชิงวัตถุสนับสนุนให้โปรแกรมเมอร์วางข้อมูลที่ไม่สามารถเข้าถึงได้โดยตรงโดยส่วนที่เหลือของโปรแกรม แต่จะเข้าถึงข้อมูลได้โดยการเรียกฟังก์ชั่นที่เขียนขึ้นเป็นพิเศษโดยทั่วไปเรียกว่าเมธอดซึ่งรวมอยู่ในข้อมูล ในทางกลับกัน ECS ดูเหมือนจะเป็นเรื่องเกี่ยวกับการแยกข้อมูลของคุณออกจากพฤติกรรมของคุณ

20 design-patterns  object-oriented  functional-programming  architectural-patterns  entity-component-system 

ฉันเป็นโปรแกรมเมอร์ C ++ ระดับต้น แต่ฉันเข้าใจแนวคิดของภาษาค่อนข้างดี เมื่อฉันเริ่มเรียนรู้ไลบรารี C ++ ภายนอกเช่น SDL, OpenGL (อาจเป็นอย่างอื่น) ด้วยความประหลาดใจที่ยิ่งใหญ่ของฉันฉันพบว่าพวกเขาไม่ได้ใช้แนวคิด C ++ เลย ตัวอย่างเช่นทั้ง SDL และ OpenGL ไม่ใช้คลาสหรือข้อยกเว้นเลือกฟังก์ชั่นและรหัสข้อผิดพลาด ใน OpenGL ฉันเคยเห็นฟังก์ชั่นเช่น glVertex2f ซึ่งใช้ตัวแปรลอย 2 ตัวเป็นอินพุตและน่าจะดีกว่าเทมเพลต นอกจากนี้บางครั้งห้องสมุดเหล่านี้ใช้มาร์กอสในขณะที่ดูเหมือนว่าเป็นข้อตกลงทั่วไปที่ใช้มาโครไม่ดี โดยรวมแล้วพวกเขาดูเหมือนจะเขียนในสไตล์ C มากกว่าในสไตล์ C ++ แต่พวกเขาเป็นภาษาที่แตกต่างกันโดยสิ้นเชิงใช่มั้ย คำถามคือเหตุใดห้องสมุดสมัยใหม่จึงไม่ใช้ข้อดีของภาษาที่เขียน

20 c++  object-oriented  libraries  opengl 

ฉันได้ผ่านทฤษฏีมากมายเกี่ยวกับการห่อหุ้มและเทคนิคสามประการของการนำไปใช้ซึ่ง ได้แก่ Association, Aggregation and Composition สิ่งที่ฉันพบคือ : encapsulation Encapsulation เป็นเทคนิคในการสร้างฟิลด์ในคลาสส่วนตัวและให้การเข้าถึงฟิลด์ด้วยวิธีสาธารณะ หากมีการประกาศเขตข้อมูลส่วนบุคคลจะไม่สามารถเข้าถึงได้โดยทุกคนที่อยู่นอกชั้นเรียนดังนั้นจึงซ่อนเขตข้อมูลภายในชั้นเรียน ด้วยเหตุนี้การห่อหุ้มจึงถูกเรียกว่าการซ่อนข้อมูล การห่อหุ้มสามารถอธิบายได้ว่าเป็นเกราะป้องกันที่ป้องกันรหัสและข้อมูลที่ถูกเข้าถึงแบบสุ่มโดยรหัสอื่นที่กำหนดไว้นอกคลาส การเข้าถึงข้อมูลและรหัสถูกควบคุมอย่างแน่นหนาโดยอินเตอร์เฟส ประโยชน์หลักของการห่อหุ้มคือความสามารถในการปรับเปลี่ยนรหัสที่เรานำไปใช้โดยไม่ทำลายรหัสของผู้อื่นที่ใช้รหัสของเรา ด้วยคุณสมบัตินี้ Encapsulation ช่วยให้การบำรุงรักษาความยืดหยุ่นและความสามารถในการขยายโค้ดของเรา สมาคม การเชื่อมโยงคือความสัมพันธ์ที่วัตถุทั้งหมดมีวงจรชีวิตของตนเองและไม่มีเจ้าของ ลองมาเป็นตัวอย่างของครูและนักเรียน นักเรียนหลายคนสามารถเชื่อมโยงกับครูคนเดียวและนักเรียนคนเดียวสามารถเชื่อมโยงกับครูหลายคน แต่ไม่มีความเป็นเจ้าของระหว่างวัตถุและทั้งสองมีวงจรชีวิตของตัวเอง ทั้งสามารถสร้างและลบได้อย่างอิสระ การรวมตัว การรวมเป็นรูปแบบเฉพาะของสมาคมที่วัตถุทั้งหมดมีวงจรชีวิตของตนเอง แต่มีความเป็นเจ้าของและวัตถุลูกไม่สามารถเป็นของวัตถุแม่อื่นได้ มาดูตัวอย่างของภาควิชาและอาจารย์ ครูคนเดียวไม่สามารถอยู่ในหลายแผนกได้ แต่ถ้าเราลบแผนกวัตถุของอาจารย์จะไม่ถูกทำลาย เราสามารถคิดว่ามันเป็นความสัมพันธ์แบบ "มี - a" ส่วนประกอบ องค์ประกอบเป็นอีกรูปแบบหนึ่งของการรวมตัวและเราสามารถเรียกสิ่งนี้ว่าเป็นความสัมพันธ์ "ความตาย" มันเป็นประเภทที่แข็งแกร่งของการรวม วัตถุลูกไม่มีวงจรชีวิตและถ้าวัตถุแม่ลบวัตถุลูกทั้งหมดจะถูกลบ ลองมาอีกตัวอย่างของความสัมพันธ์ระหว่างบ้านและห้อง บ้านสามารถมีหลายห้อง แต่ไม่มีชีวิตอิสระของห้องและห้องใด ๆ ไม่สามารถเป็นของบ้านสองหลังที่แตกต่างกัน หากเราลบบ้านห้องจะถูกลบโดยอัตโนมัติ คำถามคือ: ตอนนี้สิ่งเหล่านี้เป็นตัวอย่างของโลกแห่งความจริง ฉันกำลังมองหาคำอธิบายเกี่ยวกับวิธีการใช้เทคนิคเหล่านี้ในรหัสชั้นเรียนจริง ผมหมายถึงสิ่งที่เป็นจุดสำหรับการใช้สามเทคนิคที่แตกต่างกันสำหรับการห่อหุ้ม …

20 object-oriented  encapsulation 

ใน Java, C # และภาษาที่มีการตรวจสอบอย่างมากและมีการพิมพ์แบบคงที่เราใช้ในการเขียนโค้ดดังนี้: public void m1() { ... } protected void m2() { ... } private void m2() { ... } void m2() { ... } ภาษาที่ตรวจสอบแบบไดนามิกบางภาษาไม่ได้ให้คำหลักเพื่อแสดงระดับของ "ความเป็นส่วนตัว" ของสมาชิกชั้นเรียนที่กำหนดและพึ่งพาวิธีการเข้ารหัสแทน Python เช่นคำนำหน้าสมาชิกส่วนตัวที่มีเครื่องหมายขีดล่าง: _m(self): pass อาจเป็นที่ถกเถียงกันอยู่ว่าการให้คำหลักดังกล่าวในภาษาที่ตรวจสอบแบบไดนามิกจะเพิ่มการใช้งานเพียงเล็กน้อยเนื่องจากมีการตรวจสอบที่รันไทม์เท่านั้น อย่างไรก็ตามฉันไม่พบเหตุผลที่ดีที่จะให้คำหลักเหล่านี้ในภาษาที่ผ่านการตรวจสอบแบบคงที่เช่นกัน ฉันพบว่าข้อกำหนดในการกรอกรหัสด้วยคำหลักที่ค่อนข้างละเอียดเช่นprotectedทั้งน่ารำคาญและเสียสมาธิ จนถึงตอนนี้ฉันยังไม่ได้อยู่ในสถานการณ์ที่ข้อผิดพลาดของคอมไพเลอร์ที่เกิดจากคำหลักเหล่านี้จะช่วยฉันจากข้อผิดพลาด ในทางตรงกันข้ามฉันอยู่ในสถานการณ์ที่การวางผิดพลาดprotectedทำให้ฉันไม่สามารถใช้ห้องสมุดได้ เมื่อคำนึงถึงสิ่งนี้คำถามของฉันคือ: ข้อมูลซ่อนตัวมากกว่าแบบแผนระหว่างโปรแกรมเมอร์ใช้เพื่อกำหนดว่าส่วนใดของส่วนต่อประสานที่เป็นทางการของคลาส? มันสามารถใช้เพื่อป้องกันสถานะลับของชั้นเรียนจากการถูกโจมตีหรือไม่? การสะท้อนกลับสามารถแทนที่กลไกนี้ได้หรือไม่? อะไรจะทำให้คุ้มค่าสำหรับคอมไพเลอร์ในการบังคับใช้การซ่อนข้อมูล

20 object-oriented  concepts 

วัตถุไม่เคย? ดีแทบจะไม่เคย ในส่วน VIEWPOINT ของ Communications of The ACM ฉันพบบทความที่น่าสนใจเรื่อง " Objects Never? Well, Hardly Ever " มันเป็นมุมมองที่แตกต่างอย่างสิ้นเชิงจากวัตถุแรกหรือวัตถุช้า เขาแนะนำ "ไม่เคยมีวัตถุ" หรืออาจเป็น "โรงเรียนที่สำเร็จการศึกษาจากวัตถุ" ผู้เขียนพูดคุยเกี่ยวกับ OOP และตั้งคำถามเกี่ยวกับวิธีการใช้ OOP ในสภาพแวดล้อมการเขียนโปรแกรมในโลกแห่งความเป็นจริง เขาคิดว่า OOP ไม่ใช่รูปแบบการเขียนโปรแกรมที่โดดเด่น ตัวอย่างเช่นเขาอ้างว่า 70% ของการเขียนโปรแกรมเสร็จแล้วสำหรับระบบสมองกลฝังตัวที่ OOP ไม่เหมาะจริง ๆ เมื่ออาจารย์ในมหาวิทยาลัยต้องการพูดคุยเกี่ยวกับประโยชน์ของ OOP พวกเขาจะพูดถึงการใช้รหัสซ้ำ อีกตัวอย่างเขาอ้างว่านี่ไม่ใช่กรณีจริงในโลกแห่งความเป็นจริง การใช้ซ้ำรหัสนั้นยากกว่าสิ่งที่อ้างในมหาวิทยาลัย: ฉันอ้างว่าการใช้ OOP นั้นไม่เป็นที่แพร่หลายเหมือนที่คนส่วนใหญ่เชื่อว่ามันไม่ประสบความสำเร็จเท่าที่ผู้เสนอเรียกร้องและดังนั้นที่กลางของมันในหลักสูตร CS ไม่ได้เป็นธรรม เป็นเรื่องที่น่าสนใจสำหรับฉันที่จะรู้ว่าผู้คนในกองซ้อนกันคิดอย่างไรกับเรื่องนี้? OOP เป็นรูปแบบการเขียนโปรแกรมที่โดดเด่นจากมุมมองของโปรแกรมเมอร์หรือไม่? ถ้าฉันควรเลือก …

20 object-oriented  paradigms  language-agnostic 

มีวัตถุประสงค์ในการประกาศinit()วิธีการสำหรับประเภทใด ๆ ? ฉันไม่ได้ถามว่าเราควรจะต้องการinit()มากกว่านวกรรมิกหรือวิธีการหลีกเลี่ยงการประกาศinit() ฉันถามว่ามีเหตุผลใด ๆ ที่อยู่เบื้องหลังการประกาศinit()วิธีการ (ดูว่ามันเป็นเรื่องธรรมดา) หรือไม่ถ้ามันเป็นกลิ่นรหัสและควรหลีกเลี่ยง init()สำนวนเป็นเรื่องธรรมดามาก แต่ผมยังไม่เห็นประโยชน์ที่แท้จริงใด ๆ ฉันกำลังพูดถึงประเภทที่สนับสนุนการเริ่มต้นด้วยวิธีการ: class Demo { public void init() { //... } } สิ่งนี้จะใช้ในรหัสการผลิตเมื่อใด ฉันรู้สึกว่ามันอาจจะเป็นกลิ่นรหัสเพราะมันบอกว่านวกรรมิกไม่เริ่มต้นวัตถุอย่างสมบูรณ์ทำให้วัตถุที่สร้างขึ้นบางส่วน วัตถุไม่ควรมีอยู่หากไม่ได้ตั้งสถานะ นี่ทำให้ฉันเชื่อว่ามันอาจเป็นส่วนหนึ่งของเทคนิคบางชนิดที่ใช้เพื่อเพิ่มความเร็วในการผลิตในแง่ของการใช้งานระดับองค์กร มันเป็นเหตุผลเดียวที่ฉันคิดได้ว่ามีสำนวนแบบนี้ฉันไม่แน่ใจว่ามันจะมีประโยชน์อย่างไรถ้าเป็นเช่นนั้น

20 java  object-oriented  object-oriented-design  code-quality  code-smell 

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

20 java  c#  design-patterns  object-oriented  terminology 

ฉันเข้าใจว่าตาม C ++ สเป็คไม่มีสิ่งเช่น "วิธีการ" และบางส่วน (มากที่สุด?) โปรแกรมเมอร์ C ++ พิจารณา "วิธี" เป็น Java-ism ในทางกลับกันแม้แต่ในฟอรัม C ++คนก็ดูเหมือนจะพูดถึงวิธีการต่างๆโดยไม่ชักกระตุก ฉันกำลังมองหาอนุสัญญาที่เป็นที่รู้จักหรือการปฏิบัติทั่วไปเกี่ยวกับคำศัพท์นี้ ฉันกำลังทำเอกสาร API ที่มีทั้ง C ++ และ Java เวอร์ชัน นักพัฒนาได้เก็บคลาสและเมธอด / ฟังก์ชันสมาชิกไว้เหมือนกันระหว่างสองชื่อนี้เพื่อความสะดวกในการย้ายและการทดสอบ ด้วยเหตุนี้สิ่งที่จำเป็นต้องได้รับการบันทึกเกี่ยวกับ API เหล่านี้คือ "ทางเลือก" ด้านบนของภาษา ฉันต้องสามารถพูดคุยทั่วไปเกี่ยวกับ Foos และ Bars ด้วยวิธีการ baz () และ mumble () ... วิธีการ? ถ้าฉันพูดถึงวิธีการโปรแกรมเมอร์ Java จะพิจารณาเป็นธรรมชาติและจะปรากฏขึ้นโปรแกรมเมอร์ C …

19 object-oriented  c++  terminology 

ตามRefactoring เพื่อรูปแบบ : เมื่อคลาสพยายามทำมากเกินไปมันมักจะแสดงตัวแปรอินสแตนซ์มากเกินไป เมื่อคลาสมีตัวแปรอินสแตนซ์มากเกินไปรหัสที่ซ้ำกันจะไม่สามารถล้าหลังได้ การมีตัวแปรอินสแตนซ์มากเกินไปนำไปสู่การทำซ้ำรหัสได้อย่างไร

19 design  design-patterns  object-oriented  object-oriented-design  refactoring 

ฉันอ่านว่าหลักการทดแทนของ Liskovถูกละเมิดหาก: เงื่อนไขเบื้องต้นมีความเข้มแข็งหรือ Postconditions จะอ่อนแอลง แต่ฉันยังไม่เข้าใจว่าจุดสองจุดนี้จะละเมิดหลักการเปลี่ยนตัว Liskov อย่างไร บางคนได้โปรดอธิบายด้วยตัวอย่าง โดยเฉพาะอย่างยิ่งหนึ่งในเงื่อนไขข้างต้นจะทำให้สถานการณ์ที่วัตถุ subclass ไม่สามารถทดแทนสำหรับวัตถุ superclass ได้อย่างไร

19 object-oriented  inheritance  abstraction  liskov-substitution 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันเริ่มต้นด้วย ActionScript 2.0 แล้วจึงไปกับ Java ฉันเรียนรู้หรืออย่างน้อยก็ใช้หลายภาษาตั้งแต่นั้นมารวมถึง Python (อาจเป็นภาษาที่ฉันชอบ) ฉันกลัวว่ารูปแบบการเขียนโปรแกรมเชิงวัตถุของฉันนั้นไม่ค่อยไพเราะมากและอย่าง Java OOP ที่มีไวยากรณ์ของ Python อะไรที่ทำให้ Java like และ Pythonic OOP แตกต่างจากกัน? โปรแกรมเมอร์ Java ทำสิ่งใดบ่อยครั้งที่ "unpythonically" เมื่อเขียนโค้ดเชิงวัตถุใน Python

19 java  object-oriented  python 

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

19 java  object-oriented  groovy  static  instance