ใน Java ฉันควรใช้ "final" สำหรับพารามิเตอร์และ locals แม้ว่าฉันไม่จำเป็นต้อง?

Java อนุญาตให้ทำเครื่องหมายตัวแปร (ฟิลด์ / โลแคล / พารามิเตอร์) เป็นfinalเพื่อป้องกันการกำหนดใหม่ ฉันพบว่ามันมีประโยชน์มากกับฟิลด์เนื่องจากมันช่วยให้ฉันดูได้อย่างรวดเร็วว่าคุณลักษณะบางอย่างหรือทั้งคลาสนั้นมีจุดมุ่งหมายที่ไม่เปลี่ยนรูป

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

ไม่มั่นใจเกี่ยวกับรูปแบบการเขียนโปรแกรมของฉันอีกต่อไปฉันสงสัยว่าอะไรคือข้อดีและข้อเสียอื่น ๆ ของการใช้finalที่ใดก็ได้ลักษณะอุตสาหกรรมที่พบบ่อยที่สุดคืออะไรและเพราะเหตุใด

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

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

ยิ่งกว่านั้นอย่างที่คุณรู้finalไม่รับประกันว่าคุณจะไม่สามารถเปลี่ยนค่า / สถานะของตัวแปร (ไม่แปร) ได้ มีเพียงคุณเท่านั้นที่ไม่สามารถมอบหมายการอ้างอิงไปยังวัตถุนั้นอีกครั้งเมื่อเริ่มต้นแล้ว กล่าวอีกนัยหนึ่งมันทำงานได้อย่างราบรื่นเฉพาะกับตัวแปรประเภทดั้งเดิมหรือไม่เปลี่ยนรูป พิจารณา

final String s = "forever";
final int i = 1;
final Map<String, Integer> m = new HashMap<String, Integer>();

s = "never"; // compilation error!
i++; // compilation error!
m.put(s, i); // fine

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

สไตล์และความคิดในการเขียนโปรแกรม Java ของคุณนั้นดี - ไม่ต้องสงสัยเลยว่ามี

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

นี่คือเหตุผลที่คุณควรใช้finalคำหลัก คุณระบุว่าคุณรู้ว่ามันจะไม่ถูกกำหนดใหม่ แต่ไม่มีใครรู้ว่า ใช้finaldisambiguates รหัสของคุณทันทีที่น้อยมาก

ข้อดีอย่างหนึ่งของการใช้final/ constทุกที่ที่เป็นไปได้คือมันช่วยลดภาระทางจิตสำหรับผู้อ่านรหัสของคุณ

เขาสามารถมั่นใจได้ว่าค่า / การอ้างอิงจะไม่เปลี่ยนแปลงในภายหลัง ดังนั้นเขาไม่จำเป็นต้องใส่ใจกับการดัดแปลงเพื่อทำความเข้าใจกับการคำนวณ

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

ฉันพิจารณาfinalในพารามิเตอร์เมธอดและตัวแปรโลคัลเพื่อเป็นจุดรบกวนของโค้ด การประกาศเมธอด Java สามารถค่อนข้างยาว (โดยเฉพาะกับ generics) - ไม่จำเป็นต้องทำให้อีกต่อไป

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

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

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

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

โดยไม่ต้องfinal:

public void doSomething(String input) {
    input = input.toLowerCase();
    // do a few things with input
}

ง่าย สะอาด ทุกคนรู้ว่าเกิดอะไรขึ้น

ตอนนี้ด้วย 'final' ตัวเลือก 1:

public void doSomething(final String input) {
    final String lowercaseInput = input.toLowerCase();
    // do a few things with lowercaseInput
}

ในขณะที่การทำให้พารามิเตอร์finalหยุด coder การเพิ่มรหัสเพิ่มเติมจากที่คิดว่าเขากำลังทำงานกับค่าเดิมมีความเสี่ยงที่เท่าเทียมกันที่รหัสต่อไปอาจใช้inputแทนlowercaseInputซึ่งไม่ควรและที่ไม่สามารถป้องกันเพราะคุณสามารถ ' ไม่นำออกจากขอบเขต (หรือแม้กระทั่งมอบหมายnullให้inputหากสิ่งนั้นจะช่วยได้อยู่ดี)

ด้วย 'final' ตัวเลือก 2:

public void doSomething(final String input) {
    // do a few things with input.toLowerCase()
}

ตอนนี้เราเพิ่งสร้างรหัสเสียงให้มากขึ้นและนำเสนอประสิทธิภาพที่ยอดเยี่ยมในการเรียกใช้toLowerCase()n ครั้ง

ด้วย 'final' ตัวเลือก 3:

public void doSomething(final String input) {
    doSomethingPrivate(input.toLowerCase());
}

/** @throws IllegalArgumentException if input not all lower case */
private void doSomethingPrivate(final String input) {
    if (!input.equals(input.toLowerCase())) {
        throw new IllegalArgumentException("input not lowercase");
    }
    // do a few things with input
}

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

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

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

โปรดทราบว่าfinalในตอนแรกไม่ได้ปกป้องคุณอย่างที่คุณเห็น

public void foo(final Date date) {
    date.setTime(0); 
    // code that uses date
}

final ไม่ได้ป้องกันคุณอย่างสมบูรณ์เว้นแต่ประเภทพารามิเตอร์จะเป็นแบบดั้งเดิมหรือไม่เปลี่ยนรูป

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