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

TD; DR: มีความสับสนเกี่ยวกับสิ่งที่ฉันถามดังนั้นนี่คือแนวคิดการขับขี่ที่อยู่เบื้องหลังคำถาม: ฉันมักจะตั้งคำถามว่ามันคืออะไร ฉันอาจไม่ได้พูดชัดแจ้ง แต่แรกเริ่ม แต่เจตนาได้เสมอ " เป็นโมดูลแยกแยกหลวมคู่ decoupled รหัส refactored " ช้าลงอย่างเห็นได้ชัดโดยธรรมชาติของตัวเองมากกว่า " เสาเดียวหน่วยทำทุกอย่างในที่เดียวหนึ่งไฟล์คู่แน่น " รหัส ส่วนที่เหลือเป็นเพียงรายละเอียดและอาการต่าง ๆ ของเรื่องนี้ที่ฉันเจอในตอนนี้หรือตอนนี้หรือจะในภายหลัง มันช้าลงอย่างแน่นอนในระดับหนึ่ง เช่นเดียวกับดิสก์ที่ไม่มีการดีแฟรกต์คุณต้องเลือกชิ้นส่วนจากทุกที่ มันช้ากว่า ได้อย่างแน่นอน แต่ฉันควรสนใจ และคำถามไม่ได้เกี่ยวกับ ... ไม่เกี่ยวกับการเพิ่มประสิทธิภาพขนาดเล็กการปรับให้เหมาะสมก่อนวัยและอื่น ๆ มันไม่เกี่ยวกับ "เพิ่มประสิทธิภาพส่วนนี้หรือส่วนที่ตาย" ถ้าเช่นนั้นจะเป็นอะไร เป็นเรื่องเกี่ยวกับระเบียบวิธีและเทคนิคโดยรวมและวิธีคิดเกี่ยวกับการเขียนโค้ดที่เกิดขึ้นเมื่อเวลาผ่านไป: "ฉีดรหัสนี้ในชั้นเรียนของคุณเป็นการพึ่งพา" "เขียนหนึ่งไฟล์ต่อคลาส" "แยกมุมมองของคุณออกจากฐานข้อมูลตัวควบคุมโดเมน" อย่าเขียน codeblock สปาเก็ตตี้ที่เป็นเนื้อเดียวกัน แต่เขียนส่วนประกอบแยกส่วนจำนวนมากที่ทำงานร่วมกัน มันเกี่ยวกับวิธีการและรูปแบบของรหัสที่ปัจจุบัน - ภายในทศวรรษนี้ - เห็นและสนับสนุนในกรอบการทำงานส่วนใหญ่ที่สนับสนุนการประชุมส่งต่อผ่านชุมชน มันเป็นการเปลี่ยนความคิดจาก 'monolithic blocks' เป็น …

35 object-oriented  performance  refactoring  dependency-injection 

ฉันได้เรียนรู้การเขียนโปรแกรม OO เป็นหลักใน C ++, C # และ Java ฉันคิดว่าฉันมีความเข้าใจเป็นอย่างดีเกี่ยวกับความเข้าใจของฉันเกี่ยวกับการห่อหุ้มการสืบทอดและความหลากหลาย (รวมถึงการอ่านคำถามจำนวนมากบนไซต์นี้) สิ่งหนึ่งที่ดูเหมือนจะปรากฏขึ้นที่นี่และมีแนวคิดของ "การส่งข้อความ" เห็นได้ชัดว่านี่คือสิ่งที่ไม่ได้ใช้ในขณะที่การเขียนโปรแกรม OO ในภาษาหลักของวันนี้ แต่ได้รับการสนับสนุนโดย Smalltalk คำถามของฉันคือ: ข้อความผ่านคืออะไร (มีคนให้ตัวอย่างที่เป็นประโยชน์ได้หรือไม่) มีการสนับสนุน "ข้อความส่งผ่าน" นี้ใน C ++, C # หรือ Java หรือไม่

35 java  c#  c++  object-oriented 

