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

ฉันผ่านหลักสูตรการเขียนโปรแกรมเกมมาตลอด นี่ไม่ใช่ระดับวิทยาศาสตร์คอมพิวเตอร์ดังนั้นทฤษฎีจำนวนมากจึงหลีกเลี่ยงการสร้างพอร์ตโฟลิโอที่ใช้งานได้จริงและสิ่งที่ฉันเห็นว่าเป็นการเรียนรู้ของ JIT ซึ่งเห็นได้ชัดว่ามีความสำคัญมากกว่าในอุตสาหกรรมเกม หัวข้อแรกคือ "ความรู้เบื้องต้นเกี่ยวกับการเขียนโปรแกรมเชิงวัตถุ" วลีนั้นไม่ได้รบกวนฉันจนกว่าฉันจะได้เรียนรู้เกี่ยวกับกระบวนทัศน์การเขียนโปรแกรมที่แตกต่างกัน (ฉันได้รับรายการนี้จากhttps://en.wikipedia.org/wiki/Comparison_of_programming_paradigms ): ความจำเป็น การทำงาน ขั้นตอน โครงสร้าง เหตุการณ์ที่ขับเคลื่อนด้วย เชิงวัตถุ ที่เปิดเผย ออ-Based ฉันเข้าใจว่านี่ไม่ใช่รายการที่ละเอียดถี่ถ้วนและแนวคิดเหล่านี้ทั้งหมดไม่เท่ากันและส่วนใหญ่ไม่ได้ จำกัด เฉพาะ แต่ฉันไม่เข้าใจว่าทำไมพวกเขาส่วนใหญ่จึงได้คำเพียงคำเดียว การทำงาน; ที่เปิดเผย - แต่เมื่อเราพูดถึงการเขียนโปรแกรมกับวัตถุเราต้องชี้แจงว่าเรามุ่งเน้นไปที่วัตถุเหล่านั้น เราใช้วัตถุไม่ได้เหรอ? เราไม่สามารถมีสิ่งของได้หรือ ทำไมพวกเขาต้องปรับทิศทางเราในฐานะดาวนำทางของเรา? ดูที่นี่ ( https://en.wikipedia.org/wiki/Object-oriented_programming ) ไม่มีการใช้คำว่า "เชิง" ที่ระบุเป็นคำของตนเอง อธิบายเฉพาะ "วัตถุ" นอกจากนี้ฉันสามารถดูเหตุผลเชิงปฏิบัติว่าทำไมจึงใช้ Event-Driven เพราะการเขียนโปรแกรมกิจกรรมเป็นสิ่งที่คุณทำเมื่อคุณกำลังประชุมอยู่และโปรแกรม Automata ทำให้ดูเหมือนว่าคุณกำลังตั้งสายการผลิตหุ่นยนต์ ดังนั้นช่วยให้มีคำที่ชัดเจนเพิ่มเติมที่นั่น อะไรทำให้การเขียนโปรแกรมวัตถุเป็นวลีไม่เพียงพอที่จะอธิบายสิ่งที่เราทำเมื่อเราใช้วัตถุในการเขียนโปรแกรมของเรา เห็นได้ชัดจากน้ำเสียงของฉันฉันไม่ชอบคำว่า "เชิง" เกินไป มันทำให้ฉันนึกถึงเวลาของฉันในฐานะนักข่าวศาลฟังทนายหลังจากที่ทนายความใช้วลี "ที่เกี่ยวข้องกับ" เป็นเห็บวาจา …

14 object-oriented  terminology  history  grammar 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังว่าคำตอบจะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้อาจเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา บางครั้งฉันสร้างคลาส 'Util' ซึ่งส่วนใหญ่ใช้เพื่อเก็บวิธีการและค่านิยมที่ไม่ได้อยู่ในที่อื่น แต่ทุกครั้งที่ฉันสร้างหนึ่งในชั้นเรียนเหล่านี้ฉันคิดว่า "เอ่อ - โอ้ฉันจะเสียใจในภายหลัง ... " เพราะฉันอ่านที่ไหนสักแห่งที่มันไม่ดี แต่ในทางกลับกันดูเหมือนจะมีสองกรณี (อย่างน้อยสำหรับฉัน) ที่น่าสนใจสำหรับพวกเขา: ความลับการนำไปใช้งานที่ใช้ในหลายคลาสภายในแพ็กเกจ นำเสนอฟังก์ชั่นที่มีประโยชน์เพื่อเพิ่มคลาสโดยไม่ทำให้หน้าจอของคุณยุ่ง ฉันกำลังจะไปสู่ความพินาศหรือไม่? คุณพูดอะไร !! ฉันควร refactor หรือไม่

14 design  object-oriented  code-smell 

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

14 java  object-oriented 

แรงบันดาลใจจากคำตอบนี้ : หลักการทดแทน Liskov ต้องการ สิ่งนั้น เงื่อนไขเบื้องต้นไม่สามารถเสริมความแข็งแกร่งในประเภทย่อย Postconditions ไม่สามารถลดลงในประเภทย่อย ค่าคงที่ของซูเปอร์ไทป์จะต้องเก็บรักษาไว้ในประเภทย่อย ข้อ จำกัด ประวัติ ("กฎประวัติศาสตร์") วัตถุนั้นได้รับการยกย่องว่าสามารถปรับเปลี่ยนได้ด้วยวิธีการของพวกเขาเท่านั้น (encapsulation) เนื่องจากชนิดย่อยอาจแนะนำวิธีการที่ไม่ปรากฏใน supertype การแนะนำวิธีการเหล่านี้อาจอนุญาตให้มีการเปลี่ยนแปลงสถานะในชนิดย่อยที่ไม่อนุญาตใน supertype ข้อ จำกัด ประวัติห้ามสิ่งนี้ ฉันหวังว่าถ้ามีคนจะโพสต์ลำดับชั้นของชั้นเรียนที่ละเมิด 4 คะแนนและจะแก้ไขได้อย่างไร ฉันกำลังมองหาคำอธิบายอย่างละเอียดเพื่อจุดประสงค์ด้านการศึกษาเกี่ยวกับวิธีระบุแต่ละจุดในลำดับชั้นและวิธีที่ดีที่สุดในการแก้ไข หมายเหตุ: ฉันหวังว่าจะโพสต์ตัวอย่างโค้ดเพื่อให้คนทำงาน แต่คำถามนั้นเกี่ยวกับวิธีระบุลำดับชั้นผิดพลาด :)

