Java අපවාද හසුරුවීමේ පූර්ණ මාර්ගෝපදේශය: throw සහ throws

placeholders.

1. හැඳින්වීම

ඔබ ජාවා භාෂාවෙන් වැඩසටහන් ලියන්න ආරම්භ කරන විට, “exception handling” (අපවාද හසුරුව) යන පදය අනිවාර්යයෙන්ම මුහුණ දේ. විවිධ යතුරුපද අතර, “throw” සහ “throws” යන දෙක ආරම්භකයන්ට විශේෂයෙන් ගැඹුරු වශයෙන් ගැලපෙන්නේ ඒවා සමාන ලෙස පෙනෙන නමුත් වෙනස් කාර්යයන් සපයන නිසාය.

ජාවා යනු ආරක්ෂාව සහ ශක්තිමත් බව සැලකිල්ලට ගෙන නිර්මාණය කරන ලද භාෂාවකි, එය දෝෂ සහ අනපේක්ෂිත තත්ත්වයන් නිසි ලෙස හසුරවීමට අන්තර්ගත ක්‍රමයක් සපයයි. මෙම ක්‍රමය “exception handling” (අපවාද හසුරුව) ලෙස හැඳින්වේ. අපවාද හසුරුව වැඩසටහන්වල විශ්වාසනීයතාවය සහ නඩත්තුකිරීමේ හැකියාව වැඩිදියුණු කිරීමේ වැදගත් භූමිකාවක් ගනී.

මෙම ලිපියේ, අපි “java throws” භාවිතා කිරීම පිළිබඳව මූලික අපවාද හසුරුවේ සිට ආරම්භ කර, නිතර අසන ප්‍රශ්න සහ පොදු වැරදි පිළිබඳව යාමට අවධානය යොමු කරමු. “throw” සහ “throws” අතර වෙනස ගැන නොදන්නා හෝ throws කුමන තැනක, කෙසේ භාවිතා කළ යුතුද යන්න තේරුම් ගැනීමට කැමති ඕනෑම කෙනෙකුට මෙම මාර්ගෝපදේශය විශේෂයෙන් ප්‍රයෝජනවත් වේ. අපි වාස්තුක තොරතුරු, උපදෙස්, සහ සැබෑ ලෝක ව්‍යාපෘතිවල නිතර දක්නට ලැබෙන නියැදි කේත උදාහරණද ඇතුළත් කර ඇත, එබැවින් අවසානය දක්වා කියවන්න.

2. ජාවාහි අපවාද හසුරුව යනු කුමක්ද?

ජාවා වැඩසටහන් ලියන විට, රන්ටයිම් (runtime) තුළ විවිධ අනපේක්ෂිත තත්ත්වයන් සිදුවිය හැක. උදාහරණයක් ලෙස, ගොනුවක් සොයාගත නොහැකි වීම, ශූන්‍යයෙන් බෙදීමේ දෝෂයක්, හෝ අරේ එකක සීමා පිටත අංගයක් ප්‍රවේශය කිරීම උත්සාහ කිරීම. මෙම තත්ත්වයන් “අපවාද” (exceptions) ලෙස හැඳින්වේ.

2.1 අපවාද හසුරුවේ මූලික සංකල්ප

අපවාද හසුරුව යනු වැඩසටහන ක්‍රියාත්මක වන අතර සිදුවන අසාමාන්‍ය තත්ත්වයන් (අපවාද) හඳුනාගෙන, සංවර්ධකයන්ට ඒවා නිසි ලෙස සලසීමට ඉඩ දෙන ක්‍රමයකි. අපවාදයක් සිදුවූ විට වැඩසටහන හදිසි ලෙස නවත්වීම වෙනුවට, ජාවා දෝෂයේ වර්ගය සහ අන්තර්ගතය අනුව යෙදුමට අර්ථවත් ප්‍රතිචාරයක් ලබා දීමට හැකියාව සලසයි. මෙය යෙදුමේ ස්ථායිත්වය සහ පරිශීලක අත්දැකීම වැඩිදියුණු කරයි.

