როგორ ხდება შეცდომების დამუშავება Java-ში და როგორ მუშაობთ მათთან?

Java-да දෝෂ හෝ විශේෂ අවස්ථා මැදිරිමක් භාවිතා කරමින් සැලසුම් කරයි. විශේෂ අවස්ථා යනු, වැඩසටහනේ සාමාන්‍ය ක්‍රියාවලිය බිඳවැටෙන සිදුවීම් වේ. ඒවා දෙකක් ඇත: Checked Exceptions සහ Unchecked Exceptions.

Checked Exceptions:

• java.lang.Exception මගින් උරුමකළ (RuntimeException නොවෙයි).
• එය අනිවාර්යයෙන්ම සැලසුම් කළ යුතුය (try-catch භාවිතා කර) හෝ මාර්ගෝපදේශයේ (throws භාවිතා කර) දන්විය යුතුය.
• සාමාන්‍ය තත්වයන්හි සිදුවිය හැකි දෝෂ (උදාහරණයක් ලෙස, IOException, FileNotFoundException).

Unchecked Exceptions:

• java.lang.RuntimeException හෝ java.lang.Error මගින් උරුමකළ.
• අනිවාර්ය සැලසුම් කිරීමක් අවශ්‍ය නොවේ.
• සාමාන්‍යයෙන්, කේතයේ තර්ක දෝෂ හෝ ක්‍රියාකාරකම් පරිසරයේ අසමත් තත්වයන් (NullPointerException, ArrayIndexOutOfBoundsException) පෙන්වයි.

විශේෂ අවස්ථා සැලසුම් කිරීම:

try-catch-finally බ්ලොක් භාවිතා කරයි:

• try: දෝෂයක් ඇති විය හැකි කේත කොටස.
• catch: try කොටස තුළ දෝෂයක් ඇති වුවහොත් ක්‍රියාත්මක වන කොටස.
• finally: සෑම විටම ක්‍රියාත්මක වන කොටස, සම්පත් නිදහස් කිරීම සඳහා (උදාහරණයක් ලෙස, ගොනු වසා දැමීම).

try {
    // දෝෂයක් ඇති විය හැකි කේත
    int result = 10 / 0; // උදාහරණයක්: ArithmeticException
} catch (ArithmeticException e) {
    // ArithmeticException සැලසුම් කිරීම
    System.err.println("සෙල්ෆ් බෙදීමේ දෝෂය: " + e.getMessage());
} catch (Exception e) {
    // වෙනත් සියලු දෝෂ සැලසුම් කිරීම
    System.err.println("සාමාන්‍ය දෝෂය: " + e.getMessage());
} finally {
    // සෑම විටම ක්‍රියාත්මක වන කොටස
    System.out.println("Finally කොටස ක්‍රියාත්මක විය.");
}

දෝෂ මාරු කිරීම:

මෙතෝඩ් එකක් නියමිත දෝෂයක් ඇති විය හැකි බව දන්වයි, throws යතුරු පදය භාවිතා කර:

public void readFile(String filePath) throws FileNotFoundException, IOException {
    // ගොනුව කියවීමේ කේතය
    FileReader fr = new FileReader(filePath);
    // ගොනුව නොමැති නම්, FileNotFoundException එවිය හැක
    // IO දෝෂයක් ඇති වුවහොත්, IOException එවිය හැක
    // ...
}

ආරාධක මාර්ගෝපදේශය මෙම දෝෂය සැලසුම් කළ යුතුය, හෝ එය මාරු කිරීමට දන්විය යුතුය.

අභිරුචි දෝෂ නිර්මාණය:

Exception හෝ RuntimeException මගින් උරුමකළ ඔබගේම දෝෂ පන්තියක් නිර්මාණය කළ හැක:

public class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

භාවිතය:

public void processData(int value) throws MyCustomException {
    if (value < 0) {
        throw new MyCustomException("අගය ඍණාත්මක නොවිය යුතුයි");
    }
    // දත්ත සැකසීම
}

ප්‍රධාන දෝෂ පන්තියන් (ආරක්ෂිත වර්ගය):

• java.lang.Throwable (සියලු දෝෂ සහ විශේෂ අවස්ථා සඳහා මූලික පන්තිය)
  • java.lang.Error (වැදගත් ගැටලු සඳහා, සාමාන්‍යයෙන් සැලසුම් නොකළ යුතු, උදාහරණයක් ලෙස OutOfMemoryError)
  • java.lang.Exception (සැලසුම් කළ හැකි දෝෂ)
    • java.lang.RuntimeException (Unchecked Exceptions)
      • NullPointerException
      • ArrayIndexOutOfBoundsException
      • ArithmeticException
      • සහ අනෙකුත්
    • වෙනත් Exception උපපන්තියන්
      • IOException
      • FileNotFoundException
      • SQLException
      • සහ අනෙකුත්

දෝෂ සමඟ වැඩ කිරීම මෙම ආරක්ෂිත වර්ගය, නිවැරදි දෝෂ වර්ගය තෝරා ගැනීම, try-catch-finally භාවිතා කිරීම, දෝෂ ලොග් කිරීම ආදී ක්‍රියාවලියන් සමඟ සිදු වේ.