14 object-oriented  inheritance  solid  design-principles  liskov-substitution 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว ฉันทำงานให้กับ บริษัท ขนาดกลางที่มีนักพัฒนาประมาณ 250 คน น่าเสียดายที่หลายคนติดอยู่ในกระบวนการคิดและบางทีมส่งมอบแอปพลิเคชันสคริปต์ธุรกรรมขนาดใหญ่อย่างต่อเนื่องซึ่งในความเป็นจริงแล้วแอปพลิเคชันมีตรรกะมากมาย พวกเขายังไม่สามารถจัดการการพึ่งพาการออกแบบและจบลงด้วยบริการที่ขึ้นอยู่กับบริการจำนวนมากอีกตัวอย่าง (ตัวอย่างที่ชัดเจนของBig Ball of Mud ) คำถามของฉันคือคุณสามารถแนะนำวิธีกระจายความรู้ประเภทนี้ได้อย่างไร ฉันรู้ว่าพื้นผิวของปัญหาคือแอปพลิเคชันเหล่านี้มีสถาปัตยกรรมและการออกแบบที่ไม่ดี อีกปัญหาคือมีนักพัฒนาบางคนที่ต่อต้านการเขียนการทดสอบใด ๆ บางสิ่งที่ฉันทำเพื่อเปลี่ยนแปลงสิ่งนี้ (แต่ฉันล้มเหลวหรือการเปลี่ยนแปลงเล็กเกินไป) ใช้งานนำเสนอเกี่ยวกับหลักการออกแบบ (SOLID, clean code, ฯลฯ ) การประชุมเชิงปฏิบัติการเกี่ยวกับ TDD และ BDD ทีมการฝึกสอน (ซึ่งรวมถึงการใช้โซนาร์, findbugs, jdepend และเครื่องมืออื่น ๆ ) การพูดถึง IDE & Refactoring …

14 design  learning  object-oriented  architecture 

