Java แต่ละบรรทัดมีจำนวนบรรทัดเท่าใด [ปิด]

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

เพื่อความชัดเจนฉันรู้ว่าจำนวนบรรทัดไม่ได้ใกล้เคียงกับมาตรฐานจริงเพื่อใช้สำหรับสิ่งที่ควรอยู่ในชั้นเรียนเฉพาะและสิ่งที่ไม่ควร คลาสควรได้รับการออกแบบให้สอดคล้องกับปรัชญา OOP (การห่อหุ้ม ฯลฯ ) ที่เหมาะสม ที่กล่าวว่ากฎง่ายๆสามารถให้เป็นจุดเริ่มต้นที่มีประโยชน์สำหรับการพิจารณาการรีแฟคเจอริ่ง (เช่น "อืมชั้นนี้มีบรรทัดของรหัส> n มันอาจไม่สามารถอ่านได้และทำงานของการห่อหุ้มด้วยหมัด ถูก refactored ในบางจุด ")

ในทางกลับกันคุณอาจพบตัวอย่างของคลาสที่มีขนาดใหญ่มากที่ยังคงเชื่อฟังการออกแบบ OOP ได้ดีและอ่านได้และบำรุงรักษาได้แม้จะมีความยาวอยู่หรือไม่

นี่คือที่เกี่ยวข้องที่ไม่ซ้ำกันคำถามเกี่ยวกับเส้นต่อฟังก์ชั่น

ตัวชี้วัดที่น่าสนใจ:

            Junit fitnesse testNG เมื่อ jdepend ant tomcat
            ----- -------- ------ --- ------- --- ------
สูงสุด 500 498 1450 355 668 2168 5457
หมายถึง 64.0 77.6 62.7 95.3 128.8 215.9 261.6
ต่ำสุด 4 6 4 10 20 3 12
sigma 75 76 110 78 129 261 369
ไฟล์ 90 632 1152 69 55 954 1468
บรรทัดทั้งหมด 5756 49063 72273 6575 7085 206001 384026

ฉันใช้ FitNesse เป็นเกณฑ์มาตรฐานเพราะฉันมีส่วนเกี่ยวข้องกับการเขียน ใน FitNesse คลาสเฉลี่ยมีความยาว 77 บรรทัด ไม่มีความยาวเกิน 498 บรรทัด และค่าเบี่ยงเบนมาตรฐานคือ 76 เส้น นั่นหมายความว่าชั้นเรียนส่วนใหญ่น้อยกว่า 150 บรรทัด แม้แต่ Tomcat ที่มีหนึ่งคลาสเกินกว่า 5,000 บรรทัดมีคลาสส่วนใหญ่น้อยกว่า 500 บรรทัด

รับนี้เราอาจใช้ 200 บรรทัดเป็นแนวทางที่ดีที่จะอยู่ด้านล่าง

สำหรับฉันบรรทัดของรหัสไม่เกี่ยวข้องในบริบทนี้ ทุกอย่างเกี่ยวกับจำนวนของเหตุผลที่แตกต่างกันฉันจะมาที่ชั้นนี้เพื่อเปลี่ยน

ถ้าฉันมาที่ชั้นนี้เมื่อฉันต้องการเปลี่ยนกฎสำหรับการตรวจสอบความถูกต้องของบุคคลฉันไม่ต้องการมาที่ชั้นเรียนเดียวกันเพื่อเปลี่ยนกฎสำหรับการตรวจสอบความถูกต้องของคำสั่งซื้อและฉันไม่ต้องการมาที่นี่เพื่อเปลี่ยนตำแหน่งที่ฉัน สานต่อบุคคล

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

ฉันขอโทษ แต่ฉันประหลาดใจมากที่คำตอบมากมายระบุว่า "ไม่สำคัญ" มันสำคัญมากว่ามีกี่บรรทัดในชั้นเรียน ทำไม? พิจารณาหลักการเหล่านี้ในการเขียนโค้ด Java ที่ดี ...

• การตรวจสอบได้
• การติดต่อกัน
• การแต่งงานกัน
• สามารถทำความเข้าใจได้

คลาสที่มีบรรทัดจำนวนมากในนั้นจะละเมิดหลักการเหล่านั้นทั้งหมด

