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

ในภาษาเชิงวัตถุที่สนับสนุนพารามิเตอร์ประเภททั่วไป (เรียกอีกอย่างว่าคลาสเทมเพลตและตัวแปรหลายรูปแบบ แต่แน่นอนว่าชื่อแต่ละชื่อมีความหมายที่แตกต่างกัน) มันมักจะเป็นไปได้ที่จะระบุข้อ จำกัด ประเภทในพารามิเตอร์ประเภทเช่นนั้น จากประเภทอื่น ตัวอย่างเช่นนี่คือไวยากรณ์ใน C #: //for classes: class ExampleClass<T> where T : I1 { } //for methods: S ExampleMethod<S>(S value) where S : I2 { ... } อะไรคือเหตุผลที่ใช้ประเภทอินเตอร์เฟสจริงมากกว่าชนิดที่ จำกัด โดยอินเตอร์เฟสเหล่านั้น ตัวอย่างเช่นอะไรคือเหตุผลในการสร้างวิธีการเซ็นชื่อI2 ExampleMethod(I2 value)?

15 object-oriented  type-systems  generics 

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

15 c++  object-oriented 

ฉันมีแผนที่ดังต่อไปนี้: Map<Double, List<SoundEvent>> soundEventCells = new HashMap<Double, List<SoundEvent>>(); นี้HashMapแมdoubleค่า (ซึ่งเป็นคะแนนในเวลา) เพื่อที่สอดคล้องกันSoundEvent'มือถือ': แต่ละเซลล์สามารถมีจำนวนSoundEvents นั่นเป็นสาเหตุที่มันถูกนำมาใช้เป็นList<SoundEvent>เพราะนั่นคือสิ่งที่มันเป็น เพื่อประโยชน์ในการอ่านรหัสได้ดีขึ้นฉันจึงคิดถึงการใช้คลาสภายในแบบคงที่ที่ง่ายมากเช่น: private static class SoundEventCell { private List<SoundEvent> soundEvents = new ArrayList<SoundEvent>(); public void addEvent(SoundEvent event){ soundEvents.add(event); } public int getSize(){ return soundEvents.size(); } public SoundEvent getEvent(int index){ return soundEvents.get(index); } // .. remove() method unneeded } …

15 java  design  object-oriented 

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

15 design-patterns  object-oriented  functions 

ลองนึกภาพลูกค้าของคุณต้องการที่จะมีความเป็นไปได้ที่จะเพิ่มคุณสมบัติใหม่ (เช่นสี) ให้กับผลิตภัณฑ์ใน eshop ของพวกเขาใน CMS ของพวกเขา แทนที่จะมีคุณสมบัติเป็นฟิลด์: class Car extends Product { protected String type; protected int seats; } คุณอาจจะทำสิ่งที่ชอบ: class Product { protected String productName; protected Map<String, Property> properties; } class Property { protected String name; protected String value; } นั่นคือการสร้างระบบประเภทของตัวเองอยู่ด้านบนของระบบที่มีอยู่ ฉันรู้สึกเช่นนี้อาจเห็นได้ว่าเป็นการสร้างโดเมนเฉพาะหรือไม่? วิธีนี้เป็นรูปแบบการออกแบบที่รู้จักหรือไม่? คุณจะแก้ปัญหาต่างกันหรือไม่? ฉันรู้ว่ามีภาษาที่ฉันสามารถเพิ่มเขตข้อมูลในรันไทม์ แต่สิ่งที่เกี่ยวกับฐานข้อมูล? คุณอยากจะเพิ่ม / …

15 design-patterns  object-oriented 

( สำหรับจุดประสงค์ของคำถามนี้เมื่อฉันพูดว่า 'ส่วนต่อประสาน' ฉันหมายถึงโครงสร้างของภาษาinterfaceและไม่ใช่ 'ส่วนต่อประสาน' ในแง่อื่น ๆ ของคำเช่นวิธีสาธารณะที่ชั้นเรียนเสนอโลกภายนอกเพื่อสื่อสารกับและ จัดการมัน. ) การมีเพศสัมพันธ์แบบหลวมสามารถทำได้โดยการมีวัตถุขึ้นอยู่กับสิ่งที่เป็นนามธรรมแทนประเภทคอนกรีต วิธีนี้ช่วยให้การแต่งงานกันแบบหลวม ๆ ด้วยเหตุผลหลักสองประการ: 1-นามธรรมมีแนวโน้มที่จะเปลี่ยนแปลงน้อยกว่าประเภทคอนกรีตซึ่งหมายความว่ารหัสที่ขึ้นต่อกันมีโอกาสน้อยที่จะแตก คอนกรีตที่แตกต่างกัน2ประเภทสามารถใช้งานได้ที่รันไทม์เพราะมันเหมาะสมกับสิ่งที่เป็นนามธรรม คอนกรีตชนิดใหม่สามารถเพิ่มได้ในภายหลังโดยไม่จำเป็นต้องแก้ไขรหัสที่มีอยู่เดิม ตัวอย่างเช่นพิจารณาชั้นCarและสอง subclasses และVolvoMazda หากรหัสของคุณขึ้นอยู่กับ a Carมันสามารถใช้ a Volvoหรือ a Mazdaในระหว่างรันไทม์ ในภายหลังในคลาสย่อยเพิ่มเติมสามารถเพิ่มได้โดยไม่จำเป็นต้องเปลี่ยนรหัสที่ต้องพึ่งพา นอกจากนี้Car- ซึ่งเป็นนามธรรม - มีโอกาสน้อยที่จะมีการเปลี่ยนแปลงกว่าหรือVolvo Mazdaโดยทั่วไปรถยนต์มักจะเหมือนกันมาระยะหนึ่งแล้ว แต่ Volvos และ Mazdas มีแนวโน้มที่จะเปลี่ยนไป I abstractions มีความเสถียรมากกว่าแบบคอนกรีต ทั้งหมดนี้เพื่อแสดงให้เห็นว่าฉันเข้าใจว่าข้อต่อหลวมคืออะไรและจะบรรลุผลได้อย่างไรโดยขึ้นอยู่กับนามธรรมและไม่ใช่ข้อสรุป (ถ้าฉันเขียนบางอย่างไม่ถูกต้องโปรดพูดอย่างนั้น) สิ่งที่ฉันไม่เข้าใจคือ: Abstractions สามารถเป็น superclasses หรืออินเทอร์เฟซ ถ้าเป็นเช่นนั้นเหตุใดอินเทอร์เฟซที่ได้รับการยกย่องโดยเฉพาะสำหรับความสามารถในการยอมให้มีเพศสัมพันธ์แบบหลวม? ฉันไม่เห็นความแตกต่างจากการใช้ซูเปอร์คลาส …

15 design  object-oriented  interfaces 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันกำลังเขียนโปรแกรมใน Java ในรูปแบบ OO มากด้วยตัวเอง ไม่เคยมีโอกาสได้ทำงานร่วมกับโปรแกรมเมอร์คนอื่น (ฉันยังไม่เป็นมืออาชีพอย่างน้อยก็) ฉันอยากถามว่า: การทำงานกับทีมในโครงการทำงานอย่างไรโดยเฉพาะอย่างยิ่งเมื่อทำงานกับโครงการ OO ภารกิจการแยกทำงานอย่างไร คุณพัฒนาสิ่งที่จะประสบความสำเร็จในการทำงานกับสิ่งที่โปรแกรมเมอร์อื่นพัฒนาได้อย่างไร โปรแกรมเมอร์สื่อสารอย่างไรและเมื่อไหร่? ขอบคุณ

15 object-oriented  teamwork 

โดเมนความรู้ของเราเกี่ยวข้องกับคนที่เดินข้ามแผ่นบันทึกความกดดันด้วยเท้าเปล่า เราทำการจดจำรูปภาพซึ่งส่งผลให้วัตถุของคลาส 'เท้า' หากเท้ามนุษย์ถูกจดจำในข้อมูลเซ็นเซอร์ มีการคำนวณหลายอย่างที่ต้องดำเนินการกับข้อมูลของเท้า ตอนนี้ API ตัวไหนจะดีกว่า: class Foot : public RecognizedObject { MaxPressureFrame getMaxPressureFrame(); FootAxis getFootAxis(); AnatomicalZones getAnatomicalZones(); // + similar getters for other calculations // ... } หรือ: class Foot : public RecognizedObject { virtual CalculationBase getCalculation(QString aName); // ... } ตอนนี้มีโปรและคอนแสตนท์จำนวนมากที่ฉันสามารถหาได้ แต่ฉันก็ไม่สามารถตัดสินใจได้ว่าอะไรคือสิ่งที่สำคัญที่สุด หมายเหตุนี่เป็นแอปพลิเคชั่นสำหรับผู้ใช้ไม่ใช่ไลบรารี่ซอฟต์แวร์ที่เราขาย คำแนะนำใด ๆ? โปรบางตัวสำหรับวิธีแรกอาจเป็น: …

15 design  c++  object-oriented  programming-practices  language-agnostic 

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

15 object-oriented  currying  method-chaining 

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

15 object-oriented  design-principles 

ได้รับแรงบันดาลใจจากคำถามนี้การใช้ห้องสมุดบุคคลที่สามใช้เสื้อคลุมเสมอหรือไม่ ฉันต้องการที่จะรู้ว่าสิ่งที่ผู้คนคิดว่าจริง ๆ แล้วเป็นห้องสมุดบุคคลที่สาม ตัวอย่างจาก PHP: หากฉันกำลังสร้างแอปพลิเคชันโดยใช้เฟรมเวิร์กของ Zend ฉันควรปฏิบัติต่อไลบรารีเฟรมเวิร์กของ Zend เป็นรหัสบุคคลที่สามหรือไม่ ตัวอย่างจาก C #: ถ้าฉันสร้างแอปพลิเคชันเดสก์ท็อปฉันควรปฏิบัติต่อคลาส. Net ทั้งหมดเป็นรหัสบุคคลที่สามหรือไม่ ตัวอย่างจาก Java: ฉันควรปฏิบัติต่อไลบรารีทั้งหมดใน JDK เป็นห้องสมุดบุคคลที่สามหรือไม่ บางคนบอกว่าถ้าห้องสมุดมีความเสถียรและจะไม่เปลี่ยนบ่อยๆก็ไม่จำเป็นต้องห่อ อย่างไรก็ตามฉันล้มเหลวในการดูว่าจะทดสอบคลาสที่ขึ้นอยู่กับรหัสบุคคลที่สามโดยไม่ต้องล้อม

15 programming-languages  design  object-oriented  unit-testing  terminology 

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

15 programming-languages  object-oriented  language-agnostic  abstraction 

ตามกฎข้อที่ 4 ของObject Calisthenics โดย Jeff Bay (RTF)ใน The ThoughtWorks Anthology ขอแนะนำว่าควร " ใช้คอลเลกชันชั้นหนึ่ง " กฎข้อที่ 4: คอลเลกชันชั้นหนึ่ง แอ็พพลิเคชันของกฎนี้ง่าย: คลาสใด ๆ ที่มีคอลเล็กชันควรไม่มีตัวแปรสมาชิกอื่น คอลเลกชันแต่ละรายการจะถูกห่อหุ้มในคลาสของตัวเองดังนั้นตอนนี้พฤติกรรมที่เกี่ยวข้องกับคอลเลกชันจะมีบ้าน คุณอาจพบว่าฟิลเตอร์กลายเป็นส่วนหนึ่งของคลาสใหม่นี้ นอกจากนี้คลาสใหม่ของคุณสามารถจัดการกิจกรรมต่างๆเช่นการเข้าร่วมกลุ่มสองกลุ่มด้วยกันหรือใช้กฎกับองค์ประกอบของกลุ่มแต่ละกลุ่ม สิ่งที่ฉันสามารถเข้าใจได้จากสิ่งนี้คือเราควรใช้คลาสแยกการรวบรวมคอลเลกชันและด้วยวิธีการเพิ่มลบแก้ไขข้อมูลของคอลเลกชันนั้น และเราต้องการสิ่งนี้เพื่อให้เราแน่ใจว่าประเภทข้อมูลใดที่จะเข้าสู่การรวบรวมและสิ่งที่ออกมา ในกรณีที่เราใช้การรวบรวมทั่วไป (ในภาษาที่ใช้ได้) เราจำเป็นต้องปฏิบัติตามกฎนี้หรือไม่? หากฉันขาดความสำคัญที่สำคัญโปรดชี้แจง

15 object-oriented  generics 

ในขณะที่พูดคุยเกี่ยวกับคำถามเกี่ยวกับฟังก์ชั่นเสมือนจริงบน Stack Overflow ฉันสงสัยว่ามีการตั้งชื่ออย่างเป็นทางการสำหรับฟังก์ชั่นเสมือนจริง (นามธรรม) และไม่ใช่บริสุทธิ์หรือไม่ ฉันใช้วิกิพีเดียเป็นประจำสำหรับข้อมูลของฉันซึ่งระบุว่าฟังก์ชั่นเสมือนที่บริสุทธิ์และไม่บริสุทธิ์เป็นคำทั่วไป น่าเสียดายที่บทความไม่ได้สำรองไว้พร้อมกับที่มาหรือข้อมูลอ้างอิง เพื่ออ้างอิงคำตอบของ Jon Skeet กับคำตอบของฉันว่าบริสุทธิ์และไม่บริสุทธิ์เป็นคำทั่วไปที่ใช้: @ สตีเว่น: อืม ... เป็นไปได้ แต่ข้าเคยเห็นมันในบริบทของซีพลัสพลัสมาก่อน ฉันสงสัยว่าทุกคนที่พูดถึงพวกเขาน่าจะมีพื้นหลังเป็น C ++ :) คำนี้มาจากภาษา C ++ หรือเป็นคำนิยามหรือนำไปใช้เป็นภาษาแรกและเป็นศัพท์ทางวิทยาศาสตร์ที่ 'เป็นทางการ' หรือไม่ UPDATE: Frank Shearar ให้ลิงก์ไปยังคำอธิบายของSIMULA 67 Common Base Language (1970) อย่างเป็นประโยชน์ ภาษานี้ดูเหมือนว่าจะเป็นภาษาแรกที่จะแนะนำคำหลัก OO เป็นระดับ , วัตถุและยังเสมือนเป็นแนวคิดที่เป็นทางการ มันไม่ได้กำหนดบริสุทธิ์ / ไม่ใช่บริสุทธิ์หรือนามธรรมแต่มันไม่สนับสนุนแนวคิด ใครเป็นคนกำหนด

15 object-oriented  terminology  naming  history 

เมื่อเร็ว ๆ นี้ระหว่างการตรวจสอบรหัสฉันพบรหัสซึ่งเขียนโดยเพื่อนร่วมงานคนใหม่ซึ่งมีลวดลายที่มีกลิ่น ฉันสงสัยว่าการตัดสินใจของเพื่อนร่วมงานขึ้นอยู่กับกฎที่เสนอโดยหนังสือ Clean Code ที่มีชื่อเสียง (และอาจเป็นโดยหนังสืออื่นที่คล้ายคลึงกันเช่นกัน) ฉันเข้าใจว่าตัวสร้างคลาสมีหน้าที่รับผิดชอบทั้งหมดในการสร้างวัตถุที่ถูกต้องและหน้าที่หลักของมันคือการกำหนดคุณสมบัติ (ส่วนตัว) ของวัตถุ มันอาจเกิดขึ้นได้ว่าอาจมีการตั้งค่าคุณสมบัติทางเลือกโดยวิธีการอื่นนอกเหนือจากตัวสร้างคลาส แต่สถานการณ์ดังกล่าวค่อนข้างหายาก (แม้ว่าจะไม่จำเป็นต้องผิดหากว่าส่วนที่เหลือของชั้นเรียนคำนึงถึงคุณสมบัติของทรัพย์สินนั้น) สิ่งนี้มีความสำคัญเนื่องจากช่วยให้มั่นใจได้ว่าวัตถุนั้นอยู่ในสถานะที่ถูกต้องเสมอ อย่างไรก็ตามในรหัสที่ฉันพบค่าคุณสมบัติส่วนใหญ่จริง ๆ แล้วถูกตั้งค่าโดยวิธีอื่นนอกเหนือจากตัวสร้าง ค่าที่เป็นผลมาจากการคำนวณถูกกำหนดให้กับคุณสมบัติที่จะใช้ในวิธีการส่วนตัวหลายวิธีตลอดทั้งชั้นเรียน ผู้เขียนดูเหมือนจะใช้คุณสมบัติคลาสราวกับว่าพวกเขาเป็นตัวแปรทั่วโลกที่ควรจะสามารถเข้าถึงได้ทั่วทั้งชั้นเรียนแทนที่จะเป็นพารามิเตอร์ของค่าเหล่านี้กับฟังก์ชั่นที่ต้องการพวกเขา นอกจากนี้วิธีการของชั้นเรียนควรจะเรียกว่าในลำดับที่เฉพาะเจาะจงเพราะชั้นเรียนจะไม่ทำอย่างอื่นมาก ฉันสงสัยว่ารหัสนี้ได้รับแรงบันดาลใจจากคำแนะนำเพื่อให้วิธีการสั้น (<= 5 บรรทัดของรหัส) เพื่อหลีกเลี่ยงรายการพารามิเตอร์ขนาดใหญ่ (พารามิเตอร์ <3) และตัวสร้างที่จะต้องไม่ทำงาน (เช่นการคำนวณบางประเภท ที่จำเป็นสำหรับความถูกต้องของวัตถุ) แน่นอนว่าตอนนี้ฉันสามารถสร้างรูปแบบนี้ได้หากฉันสามารถพิสูจน์ได้ว่าข้อผิดพลาดที่ไม่ได้กำหนดทุกประเภทอาจเกิดขึ้นเมื่อไม่ได้เรียกวิธีการตามลำดับที่เฉพาะเจาะจง อย่างไรก็ตามฉันคาดการณ์ว่าการตอบสนองต่อสิ่งนี้จะเพิ่มการตรวจสอบความถูกต้องซึ่งยืนยันว่าต้องตั้งค่าคุณสมบัติเมื่อมีการเรียกใช้เมธอดที่ต้องการคุณสมบัติเหล่านั้น อย่างไรก็ตามฉันอยากจะเสนอให้เปลี่ยนรหัสทั้งหมดเพื่อให้คลาสกลายเป็นสีน้ำเงินพิมพ์ไปยังวัตถุจริงแทนที่จะเป็นชุดของวิธีการที่ควรเรียกว่า (ขั้นตอน) ตามลำดับที่เฉพาะเจาะจง ฉันรู้สึกว่ารหัสที่ฉันพบมีกลิ่น ในความเป็นจริงฉันเชื่อว่ามีความแตกต่างค่อนข้างชัดเจนว่าเมื่อใดที่จะบันทึกค่าในคุณสมบัติคลาสและเมื่อนำไปใช้เป็นพารามิเตอร์สำหรับวิธีการที่แตกต่างกันในการใช้งาน - ฉันไม่เชื่อจริง ๆ ว่าพวกเขาสามารถเป็นทางเลือก . ฉันกำลังมองหาคำสำหรับความแตกต่างนี้

15 object-oriented  clean-code