คอฟฟี่เบรค #134. สิ่งที่ควรหลีกเลี่ยงเมื่อเขียนโค้ด Java วิธีการใช้คำสุดท้าย ในที่สุด และสรุปใน Java

สิ่งที่ควรหลีกเลี่ยงเมื่อเขียนโค้ด Java

ที่มา: สื่อ เราขอแจ้งให้คุณทราบถึงบทความที่แสดงข้อผิดพลาดทั่วไปที่นักพัฒนาทำเมื่อเขียนโค้ด Java

การใช้ Enum.values

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

public enum Fruits {
    APPLE, PEAR, ORANGE, BANANA;

    public static void main(String[] args) {
        System.out.println(Fruits.values());
        System.out.println(Fruits.values());
    }
}
// output
// [Lcom.test.Fruits;@7ad041f3
// [Lcom.test.Fruits;@251a69d7

มีวัตถุสองชิ้นแยกกันในหน่วยความจำที่นี่ ดังนั้นจึงอาจดูเหมือนไม่ใช่เรื่องใหญ่ แต่ถ้าคุณใช้Fruit.values()เมื่อประมวลผลคำขอและมีภาระงานสูง สิ่งนี้อาจทำให้เกิดปัญหาหน่วยความจำได้ คุณสามารถแก้ไขได้โดยแนะนำ ตัวแปร สุดท้ายแบบคงที่ส่วนตัว VALUES สำหรับการแคช

การส่งผ่านพารามิเตอร์ทางเลือกเป็นพารามิเตอร์วิธีการ

พิจารณารหัสต่อไปนี้:

LocalDateTime getCurrentTime(Optional<ZoneId> zoneId) {
    return zoneId.stream()
        .map(LocalDateTime::now)
        .findFirst()
        .orElse(LocalDateTime.now(ZoneId.systemDefault()));
}

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

LocalDateTime getCurrentTime(ZoneId zoneId) {
  return LocalDateTime.now(zoneId);
}

LocalDateTime getCurrentTime() {
  return getCurrentTime(ZoneId.systemDefault());
}

โค้ดที่คุณเห็นด้านบนนั้นอ่านและแก้ไขข้อบกพร่องได้ง่ายกว่ามาก

การใช้ StringBuilder

สตริงใน Java นั้นไม่เปลี่ยนรูป ซึ่งหมายความว่าเมื่อสร้างขึ้นแล้วจะไม่สามารถแก้ไขได้อีกต่อไป JVM รักษาพูลสตริงและก่อนที่จะสร้างอันใหม่ ให้เรียก เมธอด String.intern()ซึ่งจะส่งคืนอินสแตนซ์จากพูลสตริงที่สอดคล้องกับค่า หากมีอยู่ สมมติว่าเราต้องการสร้างสตริงแบบยาวโดยการเชื่อมองค์ประกอบเข้าด้วยกัน

String longString = new StringBuilder()
  .append("start")
  .append("middle")
  .append("middle")
  .append("middle")
  .append("end")
  .toString();

เราได้รับแจ้งเมื่อเร็วๆ นี้ว่านี่เป็นความคิดที่แย่มาก เนื่องจาก Java เวอร์ชันเก่าทำสิ่งต่อไปนี้:

• ในบรรทัดที่ 1 สตริง “start” จะถูกแทรกลงในพูลสตริงและชี้ไปที่longString
• บรรทัดที่ 2 เพิ่มสตริง "startmiddle" ลงในพูลและชี้ไปที่สตริงด้วยlongString
• ในบรรทัดที่ 3 เรามี "startmiddlemiddle"
• ในบรรทัดที่ 4 - "เริ่มต้นกลางกลางกลาง"
• และสุดท้ายในบรรทัดที่ 5 เราเพิ่ม "startmiddlemiddlemiddleend" ลงในพูลและชี้longString ไปที่มัน

แถวเหล่านี้ทั้งหมดยังคงอยู่ในพูลและไม่เคยถูกใช้ ส่งผลให้ RAM จำนวนมากสูญเปล่า เพื่อหลีกเลี่ยงปัญหานี้ เราสามารถใช้ StringBuilder

String longString = new StringBuilder()
  .append("start")
  .append("middle")
  .append("middle")
  .append("middle")
  .append("end")
  .toString();

StringBuilder สร้างเพียงสตริงเดียวเมื่อ มีการเรียกใช้เมธอด toStringดังนั้นจะเป็นการกำจัดสตริงระดับกลางทั้งหมดที่เพิ่มลงในพูลตั้งแต่แรก อย่างไรก็ตาม หลังจาก Java 5 คอมไพเลอร์จะดำเนินการโดยอัตโนมัติดังนั้นจึงเป็นการดีกว่าถ้าใช้การต่อสตริงโดยใช้ "+"