ฉันมีชั้นเรียนขนาดใหญ่ที่มีโค้ดมากกว่า 2K บรรทัด (และเพิ่มขึ้นเรื่อย ๆ ) ที่ฉันอยากจะสร้างใหม่หากเป็นไปได้เพื่อให้มีการออกแบบที่เบาและสะอาดมากขึ้น เหตุผลที่มันใหญ่มากส่วนใหญ่เป็นเพราะคลาสเหล่านี้จัดการกับชุดของแผนที่ที่วิธีการส่วนใหญ่จำเป็นต้องเข้าถึงและวิธีการเชื่อมต่อกันมาก ฉันจะยกตัวอย่างชัดเจน: ฉันมีคลาสที่เรียกServerว่าจัดการข้อความขาเข้า มันมีวิธีการเช่นjoinChatroom, searchUsers, sendPrivateMessageและอื่น ๆ ทั้งหมดของวิธีการเหล่านี้จัดการแผนที่เช่นusers, chatrooms, servers... บางทีมันอาจจะดีถ้าฉันมีข้อความการจัดการเรียนที่เกี่ยวข้องกับห้องสนทนาการจัดการกับผู้ใช้อื่น ๆ แต่ปัญหาหลักที่นี่คือฉันต้องใช้แผนที่ทั้งหมดในวิธีการส่วนใหญ่ นั่นเป็นเหตุผลที่ตอนนี้พวกเขาทั้งหมดติดอยู่ในServerชั้นเรียนเพราะพวกเขาทั้งหมดพึ่งพาแผนที่ทั่วไปเหล่านี้และวิธีการเชื่อมต่อซึ่งกันและกัน ฉันจะต้องสร้างห้องเรียนแชท แต่มีการอ้างอิงถึงวัตถุอื่น ๆ ผู้ใช้คลาสอีกครั้งโดยอ้างอิงถึงวัตถุอื่นทั้งหมดเป็นต้น ฉันรู้สึกว่าฉันจะทำอะไรผิด

14 java  object-oriented  design-patterns  design 

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

14 object-oriented  algorithms  performance 

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

14 object-oriented  design-patterns  coding 

ฉันต้องออกแบบลำดับชั้นของชั้นเรียนสำหรับโครงการ C # ของฉัน โดยพื้นฐานแล้วฟังก์ชันของคลาสนั้นคล้ายกับคลาสของ WinForms ดังนั้นให้ลองใช้ชุดเครื่องมือ WinForms เป็นตัวอย่าง (อย่างไรก็ตามฉันไม่สามารถใช้ WinForms หรือ WPF ได้) มีคุณสมบัติและฟังก์ชั่นหลักบางอย่างที่ทุกชั้นต้องการ ขนาดตำแหน่งสีการมองเห็น (จริง / เท็จ) วิธีการวาด ฯลฯ ฉันต้องการคำแนะนำด้านการออกแบบฉันใช้การออกแบบที่มีคลาสเบสและอินเทอร์เฟซที่เป็นนามธรรมซึ่งไม่ใช่ประเภทจริง ๆ แต่ชอบพฤติกรรมมากกว่า นี่เป็นการออกแบบที่ดีหรือไม่? ถ้าไม่สิ่งที่จะเป็นการออกแบบที่ดีกว่า รหัสมีลักษณะดังนี้: abstract class Control { public int Width { get; set; } public int Height { get; set; } public int BackColor { get; …

14 c#  object-oriented  design-patterns  class-design 

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

14 c++  object-oriented  inheritance  access-modifiers 

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

14 object-oriented 

เรามักจะใช้ c ++ structs เพื่อกำหนดโครงสร้างข้อมูลเมื่อเทียบกับคลาสซึ่งสามารถเป็นโมดูลที่สมบูรณ์พร้อมเมธอดสมาชิก ตอนนี้ลึกลงไปเรารู้ว่าพวกเขาทั้งสองเหมือนกัน (พูดอย่างหลวม ๆ ) ความจริงที่ว่าเรามักจะใช้ / รักษา structs เป็นข้อมูลหน่วยงานเท่านั้นสร้างความอยากนี้ที่เราไม่ได้เพิ่มตัวสร้างเริ่มต้นเช่นกัน แต่คอนสตรัคเตอร์นั้นยอดเยี่ยมอยู่เสมอพวกเขาทำให้สิ่งต่าง ๆ ง่ายขึ้นและช่วยกำจัดข้อผิดพลาด มันจะขมวดคิ้วถ้าเพิ่มตัวสร้างเริ่มต้นให้กับโครงสร้างข้อมูลของฉัน? การใช้Constructor ที่เป็นค่าเริ่มต้นยังทำให้โครงสร้าง Non-POD (ชนิดข้อมูลเก่าแบบเดิม) จัดทำตามเกณฑ์อื่น ๆ เพื่อให้สิ่งต่าง ๆ ในมุมมองพิจารณาตัวอย่างง่าย ๆ แต่ในความเป็นจริง struct จะใหญ่กว่ามาก struct method { char name[32]; float temperature; int duration; }; ทุกครั้งที่ฉันสร้างวิธีการฉันต้องกังวลเกี่ยวกับ (พูดน้อยที่สุด) ถ้าฉันลืมตั้งค่าบางอย่าง ลองนึกภาพฉันลืมที่จะตั้งค่าtemperatureและใช้วิธีการกับระบบซึ่งตอนนี้เป็นค่าสูงแบบสุ่มและทำให้เกิดการทำร้ายร่างกาย หรือฉันลืมที่จะตั้งค่าdurationและตอนนี้วิธีการใช้ตัวเองสำหรับช่วงเวลาสูงที่ไม่รู้จัก ทำไมฉันต้องรับผิดชอบในการเริ่มต้นวัตถุทุกครั้งแทนที่จะใช้ตัวสร้างซึ่งรับประกันได้หรือไม่