2.2 පරීක්ෂා කළ අපවාද සහ පරීක්ෂා නොකළ අපවාද

ජාවා අපවාද දෙකක් ප්‍රධාන වර්ග දෙකකට බෙදේ.

පරීක්ෂා කළ අපවාද

පරීක්ෂා කළ අපවාද යනු සංග්‍රහ (compile) කාලයේදී හසුරවිය යුතු අපවාද වේ. උදාහරණයක් ලෙස ගොනු මෙහෙයුම් අතර IOException. මෙම අපවාද try-catch බ්ලොක් එකක් භාවිතා කර හෝ throws ප්‍රකාශයක් මගින් කැඳවුම්කරු වෙත ප්‍රචාරණය කර යුතුය.

try {
    FileReader fr = new FileReader("data.txt");
} catch (IOException e) {
    e.printStackTrace();
}

පරීක්ෂා නොකළ අපවාද

පරීක්ෂා නොකළ අපවාද යනු සංග්‍රහ කාලයේ අනිවාර්ය හසුරුව අවශ්‍ය නොවන අපවාද වේ. සාමාන්‍ය උදාහරණ ලෙස NullPointerException සහ ArrayIndexOutOfBoundsException යනවා, ඒවා සාමාන්‍යයෙන් වැඩසටහන් දෝෂයන් නිසා සිදුවේ. ජාවා මෙම අපවාද හසුරුව නොකරත් සංග්‍රහ කරගත හැකි නමුත්, අනපේක්ෂිත දෝෂ වලින් වැළැක්වීමට අවශ්‍ය වන විට ඒවාට සලස්වීම සුදුසුය.

2.3 අපවාද හසුරුව අවශ්‍ය වන්නේ ඇයි

අපවාද හසුරුව නිසි ලෙස ක්‍රියාත්මක කිරීම පහත වාසි ලබා දේ:

• ** වැඩසටහනේ ස්ථායිත්වය වැඩිදියුණු කිරීම:** අනපේක්ෂිත දෝෂ සිදු වූ විටත්, වැඩසටහන හදිසි නවත්වීමකින් තොරව සුදුසු පණිවුඩ පෙන්වා හෝ ප්‍රතිසාධන ලොජික් ක්‍රියාත්මක කළ හැක.
• ** පරීක්ෂණය පහසු කිරීම:** අපවාදයේ වර්ගය සහ පණිවුඩය ගැටළුවේ හේතුව හඳුනා ගැනීමට පහසු කරයි.
• ** පරිශීලක අත්දැකීම වැඩිදියුණු කිරීම:** දෝෂයක් මත හදිසි නවත්වීම වෙනුවට, පද්ධතිය අර්ථවත් ප්‍රතිචාර හෝ ප්‍රතිසාධන පියවර ලබා දිය හැක.

ජාවාහි අපවාද හසුරුව ශක්තිමත් යෙදුම් ගොඩනැගීමට අත්‍යවශ්‍ය කුසලතාවකි. ඊළඟ අධ್ಯಾಯයේ, “throw” මූලික කරුණු පැහැදිලි කරමු.

3. “throw” යනු කුමක්ද?

ජාවාහි, “throw” යනු අපවාදයක් අදහස් පූර්වකව උත්පාදනය කිරීමට භාවිතා කරන යතුරුපදයකි. අපවාදයන් වැඩසටහන ක්‍රියාත්මක වන විට ස්වයංක්‍රීයව සිදුවන නමුත්, නියමිත කොන්දේසි පිරිනැමෙන විට අපවාදයක් නිර්මාණය කර එය උත්පාදනය කිරීමට ඔබට අවශ්‍ය විය හැක—මෙම අවස්ථාවේ “throw” භාවිතා වේ.

3.1 “throw” හි මූලික භාවිතය

“throw” යනු අපවාද වස්තුවක් නිශ්චිතව උත්පාදනය කර එය උසුලයි, එවිට අපවාදයක් සිදුවේ. මූලික වාක්‍ය රචනය පහත පරිදි වේ:

throw new ExceptionClass("Error message");