การใช้กระดาษห่อแบบดั้งเดิมเมื่อไม่จำเป็น

พิจารณาสองส่วนต่อไปนี้:

int sum = 0;
for (int i = 0; i < 1000 * 1000; i++) {
  sum += i;
}
System.out.println(sum);

Integer sum = 0;
for (int i = 0; i < 1000 * 1000; i++) {
  sum += i;
}
System.out.println(sum);

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

วิธีการใช้คำสุดท้าย ในที่สุด และสรุปใน Java

ที่มา: Newsshare ในบทความนี้ คุณจะได้เรียนรู้ว่า Finalize คีย์เวิร์ดถูกใช้ที่ไหน เมื่อใด และเพราะเหตุใด และคุ้มค่าที่จะใช้คีย์เวิร์ดดังกล่าวใน Java หรือไม่ นอกจากนี้คุณยังจะได้เรียนรู้ความแตกต่างระหว่างขั้นสุดท้าย ในที่สุด และขั้นสุดท้าย

สุดท้ายใช้บล็อกที่ไหน?

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

คุณจะสรุปตัวแปรใน Java ได้อย่างไร?

มี 3 วิธีในการเริ่มต้นตัวแปร Java สุดท้าย:

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

เราสามารถเรียกวิธีการสรุปด้วยตนเองใน Java ได้หรือไม่?

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

วิธีการสรุปจะถูกเรียกเมื่อใด

เมธอดFinalize()ถูกเรียกเพื่อทำการล้างข้อมูลก่อนการรวบรวมขยะ

อะไรคือความแตกต่างระหว่าง Final, ในที่สุด และ Finalize?

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

เป็นไปได้ไหมที่จะแทนที่วิธีสุดท้าย?

ไม่ได้ วิธีการประกาศขั้นสุดท้ายไม่สามารถแทนที่หรือซ่อนได้

เราสามารถใช้ try โดยไม่ catch ได้ไหม?

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

วิธีการสุดท้ายคืออะไร?

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

ตัวสร้างสามารถถือเป็นที่สิ้นสุดได้หรือไม่?

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

ในที่สุดคำหลักที่ใช้คืออะไร?

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

สุดท้ายมีประโยชน์อะไร?

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

เหตุใดวิธีการ Finalize จึงได้รับการป้องกัน

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

วิธีการสรุปจะถูกเรียกใน Java เสมอหรือไม่

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

ความแตกต่างระหว่างการขว้างและการขว้างคืออะไร?

คีย์เวิร์ด Throw ใช้เพื่อจงใจโยนข้อยกเว้น คีย์เวิร์ด Throws ใช้เพื่อประกาศข้อยกเว้นตั้งแต่หนึ่งรายการขึ้นไป โดยคั่นด้วยเครื่องหมายจุลภาค เมื่อใช้การโยน จะมีข้อยกเว้นเดียวเท่านั้นที่จะถูกโยนทิ้ง

อะไรคือความแตกต่างระหว่าง try catch และคีย์เวิร์ดสุดท้าย?

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

ในที่สุดเราก็สามารถใช้โดยไม่ต้องลองใช้ Java ได้ไหม?

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

เราสามารถสืบทอดวิธีสุดท้ายได้หรือไม่?

วิธีสุดท้ายสืบทอดมาหรือไม่? ใช่ วิธีการสุดท้ายได้รับการสืบทอดมา แต่คุณไม่สามารถแทนที่ได้

วิธีใดไม่สามารถแทนที่ได้?

เราไม่สามารถแทนที่วิธีการแบบคงที่ได้เนื่องจากการแทนที่วิธีการจะขึ้นอยู่กับการเชื่อมโยงแบบไดนามิกที่รันไทม์ และวิธีการแบบคงที่จะถูกผูกไว้โดยใช้การเชื่อมโยงแบบคงที่ในเวลารวบรวม ดังนั้นจึงไม่สามารถเอาชนะวิธีคงที่ได้

จะเกิดอะไรขึ้นหากวิธีสุดท้ายถูกแทนที่?

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

คำหลักสุดท้ายและวิธีการสรุปผลทำงานเหมือนกันหรือไม่

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

super keyword ใน Java คืออะไร?

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

อะไรคือความแตกต่างระหว่างคำหลักแบบคงที่และคำหลักสุดท้าย?

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