ไม่ใช่วิธีปฏิบัติที่ดีในการจัดการข้อยกเว้นรันไทม์ในรหัสหรือไม่

ฉันกำลังทำงานกับแอปพลิเคชัน Java และฉันเห็นว่ามีการจัดการข้อยกเว้นเวลาทำงานในหลาย ๆ ที่ ตัวอย่างเช่น,

try {
    // do something
} catch(NullPointerException e) {
    return null;
}

คำถามของฉันคือเมื่อใดที่ควรปฏิบัติกับข้อยกเว้นรันไทม์ เมื่อใดควรยกเว้นข้อยกเว้นที่ไม่ถูกจัดการ?

มันขึ้นอยู่กับ.

ตัวอย่างเช่นInteger#parseIntthrows NumberFormatException(ซึ่งคือ RTE) หากไม่สามารถแยกวิเคราะห์สตริงที่ระบุ แต่แน่นอนคุณไม่ต้องการให้แอปของคุณพังเพราะผู้ใช้เขียน "x" ลงในช่องข้อความที่เป็นจำนวนเต็มใช่ไหม และคุณจะรู้ได้อย่างไรว่าสตริงสามารถวิเคราะห์คำยกเว้นว่าคุณพยายามแยกวิเคราะห์ก่อน ดังนั้นในกรณีนี้ RTE เป็นเพียงสัญญาณข้อผิดพลาดที่ควรทำให้เกิดข้อผิดพลาดบางชนิด หนึ่งอาจโต้แย้งว่ามันควรจะเป็นข้อยกเว้นที่ตรวจสอบ แต่สิ่งที่คุณสามารถทำได้ - มันไม่ได้

NullPointerExceptions มักจะเป็นสัญญาณของการตรวจสอบโมฆะที่ขาดหายไป ดังนั้นแทนที่จะจับมันแบบนี้คุณควรเพิ่มการตรวจสอบค่าโมฆะ apropriate เพื่อให้แน่ใจว่าไม่ได้โยนข้อยกเว้น

แต่บางครั้งมันก็เหมาะที่จะจัดการกับ RunTimeExceptions ตัวอย่างเช่นเมื่อคุณไม่สามารถแก้ไขโค้ดเพื่อเพิ่มการตรวจสอบค่า Null ในสถานที่ที่เหมาะสมหรือเมื่อข้อยกเว้นเป็นสิ่งอื่นที่ไม่ใช่ NullPointerException

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

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

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

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

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

ตัวอย่างเช่น:

Integer getUserCount() {
   Integer result = null;
   try {
      // Attempt to open database and retrieve data
   } catch (TimeoutException e) {
      logger.error("Got a watch?");
   } catch (MissingDatabaseException e) {
      logger.error("What are you smoking?");
   } catch (PermissionsToReadException e) {
      logger.error("Did you *really* think you were getting away with that?");
   } catch (PressedSendButtonToHardException e) {
      logger.error("Seriously.. just back away from the computer... slowly..");
   } catch (WTFException e) {
      logger.error("You're on your own with this one.. I don't even know what happened..");
   } finally {
      // Close connections and whatnot
   }
   return result;
}

void doStuff() {
   Integer result = getUserCount();
   if(result != null) {
       // Went as planned..
   }
}

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