උදාහරණයක් ලෙස, අවලංගු පරාමිතියක් ලබා දුන් විට, ඔබට මෙසේ අපවාදයක් උසුලන්න පුළුවන්:

public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("Age must be zero or greater");
    }
    this.age = age;
}

මෙම උදාහරණයේ, වයස ශුන්‍යයට වඩා අඩු වන විට IllegalArgumentException එකක් නිකුත් වේ.

3.2 ඔබට දෝෂ නිකුත් කිරීමට අවශ්‍ය විය හැකි හේතු

“throw” භාවිතා කිරීමේ ප්‍රධාන අරමුණ වන්නේ අවලංගු තත්ත්වයන් හෝ නීති උල්ලංඝන ගැන වැඩසටහනට වහාම දැනුම් දීමයි. මෙය දෝෂ ඉක්මනින් හඳුනා ගැනීමට සහ අනිච්චිත හැසිරීම් වැළැක්වීමට උපකාරී වේ.

උදාහරණයන් වන්නේ:

• පරිශීලක ඇතුළත් කිරීම වලංගුකරණය අසාර්ථක වූ විට
• අවලංගු පරාමිතීන් හෝ සැකසුම් යොමු කරන විට
• ව්‍යාපාරික තර්කය තවත් සැකසීම තහනම් කරන විට

3.3 throw භාවිතය පිළිබඳ සටහන්

“throw” භාවිතයෙන් දෝෂයක් නිකුත් කරන විට, එය ඒම ක්‍රමය තුළ try-catch බ්ලොක් එකක් භාවිතා කර නොමැති නම්, කැඳවුම්කරු වෙත පැතිර යයි. පරීක්ෂා කළ යුතු දෝෂ (උදා: IOException) සඳහා, ක්‍රමයෙහි අත්සනෙහි “throws” යන ප්‍රකාශයද ඇතුළත් කළ යුතුය. පරීක්ෂා නොකළ දෝෂ සඳහා, throws ප්‍රකාශය විකල්පයක් වන අතර, “throw” සහ “throws” අතර වෙනස තේරුම් ගැනීම නිවැරදි භාවිතයට අත්‍යවශ්‍ය වේ.

4. throws යනු කුමක්ද?

Java වැඩසටහන් ලියන විට, ක්‍රම ප්‍රකාශනවල “throws” යන යතුරුපදය ඔබට හමුවිය හැක. throws යතුරුපදය, ක්‍රමය ක්‍රියාත්මක වන අතර එකක් හෝ වැඩි දෝෂ නිකුත් කළ හැකි බව කැඳවුම්කරුට දැනුම් දීමට භාවිතා වේ.

4.1 throws හි මූලික භාවිතය

ක්‍රම ප්‍රකාශනයේ දෝෂ පන්තියේ නාමයන් සඳහන් කිරීමෙන්, throws යතුරුපදය එම ක්‍රමය තුළ සිදුවිය හැකි සියලු දෝෂ කැඳවුම්කරු වෙත පැතිර යයි. විශේෂයෙන් පරීක්ෂා කළ යුතු දෝෂ සඳහා, කැඳවුම්කරු ඒවා නිවැරදිව හසුරවීමට throws සමඟ ප්‍රකාශ කළ යුතුය.

උදාහරණය:

public void readFile(String path) throws IOException {
    FileReader reader = new FileReader(path);
    // File reading process
}

මෙම උදාහරණයේ, FileReader නිරූපකය IOException නිකුත් කළ හැකි බැවින්, ක්‍රමය throws IOException ලෙස ප්‍රකාශ කළ යුතුය.

4.2 ක්‍රම ප්‍රකාශනවල දෝෂ පැතිරීම

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

public void processFile() throws IOException {
    readFile("test.txt"); // readFile throws IOException, so this method must also declare throws
}

4.3 බහු දෝෂ ප්‍රකාශ කිරීම

ක්‍රමයක් බහු දෝෂ නිකුත් කළ හැකි නම්, throws යතුරුපදය පසු කොමාවෙන් වෙන් කළ ලැයිස්තුවක් ලෙස ඒවා ප්‍රකාශ කළ හැක.