ฉันสังเกตเห็นว่าใน PHP5 มีการเพิ่มส่วนต่อประสานกับภาษา อย่างไรก็ตามเนื่องจาก PHP ถูกพิมพ์อย่างหลวม ๆ ดูเหมือนว่าประโยชน์ส่วนใหญ่ของการใช้ส่วนต่อประสานจะหายไป ทำไมสิ่งนี้จึงรวมอยู่ในภาษา

35 php  object-oriented  interfaces  static-typing  duck-typing 

หมายเหตุ : คำถามนี้เป็นข้อความที่ตัดตอนมาจากการโพสต์บล็อกที่ฉันเขียนไม่กี่เดือนที่ผ่านมา หลังจากวางลิงค์ไปยังบล็อกในความคิดเห็นใน Programmers.SE มีคนขอให้ฉันโพสต์คำถามที่นี่เพื่อให้พวกเขาสามารถตอบได้ การโพสต์นี้เป็นที่นิยมมากที่สุดของฉันเป็นคนที่ดูเหมือนจะพิมพ์ "ฉันไม่ได้รับการเขียนโปรแกรมเชิงวัตถุ" ใน Google มาก รู้สึกอิสระที่จะตอบที่นี่หรือในความคิดเห็นที่ Wordpress การเขียนโปรแกรมเชิงวัตถุคืออะไร? ไม่มีใครให้คำตอบที่น่าพอใจแก่ฉัน ฉันรู้สึกว่าคุณจะไม่ได้รับคำนิยามที่ดีจากคนที่พูดว่า "วัตถุ" และ "เชิงวัตถุ" ด้วยจมูกของเขาในอากาศ คุณจะไม่ได้รับคำจำกัดความที่ดีจากคนที่ไม่ได้ทำอะไรนอกจากการเขียนโปรแกรมเชิงวัตถุ ไม่มีใครเข้าใจทั้งขั้นตอนและการเขียนโปรแกรมเชิงวัตถุทำให้ฉันมีความคิดที่สอดคล้องกับสิ่งที่โปรแกรมเชิงวัตถุทำ มีใครช่วยเล่าความเห็นเกี่ยวกับข้อดีของการเขียนโปรแกรมเชิงวัตถุได้ไหม

35 object-oriented 

ฉันเพิ่งเริ่มดูการพัฒนา Android สิ่งนี้นำฉันกลับสู่โลกของการพัฒนาซอฟต์แวร์ Java ครั้งสุดท้ายที่ฉันทำงานกับ Java ฉันจะยอมรับว่าฉันไม่เข้าใจ OOP เท่าที่ฉันคิดตอนนี้ หลังจากใช้งาน C # เป็นส่วนใหญ่ในอาชีพของฉันฉันสังเกตเห็นความแตกต่างที่น่าตกใจในการใช้ Java และ C # ในการสืบทอด ใน C # ดูเหมือนว่าสามารถหลีกเลี่ยงการสืบทอดในสถานการณ์ส่วนใหญ่ งานในมือสามารถทำได้โดยใช้คลาสที่เป็นรูปธรรมของ. NET Framework ใน Java จากสิ่งที่ฉันรวบรวมจากตัวอย่างโค้ดดูเหมือนว่า Java framework จะให้ส่วนต่อประสานหรือคลาสนามธรรมที่มีความหมายที่จะนำไปใช้ / ขยายโดยนักพัฒนา ดูเหมือนว่าจะมีความแตกต่างใหญ่เกินไปที่จะทำให้สไตล์ อะไรคือเหตุผลเบื้องหลังสิ่งนี้ ฉันรู้สึกว่าฉันจะไม่เขียนโค้ด Java ที่สะอาดจนกว่าฉันจะเข้าใจสิ่งนี้ นอกจากนี้ยังมีข้อ จำกัด เพียงแค่ Android SDK หรือนี่เป็นแนวทางแบบกว้าง ๆ ของ OOP หรือไม่? หรือใส่ในอีกทางหนึ่ง มันเกี่ยวกับการออกแบบของสองภาษานี้ที่ดูเหมือนว่าจะส่งเสริมให้ใช้มรดกมากกว่าหรือน้อยกว่าอีก? …

34 java  c#  object-oriented  language-design  inheritance 