สำหรับคนที่พูดว่า "ไม่สำคัญจริงๆ" ... คุณสนุกขนาดไหนที่ลองและทำความเข้าใจกับคลาสที่มี 5,000 บรรทัดขึ้นไป หรือจะแก้ไขมัน? ถ้าคุณบอกว่าสนุกคุณมีความสัมพันธ์ที่แปลกประหลาดต่อความเจ็บปวด ...

ฉันจะบอกว่าคลาสใดที่มีมากกว่า 1,000 บรรทัดในนั้นอย่างน้อยก็ควรถูกสอบสวนว่าพวกเขาอาจละเมิดหลักการข้างต้นและแยกวิเคราะห์ออกเป็นคลาส "off-shot" หลายคลาสได้อย่างไร

ความคิดเห็นของฉันมีพื้นฐานมาจากการอ่านและการศึกษาผู้แต่งเช่น Martin Fowler, Joshua Bloch และ Misko Hevery พวกเขาเป็นแหล่งข้อมูลที่ยอดเยี่ยมในการให้คำปรึกษาสำหรับการเขียนโค้ด Java ที่ดี

ทำคนต่อไป (ซึ่งอาจเป็นคุณในอีกไม่กี่ปีข้างหน้า) เป็นที่โปรดปรานและพยายามเขียนชั้นเรียนที่มีจำนวนบรรทัดน้อยกว่าพวกเขา

ขึ้นอยู่กับความซับซ้อนไม่ใช่จำนวนบรรทัด ฉันได้เขียนกิจวัตรโง่ขนาดใหญ่ที่เข้าใจง่ายและทำสิ่งใดสิ่งหนึ่งได้อย่างแม่นยำและทำได้ดี แต่ทำไปหลายร้อยบรรทัด ฉันได้เขียนฟังก์ชั่นที่ค่อนข้างสั้นซึ่งยากที่จะเข้าใจ (และดีบัก)

อีกสิ่งที่คุณสามารถดูได้คือจำนวนฟังก์ชั่นสาธารณะในชั้นเรียน นั่นอาจเป็นสัญญาณเตือน

ฉันไม่มีการนับที่ดี แต่ฉันขอแนะนำให้ดูรหัสที่เหมาะสมที่ทำสิ่งที่มีประโยชน์ที่ร้านของคุณและจากนั้น แน่นอนคุณควรดูคลาสที่ยาวที่สุดและ API ที่ใหญ่ที่สุด

มีบรรทัดของรหัสมากเกินไปถ้าคลาสทำสิ่งต่าง ๆ มากเกินไป โดยพื้นฐานแล้วถ้าคุณทำตามหลักการของ Single Responsibility สำหรับคลาสมีข้อ จำกัด ว่าคลาสจะเติบโตขนาดใหญ่ได้อย่างไร

ในฐานะที่เป็นข้อ จำกัด ทางกายภาพที่คุณสามารถมี (ที่มา: ชั้นรูปแบบไฟล์ Java5 ):

• ค่าคงที่, การเชื่อมต่อที่ใช้, เขตข้อมูล, วิธีการและคุณลักษณะ 65,536 รายการ หมายเหตุ: คุณจะทำงานออกจากพื้นที่อย่างต่อเนื่องก่อนที่คุณจะวิ่งออกมาจากใด ๆของรายการอื่น ๆ หมายเหตุ 2: แอททริบิวต์เป็นคลาสไฟล์ที่สร้างขึ้น - เพื่อไม่ให้สับสนกับเครื่องหมาย '@Attribute' (เช่นข้อมูลการดีบักและรหัสไบต์จะถูกเก็บไว้เป็นแอตทริบิวต์แยกต่างหากสำหรับวิธีการ)
• แต่ละวิธีสามารถสร้างรหัสไบต์ได้ขนาด 4GB (32 bits) หมายเหตุ: Java เวอร์ชันก่อนหน้า 1.5 สามารถมี 64KB (16 บิต) ของรหัสไบต์ที่สร้างขึ้นสำหรับแต่ละวิธี

กล่าวโดยย่อไฟล์คลาสอาจมีขนาดใหญ่กว่าใครก็ตามที่คิดว่ามีประโยชน์ ถ้าคุณยึดหลักการความรับผิดชอบเดียวไฟล์คลาสของคุณจะมีขนาดที่เหมาะสม