public void connect(String host) throws IOException, SQLException {
    // Network or database operations
}

4.4 throws හි භූමිකාව සහ ප්‍රතිලාභ

• ආකෘතික පඬිවීම සහ නඩත්තු කිරීමේ හැකියාව වැඩිවීම: throws ප්‍රකාශනය මඟින් ක්‍රමයක් නිකුත් කළ හැකි දෝෂ වර්ගයන් වහාම පැහැදිලි වේ, එය සංවර්ධකයන් අතර සන්නිවේදනය වැඩිදියුණු කරයි.
• දෝෂ හසුරවීමේ පැහැදිලි වගකීම: throws මඟින් කැඳවුම්කරුවන්ට දෝෂ හසුරවීම අනිවාර්ය කරයි, එය ශක්තිමත් සහ සංරචිත පද්ධති සැලසුමක් ප්‍රවර්ධනය කරයි.
• අභිරුචි දෝෂ සඳහා සහය: සංවර්ධකයන්ට අභිරුචි දෝෂ පන්තීන් throws ප්‍රකාශනවලට ඇතුළත් කර, සංකීර්ණ දෝෂ අවස්ථා වඩා හොඳින් හසුරවිය හැක.

5. throw සහ throws අතර වෙනස්කම්

බොහෝවිට ගැලපෙන නමුත්, “throw” සහ “throws” Java හි දෝෂ-හසුරවීමේ ක්‍රමවේදයේ ඉතා වෙනස් භූමිකා ගනී. මෙම අධ්‍යයනය ඔවුන්ගේ වෙනස්කම් පැහැදිලි කර, එක් එක් එකක් නිවැරදිව කවදා හා කෙසේ භාවිතා කළ යුතුද යන්න විස්තර කරයි.

5.1 throw සහ throws අතර කාර්යමය වෙනස්කම්

5.2 එක් එක් එක භාවිතා කරන අවස්ථා

• throw
• අවලංගු ඇතුළත් කිරීමක් හෝ නීති උල්ලංඝනයක් හඳුනාගැනීමේදී, ඔබට ක්‍රියාත්මකව දෝෂයක් නිර්මාණය කිරීමට අවශ්‍ය වන විට භාවිතා වේ.
• උදාහරණය: “වයස ශුන්‍යයට වඩා අඩු නම්, IllegalArgumentException නිකුත් කරන්න.”
• throws
• ක්‍රමයක් හෝ නිරූපකයක් දෝෂ නිකුත් කළ හැකි වන අතර, එය කැඳවුම්කරුවන්ට දැනුම් දිය යුතු විට භාවිතා වේ.
• උදාහරණය: “ගොනු මෙහෙයුම් හෝ දත්ත ගබඩා ප්‍රවේශය කළමනාකරණය කරන ක්‍රමවල throws භාවිතා කරන්න, එහි දෝෂ අපේක්ෂිත වේ.”

5.3 සසඳා බැලීම සඳහා කේත උදාහරණ

throw උදාහරණය:

public void setName(String name) {
    if (name == null || name.isEmpty()) {
        throw new IllegalArgumentException("Name cannot be empty");
    }
    this.name = name;
}

throws උදාහරණය:

public void loadConfig(String path) throws IOException {
    FileReader reader = new FileReader(path);
    // Configuration loading process
}

5.4 සාරාංශ වගුව

throw සහ throws හි භූමිකා පැහැදිලිව වෙනස් වන අතර, කොහේ කුමන අවස්ථාවක කුමන එක භාවිතා කළ යුතුද යන්න තේරුම් ගැනීම ශක්තිමත් exception හසුරුවීමේ පළමු පියවරයි.

6. throws භාවිතා කිරීමේ හොඳ පුරුදු