ฉันได้รับอิทธิพลอย่างมากจากหนังสือ Java ที่มีประสิทธิภาพของ Joshua Bloch (ฉบับที่ 2) ซึ่งอาจจะมากกว่าหนังสือโปรแกรมที่ฉันอ่าน โดยเฉพาะรูปแบบตัวสร้างของเขา (รายการ 2) มีผลมากที่สุด แม้ผู้สร้างของ Bloch จะช่วยให้ฉันออกไปไกลกว่าเดิมในช่วงสองเดือนกว่าในช่วงสิบปีที่ผ่านมาของการเขียนโปรแกรม แต่ฉันก็ยังพบว่าตัวเองกำลังชนกำแพงเดียวกัน: การขยายชั้นเรียนด้วยโซ่ตรวนวิธีการกลับมาด้วยตนเอง - โดยเฉพาะอย่างยิ่งเมื่อ generics เข้ามาเล่นและโดยเฉพาะอย่างยิ่งกับgenerics อ้างอิงตนเอง (เช่นComparable<T extends Comparable<T>>) มีความต้องการหลักสองประการที่ฉันมีอยู่เพียงข้อที่สองที่ฉันต้องการเน้นในคำถามนี้: ปัญหาแรกคือ "วิธีการแบ่งปันวิธีการส่งกลับโซ่ตนเองโดยไม่ต้องใช้พวกเขาในทุก ... เดียว ... ชั้น?" สำหรับผู้ที่อาจจะอยากรู้อยากเห็นฉันได้กล่าวถึงส่วนนี้ที่ด้านล่างของคำตอบโพสต์นี้ แต่ไม่ใช่สิ่งที่ฉันต้องการมุ่งเน้นที่นี่ ปัญหาที่สองที่ฉันขอความคิดเห็นคือ "ฉันจะสร้างตัวสร้างในชั้นเรียนที่มีความตั้งใจที่จะขยายโดยชั้นเรียนอื่น ๆ อีกมากมายได้อย่างไร" การขยายชั้นเรียนด้วยตัวสร้างนั้นเป็นเรื่องยากกว่าการขยายชั้นเรียนแบบไม่มี การขยายชั้นเรียนที่มีการสร้างเป็นที่ยังดำเนินการNeedableและดังนั้นจึงมียาชื่อสามัญสำคัญที่เกี่ยวข้องกับมันเป็นเทอะทะ นั่นคือคำถามของฉัน: ฉันจะปรับปรุง (สิ่งที่ฉันเรียกว่า) ตัวสร้าง Bloch ได้อย่างไรฉันจึงสามารถแนบตัวสร้างกับคลาสใดก็ได้ - แม้ว่าคลาสนั้นจะมีความหมายว่า "คลาสพื้นฐาน" ที่อาจเป็น …

34 java  design  design-patterns  object-oriented 

ฉันกำลังสร้างเว็บไซต์เดิมของ PHP OOP ฉันถูกล่อลวงให้เริ่มใช้ 'ขั้นสุดท้าย' ในชั้นเรียนถึง " make it explicit that the class is currently not extended by anything" สิ่งนี้อาจช่วยประหยัดเวลาได้มากถ้าฉันมาเรียนและฉันสงสัยว่าฉันสามารถเปลี่ยนชื่อ / ลบ / แก้ไขprotectedคุณสมบัติหรือวิธีการได้หรือไม่ ถ้าฉันจริงๆต้องการที่จะขยายชั้นเรียนฉันก็สามารถลบคำหลักสุดท้ายที่จะปลดล็อคสำหรับการขยาย คือถ้าฉันมาในชั้นเรียนที่ไม่มีชั้นเรียนเด็กฉันสามารถบันทึกความรู้นั้นโดยการทำเครื่องหมายชั้นเรียนเป็นที่สิ้นสุด ครั้งต่อไปที่ฉันเข้ามาฉันจะไม่ต้องค้นหา codebase อีกครั้งเพื่อดูว่ามีลูกหรือไม่ จึงช่วยประหยัดเวลาในระหว่างการรีแฟคเตอร์ ทุกอย่างดูเหมือนจะเป็นแนวคิดที่ช่วยประหยัดเวลาได้ แต่ .... ฉันมักจะอ่านว่าคลาสควรจะทำ 'ขั้นสุดท้าย' ในโอกาสที่หายาก / พิเศษเท่านั้น บางทีมันอาจทำให้เกิดการสร้างวัตถุจำลองหรือมีผลข้างเคียงอื่น ๆ ที่ฉันไม่ได้คิด ฉันพลาดอะไรไป