คำตอบที่ถูกต้องคือ 42 เพียงแค่ล้อเล่น
ที่จริงแล้วบรรทัดสูงสุดที่แนะนำต่อคลาสคือ2,000บรรทัด

"Java Code Conventions" ตั้งแต่ปี 1999 ได้ระบุไว้ด้วยวิธีนี้:
ไฟล์ที่ยาวกว่า 2,000 บรรทัดนั้นยุ่งยากและควรหลีกเลี่ยง

หลังจากปฏิบัติตามอนุสัญญาการเข้ารหัสของ Sun / Oracle ตั้งแต่ Java ถูกคิดค้นขึ้นมาฉันพบกฎข้อนี้ในบรรทัดต่อคลาสว่าสมเหตุสมผล 99% ของรหัส Java ของคุณควรเป็นไปตาม ... และถ้าเกิน 2000 ให้ใส่สิ่งที่ต้องทำที่ด้านบนว่าชั้นเรียนต้องการการทำงาน

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

http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-141855.html#3043

รหัสสะอาด:

ชั้นเรียนควรเล็ก!

กฎข้อแรกของชั้นเรียนคือพวกเขาควรมีขนาดเล็ก กฎของการเรียนที่สองคือพวกเขาควรจะเล็กกว่านั้น ไม่เราจะไม่ทำซ้ำข้อความเดิมจากบทฟังก์ชั่น แต่เช่นเดียวกับฟังก์ชั่นขนาดเล็กเป็นกฎหลักเมื่อมันมาถึงการออกแบบชั้นเรียน เช่นเดียวกับฟังก์ชั่นคำถามทันทีของเราคือ“ เล็กแค่ไหน”

** ด้วยฟังก์ชั่นที่เราวัดขนาดโดยการนับเส้นทางกายภาพ ด้วยคลาสที่เราใช้การวัดที่แตกต่างกัน เรานับความรับผิดชอบ **

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

แล้ว:

• เพียงให้แน่ใจว่าวิธีการของคุณทำสิ่งเดียวเท่านั้น
• จากนั้นตรวจสอบให้แน่ใจว่าชั้นเรียนไม่มีความรับผิดชอบมากเกินไป

คุณจะจบลงด้วยคลาสที่มีขนาดที่จัดการได้

จำนวนบรรทัดเป็นตัวชี้วัดที่ไม่ดีนักสำหรับคุณภาพของชั้นเรียน สำหรับฉันฉันชอบที่จะดู (ตามที่คนอื่น ๆ ได้พูดถึง) ในที่สาธารณะเช่นเดียวกับคุณสมบัติสาธารณะใด ๆ ที่เปิดเผยต่อสาธารณะ (ฉันเดาสาธารณะ getters / setters ใน Java) ถ้าฉันต้องดึงตัวเลขออกมาจากอากาศเมื่อมันอาจจะดึงดูดความสนใจของฉันฉันจะบอกว่าเมื่อมีมากกว่า 10 แห่ง จริง ๆ ถ้ามันมากกว่า 5 ของคุณสมบัติหรือวิธีการอย่างใดอย่างหนึ่งฉันจะดูและมักจะหาวิธีที่จะ refactor แต่สิ่งที่มากกว่า 10 มักจะเป็นสัญญาณเตือนว่าสิ่งที่ค่อนข้างน่าจะสัมผัสได้ไม่ดี

เป็นการสนทนาอื่นทั้งหมด แต่วิธีการส่วนตัวและฟิลด์มีกลิ่นน้อยสำหรับฉันดังนั้นหากพวกเขามีส่วนร่วมมากในจำนวนบรรทัดแล้วฉันอาจไม่กังวล อย่างน้อยที่สุดก็แสดงให้เห็นว่าอาจมีบางคนที่พระเจ้าไม่ควบคุมวัตถุจากระยะไกลซึ่งเป็นปัญหาการออกแบบปัญหาสวย

ลองใช้การวัดที่ดีขึ้น

ตัวอย่างหนึ่งคือเอบีซีเมตริก มันเป็นตัวชี้วัดจำนวนของการทำงานโดยรหัสมากกว่าจำนวนรหัสที่มี

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