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

Optionalsสวิฟท์มี C # มีNullableประเภท เท่าที่ฉันสามารถบอกได้ทั้งวัตถุประสงค์เดียวกันนอกจากค่าของบางประเภทพวกเขาเก็บข้อมูลว่าตัวแปรมีค่าหรือไม่ได้กำหนด (ไม่เตรียม) คำถามเป็นOptionalsเพียงNullableประเภทที่มีชื่อแตกต่างกันหรือมีความแตกต่างทางแนวคิดอื่น ๆ กล่าวอีกนัยหนึ่งคือการพูดคุยเกี่ยวกับแนวคิดของตนเองหรือในบริบทของภาษาที่ไม่มีOptionalsหรือNullablesมันมีความสำคัญต่อการใช้คำศัพท์หรือไม่? เมื่อใช้งานฟังก์ชั่นนั้นในภาษามันไม่สำคัญว่าฉันจะพิมพ์ชื่อOptionals<T>หรือNullable<T>

15 object-oriented  programming-languages  terminology 

นี่คือสิ่งที่ฉันหมายถึง: class MyClass { int arr1[100]; int arr2[100]; int len = 100; void add(int* x1, int* x2, int size) { for (int i = 0; i < size; i++) { x1[i] += x2[i]; } } }; int main() { MyClass myInstance; // Fill the arrays... myInstance.add(myInstance.arr1, myInstance.arr2, myInstance.len); } addสามารถเข้าถึงตัวแปรทั้งหมดที่ต้องการได้แล้วเนื่องจากเป็นวิธีการเรียนดังนั้นนี่เป็นความคิดที่ไม่ดีหรือไม่? …

14 object-oriented  c++  class-design  methods  encapsulation 

เมื่อคุณใช้แนวคิดของความหลากหลายที่คุณสร้างลำดับชั้นของชั้นเรียนและใช้การอ้างอิงผู้ปกครองที่คุณเรียกใช้ฟังก์ชั่นอินเทอร์เฟซโดยไม่ทราบว่าชนิดที่เฉพาะเจาะจงมีวัตถุ มันเยี่ยมมาก ตัวอย่าง: คุณมีคอลเลคชั่นสัตว์และเรียกร้องให้สัตว์ทุกตัวทำงานeatและคุณไม่สนใจว่ามันจะกินสุนัขหรือแมว แต่ในลำดับชั้นเดียวกับที่คุณมีสัตว์ที่มีเพิ่มเติม - อื่น ๆ กว่าสืบทอดและดำเนินการจากชั้นเรียนAnimalเช่นmakeEggs, getBackFromTheFreezedStateและอื่น ๆ ดังนั้นในบางกรณีในการทำงานของคุณคุณอาจต้องการทราบประเภทเฉพาะเพื่อเรียกใช้พฤติกรรมเพิ่มเติม ยกตัวอย่างเช่นในกรณีที่มันเป็นช่วงเวลาเช้าและถ้ามันเป็นเพียงสัตว์แล้วคุณเรียกeatมิฉะนั้นถ้ามันเป็นมนุษย์แล้วโทรครั้งแรกwashHands, และเพียงแล้วโทรgetDressed eatวิธีจัดการกรณีนี้? ความแตกต่างตาย คุณจำเป็นต้องค้นหาประเภทของวัตถุซึ่งฟังดูมีกลิ่นรหัส มีวิธีการทั่วไปในการจัดการกรณีนี้หรือไม่?

14 design-patterns  object-oriented  polymorphism  subtypes 

ฉันเพิ่งเริ่มต้นกับRxJavaการใช้ReactiveXของ Java (หรือที่เรียกว่าRxและReactive Extensions ) สิ่งที่ทำให้ฉันหลงไหลจริงๆคือขนาดที่ใหญ่ของคลาสFlowableของ RxJava : มันมี 460 วิธี! เพื่อความเป็นธรรม: มีวิธีการมากมายที่มากเกินไปซึ่งกระแทกจำนวนวิธีทั้งหมดอย่างมีนัยสำคัญ บางทีคลาสนี้ควรจะถูกทำลาย แต่ความรู้และความเข้าใจของฉันเกี่ยวกับ RxJava มี จำกัด มาก คนที่สร้าง RxJava นั้นฉลาดมากและพวกเขาสามารถเสนอข้อโต้แย้งที่ถูกต้องในการเลือกสร้างFlowableด้วยวิธีการมากมาย ในทางกลับกัน: RxJava เป็นการใช้งาน Java ของส่วนขยายรีแอกทีฟของMicrosoftและนั่นไม่ได้มีคลาสFlowableดังนั้นนี่ไม่ใช่กรณีของการย้ายคลาสที่มีอยู่แบบสุ่มและนำไปใช้ใน Java [ อัปเดต:จุดก่อนหน้าในตัวเอียงไม่ถูกต้องตามจริง: คลาสObservableของ Microsoft ซึ่งมีมากกว่า 400 วิธีใช้เป็นพื้นฐานสำหรับคลาสObservableของ RxJava และFlowableนั้นคล้ายกับObservableแต่จัดการ backpressure สำหรับข้อมูลจำนวนมาก ดังนั้นทีม RxJava จึงย้ายคลาสที่มีอยู่ โพสต์นี้น่าจะท้าทายการออกแบบเดิมของคลาสObservableโดย Microsoft มากกว่าคลาสFlowableของ RxJava ] RxJava อายุน้อยกว่า 3 …

14 java  object-oriented  class-design  solid  reactive 

อะไรคือแนวทางทั่วไปหรือกฎง่ายๆสำหรับเมื่อใช้วัตถุโดเมน speciifc เทียบกับสตริงหรือหมายเลขธรรมดา? ตัวอย่าง: อายุกับจำนวนเต็ม? ชั้น FirstName vs String? UniqueID vs String หมายเลขโทรศัพท์กับสตริงเทียบกับ Long หรือไม่ DomainName คลาส vs String? ฉันคิดว่าผู้ปฏิบัติงาน OOP ส่วนใหญ่จะพูดคลาสที่เฉพาะเจาะจงสำหรับ PhoneNumber และ DomainName กฎเพิ่มเติมเกี่ยวกับสิ่งที่ทำให้พวกเขาถูกต้องและวิธีการเปรียบเทียบทำให้ชั้นเรียนง่าย ๆ ง่ายขึ้นและปลอดภัยยิ่งขึ้นที่จะจัดการกับ แต่สำหรับสามคนแรกนั้นมีการถกเถียงกันมากขึ้น ฉันไม่เคยเจอคลาส "อายุ" แต่เราสามารถโต้แย้งได้ว่ามันสมเหตุสมผลเพราะมันต้องไม่ใช่ลบ (โอเคฉันรู้ว่าคุณสามารถโต้เถียงสำหรับวัยลบได้ แต่มันเป็นตัวอย่างที่ดีที่เกือบเทียบเท่ากับจำนวนเต็มดั้งเดิม) สตริงเป็นเรื่องปกติที่จะแสดง "ชื่อ" แต่มันไม่สมบูรณ์เพราะสตริงที่ว่างเปล่าเป็นสตริงที่ถูกต้อง แต่ไม่ใช่ชื่อที่ถูกต้อง การเปรียบเทียบมักจะทำโดยไม่สนใจขนาดตัวพิมพ์ แน่นอนว่ามีวิธีการตรวจสอบความว่างเปล่าทำการเปรียบเทียบแบบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ แต่จำเป็นต้องให้ผู้บริโภคทำเช่นนี้ คำตอบนั้นขึ้นอยู่กับสภาพแวดล้อมหรือไม่? ฉันเกี่ยวข้องกับซอฟต์แวร์องค์กร / ซอฟต์แวร์มูลค่าสูงที่จะมีชีวิตอยู่และได้รับการดูแลรักษาเป็นเวลานานกว่าทศวรรษ บางทีฉันอาจจะคิดมากเรื่องนี้ แต่ฉันอยากจะรู้ว่าถ้าใครมีกฎเกณฑ์ว่าเมื่อใดควรเลือกคลาสเทียบกับแบบดั้งเดิม

14 java  c#  object-oriented  domain-driven-design  domain-objects 

ฉันใช้รหัส (รหัสใหม่) ที่ใช้สิ่งที่ฉันเรียกว่า 'อาร์เรย์แบบขนาน' หรือรายการ ความหมายมี 2 อาร์เรย์ที่มีข้อมูลที่เกี่ยวข้องและเชื่อมโยงโดยตำแหน่ง (ดัชนี) ในอาร์เรย์ ฉันพิจารณาถึงความสับสนและมีแนวโน้มที่จะเกิดข้อผิดพลาดทุกประเภท วิธีแก้ปัญหาที่ฉันเสนอตามปกติคือการสร้างวัตถุที่เรียกว่าCompanyมีฟิลด์ CompanyId และ CompanyName ตัวอย่างจริงมาก: List<string> companyNames; List<int> companyIds; //...They get populated somewhere and we then process for(var i=0; i<companyNames.Count; i++) { UpdateCompanyName(companyIds[i],companyNames[i]); } อาร์เรย์แบบขนานเหล่านี้มีการพิจารณาว่าไม่เหมาะสมหรือไม่

14 object-oriented  programming-practices  code-smell 

ฉันยังคิดว่าตัวเองเป็นโปรแกรมเมอร์ฝึกงานดังนั้นฉันมักจะมองหาวิธีที่ "ดีกว่า" สำหรับการเขียนโปรแกรมทั่วไป วันนี้เพื่อนร่วมงานของฉันแย้งว่าสไตล์การเขียนรหัสของฉันทำงานได้โดยไม่จำเป็นและฉันต้องการฟังความคิดเห็นจากผู้อื่น โดยทั่วไปเมื่อฉันออกแบบคลาสในภาษา OOP (โดยทั่วไปคือ C ++ หรือ Python) ฉันจะแยกการกำหนดค่าเริ่มต้นออกเป็นสองส่วน: class MyClass1 { public: Myclass1(type1 arg1, type2 arg2, type3 arg3); initMyClass1(); private: type1 param1; type2 param2; type3 param3; type4 anotherParam1; }; // Only the direct assignments from the input arguments are done in the constructor MyClass1::myClass1(type1 arg1, type2 …

14 design  object-oriented  coding-style 

ตัวอย่างเช่นสมมติว่าคุณมีโปรแกรมเกมคอนโซลซึ่งมีวิธีอินพุต / เอาต์พุตทุกชนิดเข้าและออกจากคอนโซล มันจะเป็นสมาร์ทเพื่อให้พวกเขาทั้งหมดในครั้งเดียวinputOutputชั้นเรียนหรือทำลายพวกเขาลงไปเรียนที่เฉพาะเจาะจงมากขึ้นเช่นstartMenuIO, inGameIO, playerIO, gameBoardIOฯลฯ ดังกล่าวว่าแต่ละชั้นจะมีประมาณ 1-5 วิธี? และเมื่อทราบเหมือนกันถ้ามันจะดีกว่าที่จะทำลายพวกเขาลงมันจะเป็นสมาร์ทที่จะวางไว้ในIOnamespace จึงทำให้เรียกพวกเขาเล็ก ๆ น้อย ๆ มากขึ้นอย่างละเอียดเช่น: IO.inGameฯลฯ ?

14 design-patterns  object-oriented  class-design  solid  single-responsibility 

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

14 object-oriented  programming-languages 

ฉันมีคลาสต่อไปนี้ class Student{ int rollNumber; int marks; public void setResult(int rollNumber, int marks){ this.rollNumber=rollNumber; this.marks=marks; } public void displayResult(){ System.out.println("Roll Number= "+this.rollNumber+" Marks= "+this.marks); } } ตอนนี้ฉันสร้างวัตถุสองประเภทที่เป็นนักเรียนดังนี้ Student s1=new Student(); Student s2=new Student(); ตอนนี้มีการจัดสรรหน่วยความจำสองชุดที่แตกต่างกันสำหรับฟิลด์อินสแตนซ์ ตอนนี้คำถามของฉันคือการจัดสรรหน่วยความจำสำหรับวิธีการ ( setResultและdisplayResult) สองครั้งหรือหนึ่งครั้ง? โปรดดูรูปต่อไปนี้และคุณสามารถช่วยฉันบอกว่ารูปใดให้ข้อมูลที่ถูกต้อง

14 java  object-oriented  memory  jvm 

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

14 object-oriented  case-studies 

ฉันเข้าใจเจตนาของหลักการแบบเปิด มันหมายถึงการลดความเสี่ยงของการทำลายบางสิ่งบางอย่างที่ใช้งานได้แล้วในขณะที่แก้ไขโดยบอกให้คุณพยายามขยายโดยไม่ต้องแก้ไข อย่างไรก็ตามฉันมีปัญหาในการทำความเข้าใจวิธีการใช้หลักการนี้ในทางปฏิบัติ เพื่อความเข้าใจของฉันมีสองวิธีในการใช้มัน ก่อนและหลังการเปลี่ยนแปลงที่เป็นไปได้: ก่อน: โปรแกรมไปยัง abstractions และ 'ทำนายอนาคต' มากที่สุดเท่าที่จะทำได้ ตัวอย่างเช่นวิธีการdrive(Car car)จะต้องเปลี่ยนหาก Motorcycleมีการเพิ่ม s ในระบบในอนาคตดังนั้นจึงอาจละเมิด OCP แต่วิธีdrive(MotorVehicle vehicle)นี้มีแนวโน้มที่จะไม่เปลี่ยนแปลงในอนาคตดังนั้นจึงเป็นไปตาม OCP อย่างไรก็ตามมันค่อนข้างยากที่จะทำนายอนาคตและรู้ล่วงหน้าว่าการเปลี่ยนแปลงใดที่จะเกิดขึ้นกับระบบ หลังจาก: เมื่อต้องการการเปลี่ยนแปลงให้ขยายคลาสแทนการแก้ไขเป็นรหัสปัจจุบัน แบบฝึก # 1 ไม่ยากที่จะเข้าใจ อย่างไรก็ตามมันเป็นข้อปฏิบัติที่ 2 ที่ฉันมีปัญหาในการทำความเข้าใจวิธีการสมัคร ยกตัวอย่างเช่น (ฉันเอามันจากวิดีโอบน YouTube): ขอบอกว่าเรามีวิธีการในระดับที่ยอมรับได้วัตถุ:CreditCard makePayment(CraditCard card)หนึ่งวันVoucherจะถูกเพิ่มเข้าไปในระบบ วิธีนี้ไม่รองรับพวกมันดังนั้นจึงต้องมีการแก้ไข เมื่อนำวิธีการนี้ไปใช้ในตอนแรกเราไม่สามารถคาดการณ์อนาคตและโปรแกรมในแง่นามธรรมได้มากขึ้น (เช่นmakePayment(Payment pay)ดังนั้นตอนนี้เราต้องเปลี่ยนรหัสที่มีอยู่ แบบฝึกหัดที่ 2 กล่าวว่าเราควรเพิ่มฟังก์ชันการทำงานโดยขยายแทนการปรับเปลี่ยน นั่นหมายความว่าอย่างไร? ฉันควรคลาสย่อยคลาสที่มีอยู่แทนที่เพียงแค่เปลี่ยนเป็นรหัสเดิมหรือไม่ ฉันควรทำเสื้อคลุมบางอย่างเพื่อหลีกเลี่ยงการเขียนรหัสใหม่หรือไม่? หรือหลักการไม่ได้อ้างถึง 'วิธีการแก้ไข / เพิ่มฟังก์ชันการทำงานที่ถูกต้อง' …

14 design  object-oriented  object-oriented-design  solid 

สมมติว่าฉันกำลังพัฒนาเว็บแอปพลิเคชัน ตัวเลือกแรกของฉันคือใช้ PHP กับ Fat-Free Framework (F3) และรูปแบบ MVC ปีหน้าฉันอาจตัดสินใจว่าอยากเปลี่ยนเป็น Zend Framework หรืออาจเป็น ASP.NET MVC ก็ได้ มันสมเหตุสมผลหรือไม่ที่จะลองและออกแบบแอปพลิเคชันของฉันในลักษณะที่มันเชื่อมโยงกับกรอบอย่างหลวม ๆ หรือเป็นกรอบที่สำคัญเกินไปที่จะทำให้สิ่งนี้เป็นจริงหรือไม่? เหตุผลเดียวที่ฉันถามคือเพราะมันเกิดขึ้นในการสนทนากับเพียร์เมื่อเร็ว ๆ นี้ที่วิพากษ์วิจารณ์พายของฉันในความคิดที่ท้องฟ้าของการมีเพศสัมพันธ์อย่างหลวม ๆ ใบสมัครของฉันเพื่อ F3

14 design-patterns  object-oriented  frameworks 

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

14 object-oriented  interview  database  web-applications  database-design 

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

14 object-oriented  coding-style