throws කාර්යක්ෂමව භාවිතා කිරීම Java වැඩසටහන්වල කියවීමට පහසුකම සහ නඩත්තු කිරීමේ හැකියාව වැඩි කරයි, එසේම විස්මය හසුරුවීමේ සමස්ත ගුණාත්මකභාවයද වර්ධනය කරයි. මෙම අධ්‍යයනය වාස්තුකලාවලදී සාමාන්‍යයෙන් භාවිතා වන නිර්දේශිත පුරුදු සහ වැදගත් සැලකිලි පිළිබඳව හඳුන්වා දෙයි.

6.1 නිරුපිත Exception පන්තීන් නිරූපණය කරන්න

throws ප්‍රකාශනවල, හැකි තරම් නිරුපිත (concrete) exception පන්තීන් නිරූපණය කරන්න.
Exception හෝ Throwable වැනි පුළුල් පන්තීන් ප්‍රකාශ කිරීමෙන් වැළකී සිටින්න.
IOException හෝ SQLException වැනි විශේෂිත exception භාවිතා කිරීමෙන්, කැඳවුම්කරුන්ට දෝෂයන් කෙසේ හසුරවිය යුතුද යන්න නිවැරදිව තීරණය කළ හැක.

හොඳ උදාහරණය:

public void saveData() throws IOException {
    // File-saving process
}

මෙය වැළකී සිටින්න:

public void saveData() throws Exception {
    // Too vague: unclear what exceptions may occur
}

6.2 Exception ශ්‍රේණිගත කිරීම (Hierarchy) භාවිතා කරන්න

Java exception පන්තීන් ශ්‍රේණිගත (hierarchical) ව්‍යුහයක් ගොඩනැගීම නිසා, සම්බන්ධිත exception පන්තීන් සුදුසු විට පියා පන්තියක් යටතේ සමූහගත කළ හැක.
එහෙත්, උසස්-මට්ටමේ exception (උදා: Exception) සමඟ අධික සාමාන්‍යීකරණය කිරීමෙන් පැහැදිළි බව අඩුවේ සහ දෝෂ හසුරුවීම අමාරු වේ.

6.3 Javadoc හි @throws ටැග් භාවිතා කරන්න

API හෝ පුස්තකාල ලබා දෙන විට, Javadoc අදහස් තුළ @throws ටැග් භාවිතා කර exception ලේඛනය කළ යුතුය.
මෙය exception සිදුවන තත්ත්වයන් පැහැදිලිව විස්තර කරයි, API භාවිතා කරන්නන්ට නිවැරදි exception හසුරුවීම ක්‍රියාත්මක කිරීමට උපකාරී වේ.

/**
 * Reads a file.
 * @param filePath Path of the file to read
 * @throws IOException If the file cannot be read
 */
public void readFile(String filePath) throws IOException {
    // ...
}

6.4 අවශ්‍ය නොවන exception නැවත-throw කිරීම වැළකී සිටින්න

අගය එකතු නොකර exception ග්‍රහණය කර පසුව නැවත-throw කිරීමෙන් වැළකී සිටින්න.
නැවත-throw කිරීම අවශ්‍ය නම්, මුල් exception එක අභිරුචි exception එකක් තුළ වැටුප් කර හෝ අතිරේක පසුබැසි තොරතුරු හෝ ලොග් කිරීමේ තොරතුරු ඇතුළත් කරන්න.

6.5 අභිරුචි Exception පන්තීන් භාවිතා කිරීම

ව්‍යාපාරික යෙදුම් සහ විශාල පද්ධතිවල, අභිරුචි exception පන්තීන් නිර්වචනය කර ඒවා throws ප්‍රකාශනවල ඇතුළත් කිරීම සාමාන්‍යයයි.
මෙය දෝෂ හේතු සහ වගකීම් පැහැදිලි කරයි, පද්ධතිය නඩත්තු කිරීම සහ විස්තාරණය කිරීම පහසු කරයි.

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

public void findData() throws DataNotFoundException {
    // Throw when data is not found
}

throws නිසි ලෙස භාවිතා කිරීමෙන්, ඔබට exception හසුරුවීමේ වගකීම් බෙදා හැරීමට, ගැටළු විසඳීම සරල කිරීමට, සහ විශ්වාසනීය හා ආරක්ෂිත Java යෙදුම් ගොඩනැගීමට හැකිය.