14 c++  object-oriented  programming-practices 

ฉันขาดการออกแบบเชิงวัตถุและเชิงเวกเตอร์ ฉันชอบความสามารถโครงสร้างและความปลอดภัยที่วัตถุมอบให้กับสถาปัตยกรรมทั้งหมด แต่ในขณะเดียวกันความเร็วนั้นสำคัญมากสำหรับฉันและการมีตัวแปรลอยแบบง่าย ๆ ในอาเรย์ช่วยในภาษา / ไลบรารีที่ใช้เวกเตอร์เช่น Matlab หรือ numpy ใน Python นี่คือส่วนหนึ่งของรหัสที่ฉันเขียนเพื่ออธิบายจุดของฉัน ปัญหา: การเพิ่มหมายเลขความผันผวนของ Tow หาก x และ y เป็นสองตัวเลขความผันผวนผลรวมของความผันผวนคือ (x ^ 2 + y ^ 2) ^ 0.5 (สมมติว่ามีเงื่อนไขทางคณิตศาสตร์บางอย่าง แต่นั่นไม่ใช่สิ่งสำคัญที่นี่) ฉันต้องการดำเนินการนี้อย่างรวดเร็วและในเวลาเดียวกันฉันต้องแน่ใจว่าผู้คนไม่เพียงเพิ่มความผันผวนในทางที่ผิด (x + y) ทั้งสองอย่างนี้มีความสำคัญ การออกแบบตาม OO จะเป็นดังนี้: from datetime import datetime from pandas import * class Volatility: …

14 design-patterns  object-oriented  python  speed 

เมื่อพัฒนาใน OOP บางครั้งจะมีการกำหนดอินเทอร์เฟซ / สัญญาโดยห้องสมุดที่คุณไม่สามารถเปลี่ยนแปลงได้ มาเรียกอินเตอร์เฟสนี้ว่า J ตอนนี้คุณมีออบเจ็กต์คลาส A ที่ใช้วัตถุที่ใช้อินเทอร์เฟซนี้ ข้างในจำเป็นต้องมีข้อกำหนดของอินเตอร์เฟสเพียงเล็กน้อย ฉันสร้างคลาสวัตถุบางอย่างในระหว่างโครงการ (ลองเรียกหนึ่งในประเภท D) ดังนั้นจึงมีค่าใช้จ่ายในการดำเนินการทุกอย่างภายในส่วนติดต่อ J ฉันต้องการใช้ฟังก์ชั่นย่อยในอินเตอร์เฟส J แต่โซลูชันของฉันยังไม่เป็นที่พอใจ: การนำทุกแง่มุมของ J ไปใช้แล้วโยน "notImplementedExceptions" ให้ผู้ใช้วัตถุของฉันเข้าใจผิด: ดูเหมือนว่าวัตถุประเภท D ของฉันจะสอดคล้องกับส่วนต่อประสาน J แต่พวกเขาทำไม่ได้ - และผู้บริโภควัตถุอื่นของฉัน J) ไม่สามารถพึ่งพาความสมบูรณ์ของวัตถุของฉัน การใช้อินเทอร์เฟซที่กำหนดใหม่ห้ามไม่ให้ฉันใช้วัตถุที่ใช้เฉพาะอินเตอร์เฟส J แม้ว่าอินเตอร์เฟส J จะเข้ากันได้กับส่วนต่อประสานของฉันเอง การปล่อยให้วัตถุที่กำหนดเองของฉันใช้อินเตอร์เฟส J จะสร้างค่าใช้จ่ายที่สำคัญเพราะพวกเขาไม่ต้องการฟังก์ชันทั้งหมดนี้ เมื่อฉันสามารถเปลี่ยนอินเตอร์เฟส J ได้ฉันจะสร้าง "super-interface" K ที่มีชุดย่อยของฟังก์ชัน J interface นี้และทำให้ …

14 object-oriented  interfaces 

ฉันกำลังเขียนการทดสอบหน่วย JUnit สำหรับชั้นเรียนของฉัน มันจะดีกว่าถ้ามีคลาสแยกสำหรับแต่ละวิธีหรือมีคลาสทดสอบเพียงหนึ่งสำหรับทุกคลาสจริง

14 java  object-oriented  unit-testing  testing  junit