34 php  object-oriented  final 

ฉันรู้อย่างเต็มที่ว่าpylintและเครื่องมือวิเคราะห์แบบคงที่อื่น ๆ ไม่ได้รู้ทั้งหมดและบางครั้งคำแนะนำของพวกเขาจะต้องไม่เชื่อฟัง (ใช้กับคลาสข้อความที่หลากหลายไม่ใช่แค่conventions) ถ้าฉันมีชั้นเรียนเช่น class related_methods(): def a_method(self): self.stack.function(self.my_var) class more_methods(): def b_method(self): self.otherfunc() class implement_methods(related_methods, more_methods): def __init__(self): self.stack = some() self.my_var = other() def otherfunc(self): self.a_method() เห็นได้ชัดว่ามีการวางแผน นี่เป็นตัวอย่างที่ดีกว่าหากคุณต้องการ ฉันเชื่อว่าสไตล์นี้เรียกว่าใช้ "มิกซ์" เช่นเดียวกับเครื่องมืออื่น ๆpylintอัตรารหัสนี้ที่-21.67 / 10ส่วนใหญ่เพราะมันคิดmore_methodsและrelated_methodsไม่ได้มีselfหรือแอตทริบิวต์otherfunc, stack, annd my_varเพราะโดยไม่ต้องใช้รหัสที่มันเห็นได้ชัดว่าไม่สามารถดูrelated_methodsและมีผสมในmore_methodsimplement_methods คอมไพเลอร์และเครื่องมือวิเคราะห์แบบสแตติกไม่สามารถแก้ปัญหาการหยุดนิ่งได้เสมอไปแต่ฉันรู้สึกว่านี่เป็นกรณีที่มองว่าสิ่งที่สืบทอดมาimplement_methodsจะแสดงให้เห็นว่าสิ่งนี้เป็นสิ่งที่ถูกต้องสมบูรณ์และนั่นก็เป็นเรื่องง่ายมาก ทำไมเครื่องมือวิเคราะห์แบบคงที่ปฏิเสธรูปแบบ OOP ที่ถูกต้อง (ฉันคิดว่า) ทั้ง: พวกเขาไม่แม้แต่จะลองตรวจสอบการสืบทอดหรือ มิกซ์อินถูกทำให้หมดกำลังใจใน Python ซึ่งเป็นสำนวนที่อ่านง่าย …

34 object-oriented  python  inheritance  python-3.x  mixins 

ในแผนภาพคลาสแต่ละคลาสมีเมธอดและคุณลักษณะ คำที่ถูกต้องในการอธิบายทั้งสองคำนั้นนอกเหนือจากสิ่งทั่วไปเช่นเนื้อหาหรือรายการอะไร บริบท: ชั้นสีส้มขยายชั้นผลไม้และสืบทอดสิ่งต่างๆ โดยที่stuff = คำเดียวสำหรับทั้งเมธอดและแอตทริบิวต์

33 object-oriented  wording 

หากคุณมีเพื่อนร่วมงานที่ไม่เข้าใจประโยชน์ของการแยกข้อกังวลหรือไม่เข้าใจเพียงพอที่จะนำไปใช้อย่างสม่ำเสมอในการทำงานประจำวันของพวกเขาคุณจะอธิบายให้พวกเขาฟังอย่างไร

33 code-quality  object-oriented 