7. ප්‍රායෝගික Exception හසුරුවීමේ රටා

Java හි exception හසුරුවීම සරල try-catch බ්ලොක් හෝ throws ප්‍රකාශන වලට වඩා වැඩි වේ. මෙම අධ්‍යයනය වාස්තුකලාවලදී සාමාන්‍යයෙන් භාවිතා වන ප්‍රායෝගික රටා සහ නිර්මාණාත්මක උපාය මාර්ග හඳුන්වා දෙයි.

7.1 try-with-resources සමඟ සම්පත් කළමනාකරණය

ගොනු, ජාල සම්බන්ධතා, හෝ දත්ත ගබඩා සම්බන්ධතා සමඟ වැඩ කරන විට, exception සිදුවූ පසුද සම්පත් නිසි ලෙස මුදා හැරීම අත්‍යවශ්‍ය වේ. Java 7 සිට, try-with-resources ප්‍රකාශනය සම්පත් ස්වයංක්‍රීයව වසා දැමීමට ඉඩ සලසයි.

try (FileReader reader = new FileReader("data.txt")) {
    // File reading process
} catch (IOException e) {
    System.out.println("Failed to read file: " + e.getMessage());
}

answer.This syntax ensures that close() is called automatically, preventing resource leaks even if exceptions occur.

7.2 බහු දෝෂ හසුරවීම කාර්යක්ෂමව

Complex operations may produce multiple types of exceptions.
Since Java 7, you can catch multiple exceptions in a single catch clause using the multi-catch feature.

try {
    methodA();
    methodB();
} catch (IOException | SQLException e) {
    // Handle both exceptions here
    e.printStackTrace();
}

You can also separate catch blocks to provide customized handling for each exception type.

7.3 දෝෂ හසුරවීමේ කාර්ය සාධන සලකා බැලීම්

While exceptions are powerful, they should not replace normal control flow.
Generating exceptions requires significant overhead because stack traces must be created, so they should be reserved for truly exceptional cases.

Incorrect usage (not recommended):

try {
    int value = array[index];
} catch (ArrayIndexOutOfBoundsException e) {
    // Bounds checking should be done beforehand
}

Recommended usage:

if (index >= 0 && index < array.length) {
    int value = array[index];
} else {
    // Out-of-range handling
}

7.4 ලොග් කිරීම සහ දැනුම්දීම්

Proper logging and alerting are essential for troubleshooting when exceptions occur.
Business systems often use logging frameworks (e.g., Log4j, SLF4J) to record detailed exception information.

catch (Exception e) {
    logger.error("An error has occurred", e);
}

7.5 අභිරුචි ප්‍රතිසාධන තර්කය ක්‍රියාත්මක කිරීම

In some cases, it is useful to implement recovery logic such as retrying an operation, reloading configuration files, or notifying users.
Instead of terminating the program immediately, strive to maintain service continuity whenever possible.

By adopting practical exception-handling techniques, you can build Java applications that are both reliable and maintainable.

8. නිතර අසන ප්‍රශ්න (FAQ)

Below are common questions from beginners about Java exception handling, particularly regarding “throws,” along with their answers.

Q1. throw සහ throws අතර ප්‍රධාන වෙනස කුමක්ද?

A1.
throw යනු වැඩසටහන ක්‍රියාත්මක වන විට වස්ථාවට දෝෂයක් උත්පාදනය කරන යතුරු පදයකි.
throws යනු ක්‍රම ප්‍රකාශනවලදී එම ක්‍රමය දෝෂයක් උත්පාදනය කළ හැකි බව ප්‍රකාශ කිරීමට භාවිතා වේ.
→ මෙය මතක තබා ගැනීමට හොඳ ක්‍රමයක්: throw = “ක්‍රියාත්මක කිරීම,” throws = “ප්‍රකාශ කිරීම.”

Q2. throws භාවිතා කරන විට මොනවාට අවධානය යොමු කළ යුතුද?