ตัวอย่างเช่นฉันเคยเห็นรหัสบางอย่างที่สร้างชิ้นส่วนเช่นนี้: Fragment myFragment=new MyFragment(); ซึ่งประกาศตัวแปรเป็นชิ้นส่วนแทน MyFragment ซึ่ง MyFragment เป็นคลาสย่อยของ Fragment ฉันไม่พอใจรหัสบรรทัดนี้เพราะฉันคิดว่ารหัสนี้ควรเป็น: MyFragment myFragment=new MyFragment(); ข้อไหนเจาะจงกว่ากันจริงหรือ? หรือโดยทั่วไปของคำถามเป็นการใช้งานไม่ถูกต้อง: Parent x=new Child(); แทน Child x=new Child(); หากเราสามารถเปลี่ยนคนที่เคยเป็นคนหลังได้โดยไม่ผิดพลาด

32 object-oriented  coding-style  refactoring  inheritance 

ฉันกำลังทำงานบนระบบที่มีผู้ใช้และผู้ใช้แต่ละคนมีหนึ่งหรือหลายบทบาท เป็นวิธีปฏิบัติที่ดีที่จะใช้ค่า List of Enum กับผู้ใช้หรือไม่ ฉันไม่สามารถคิดอะไรได้ดีไปกว่านี้ แต่มันก็ไม่เป็นไร enum Role{ Admin = 1, User = 2, } class User{ ... List<Role> Roles {get;set;} }

32 design-patterns  object-oriented 

ฉันเข้าใจแรงจูงใจที่อยู่เบื้องหลังหลักการของความรู้น้อยที่สุดแต่ฉันพบข้อเสียบางอย่างถ้าฉันพยายามนำไปใช้ในการออกแบบของฉัน หนึ่งในตัวอย่างของหลักการนี้ (จริง ๆ แล้วว่าจะไม่ใช้) ซึ่งฉันพบในหนังสือรูปแบบการออกแบบหัวแรกระบุว่ามันผิดที่จะเรียกวิธีการบนวัตถุที่ถูกส่งกลับจากการเรียกวิธีการอื่น ๆ ในแง่ของหลักการนี้ . แต่ดูเหมือนว่าบางครั้งจำเป็นต้องใช้ความสามารถนี้มาก ตัวอย่างเช่น: ฉันมีหลายคลาส: คลาสการจับภาพวิดีโอ, คลาสตัวเข้ารหัส, คลาสสตรีมและพวกเขาทั้งหมดใช้คลาสพื้นฐานอื่น ๆ , VideoFrame และเนื่องจากพวกเขามีปฏิสัมพันธ์กันพวกเขาสามารถทำสิ่งนี้ได้: streamer รหัสชั้นเรียน ... frame = encoder->WaitEncoderFrame() frame->DoOrGetSomething(); .... อย่างที่คุณเห็นหลักการนี้ไม่ได้ถูกนำไปใช้ที่นี่ สามารถนำหลักการนี้ไปใช้ที่นี่หรือว่าหลักการนี้ไม่สามารถนำไปใช้ในการออกแบบเช่นนี้ได้หรือไม่?

32 object-oriented 

ฉันกำลังเขียนโปรแกรมในJavaในรูปแบบ object-oriented (OO) OOP มาถึงฉันอย่างสังหรณ์ใจ แต่ฉันมีความรู้น้อยมากเกี่ยวกับการเขียนโปรแกรมชนิดอื่น การเขียนโปรแกรมเชิงขั้นตอนคืออะไร? มันแตกต่างจาก OOP อย่างไร? มันเป็นสิ่งเดียวกับการเขียนโปรแกรมฟังก์ชั่น ? ฉันเคยคิดว่าการเขียนโปรแกรมทั้งหมดที่ไม่ใช่ OO นั้นเป็นขั้นตอน แต่ฉันเริ่มคิดว่ามันไม่เป็นความจริง

32 object-oriented  procedural 

ในการเขียนโปรแกรมสิ่งที่เรียกว่า Principle of Least ประหลาดใจ? แนวคิดนี้เกี่ยวข้องกับการออกแบบ API ที่ดีอย่างไร สิ่งนี้ใช้ได้กับการเขียนโปรแกรมเชิงวัตถุเท่านั้นหรือมันซึมซาบเทคนิคการเขียนโปรแกรมอื่น ๆ ด้วยหรือไม่ สิ่งนี้เกี่ยวข้องกับหลักการ "ทำสิ่งเดียวในวิธีการของคุณและทำได้ดีหรือไม่"?

32 design  design-patterns  object-oriented