A2.
throws සමඟ ප්‍රකාශිත දෝෂයන් අමතන්නා විසින් අල්ලා ගැනීමට හෝ throws භාවිතා කර තවත් ප්‍රචාරණය කිරීමට අවශ්‍ය වේ.
පරීක්ෂා කළ යුතු (checked) දෝෂ සඳහා, පැහැදිලි හසුරවීම අත්‍යවශ්‍ය වේ.
ඔබ දෝෂය අල්ලා නොගත්තා හෝ ප්‍රචාරණය නොකළා නම්, වැඩසටහන සංකලනය නොවනු ඇත.

Q3. throw සහ throws එකට භාවිතා කළ හැදියිද?

A3.
ඔව්. සාමාන්‍ය රටාවක් වන්නේ ක්‍රමයක් තුළ throw භාවිතා කර දෝෂයක් උත්පාදනය කර, එම දෝෂය throws සමඟ ප්‍රකාශ කර අමතන්නා වෙත ප්‍රචාරණය කිරීමයි.

Q4. throws භාවිතා කර බහු දෝෂ ප්‍රකාශ කිරීම කෙසේද?

A4.
throws යතුරු පදය පසුතැවෙන ලැයිස්තුව කොමා (,) වලින් වෙන් කර ලියන්න. උදාහරණය: public void sample() throws IOException, SQLException

Q5. unchecked දෝෂ (RuntimeException) සමඟ throws භාවිතා කළ යුතුද?

A5.
unchecked දෝෂ (RuntimeException න් උරුම කරන) සඳහා throws ප්‍රකාශන අවශ්‍ය නොවේ. එNevertheless, ඔබට විශේෂ unchecked දෝෂයක් උත්පාදනය කළ හැකි බව අමතන්නාට පැහැදිලිව දැනුම් දීමට throws භාවිතා කළ හැක, එය කියවීමට පහසුකම සහ API පැහැදිලිත්වය වැඩි කරයි.

Q6. throws කොටස තුළ Exception හෝ Throwable ප්‍රකාශ කිරීම සරිලනද?

A6.
තාක්ෂණිකව ඔව්, නමුත් එය නිර්දේශ නොකෙරේ. ඉතා පුළුල් දෝෂ වර්ග ප්‍රකාශ කිරීමෙන්, කුමන දෝෂ සිදුවිය හැකිද යන්න පැහැදිලි නොවෙයි, සහ අමතන්නාට නිසි හසුරවීම අමාරු වේ. හැකි තරම් නිර්දිෂ්ට දෝෂ පන්තීන් භාවිතා කරන්න.

Q7. throws තුළ ප්‍රකාශිත දෝෂ සෑම විටම අල්ලා ගැනීමට අවශ්‍යද?

A7.
පරීක්ෂා කළ (checked) දෝෂ සඳහා, කැලරය (caller) එම දෝෂය අල්ලා ගැනීමට හෝ throws භාවිතයෙන් එය තවත් ප්‍රචාරණය කිරීමට අවශ්‍ය වේ.
එය නොකළහොත් සංයුතියේ (compilation) දෝෂයක් සිදුවේ.
පරීක්ෂා නොකළ (unchecked) දෝෂ සඳහා එවැනි අවශ්‍යතාවයක් නොමැත.

Q8. මට throws ලිවීමට අමතක වුවහොත් කුමක් සිදුවේ?

A8.
එක් ක්‍රමයක් checked exception එකක් throws කරන නමුත් throws සමඟ එය ප්‍රකාශ නොකළහොත්, සංයුතියේ (compile‑time) දෝෂයක් සිදුවේ.
Unchecked exception සඳහා, throws නොමැතිවද ක්‍රමය සාමාන්‍ය ලෙස සංයුත වේ, නමුත් නිසි දෝෂ සැකසීම (error handling) තවමත් ක්‍රියාත්මක කළ යුතුය.

Java හි දෝෂ සැකසීම (exception handling) පිළිබඳ ඔබේ අවබෝධය ගැඹුරු කිරීමට මෙම FAQ කොටස භාවිතා කරන්න.