Java හි තර්නරි ඔපරේටරය භාවිතා කරන ආකාරය: ව්‍යවස්ථාව, හොඳම ක්‍රම, සහ පොදු දෝෂ විස්තර

1. හැඳින්වීම

ජාවාහි ත්‍රික සැකසුම්කරණය යනු කුමක්ද?

ජාවාහි “ත්‍රික සැකසුම්කරණය” (එහිම තත්ත්ව සැකසුම්කරණය ලෙසද හඳුන්වනු ලැබේ) ? : ව්‍යාකරණය භාවිතා කරමින් තත්ත්වයකට අනුව විවිධ වටිනාකම් ආපසු ලබා දෙයි.
එය if-else ප්‍රකාශනයකට සමානව ක්‍රියා කරයි නමුත් ඔබට තත්ත්ව තර්කය වඩාත් සංක්ෂිප්තව ලිවීමට ඉඩ සලසයි, එය ඔබේ කේතය කෙටිව තබා ගැනීමට අවශ්‍ය වන විට විශේෂයෙන් වැදගත් වේ.

උදාහරණයක් ලෙස, පහත කේතය සලකන්න:

int a = 10;
int b = 20;
int max = (a > b) ? a : b;

මෙහිදී, a b ට වඩා මහත් නම්, a max වෙත ප්‍රමාණවත් කෙරේ; නැතහොත්, b ප්‍රමාණවත් කෙරේ. මෙම තර්කය එක් පේළියකින් පමණක් ලබා ගනී.

ත්‍රික සැකසුම්කරණය තේරුම් ගැනීම වැදගත් වන්නේ ඇයි

ඔබ නවක වැඩසටහන්කරණයකරුවෙකු නම්, if ප්‍රකාශනය භාවිතා කිරීම තත්ත්ව සඳහා මූලිකම ප්‍රවේශය වේ. කෙසේ වෙතත්, ඔබේ කේත පදනම වර්ධනය වන විට, ඔබට ඔබේ කේතය වඩාත් සංක්ෂිප්ත සහ පාඨක විය හැකි ලෙස තබා ගැනීමට අවශ්‍ය වේ.

එහිදී ත්‍රික සැකසුම්කරණය එනවා. එහි ව්‍යාකරණය සරල වුවද, එය වැරදි ලෙස භාවිතා කිරීමෙන් කේත පාඨකත්වය අඩු විය හැකි බැවින්, එහි මූලික දේවල් හොඳින් තේරුම් ගැනීම වැදගත් වේ.

මෙම ලිපිය ජාවාහි ත්‍රික සැකසුම්කරණයේ මූලික ව්‍යාකරණය සිට ආරම්භ කරමින්, ප්‍රායෝගික භාවිතයන්, අනතුරු ඇඟවීම් සහ සැබෑ ලෝක සංවර්ධනයේ එය භාවිතා කිරීම ආවරණය කරයි.
ඔබ ජාවා සමඟ ආරම්භ කරනවාද හෝ මූලික දේ පුනරීක්ෂා කරනවාද, මෙම මාර්ගෝපදේශය වටිනා යොමුකිරීමක් වනු ඇත.

2. ත්‍රික සැකසුම්කරණයේ මූලික ව්‍යාකරණය සහ භාවිතය

ව්‍යාකරණය තේරුම් ගැනීම

ජාවාහි ත්‍රික සැකසුම්කරණය පහත ව්‍යාකරණය භාවිතා කරයි:

condition ? expression1 : expression2;

මෙය සරලව කියන්නේ: “තත්ත්වය සත්‍ය නම්, expression1 තක්සේරු කර ආපසු ලබා දෙන්න; නැතහොත්, expression2 තක්සේරු කර ආපසු ලබා දෙන්න.“

උදාහරණය:

int a = 5;
int b = 10;
int min = (a < b) ? a : b;
System.out.println("Smaller value: " + min); // Output: Smaller value: 5

a < b true නම්, a min වෙත ප්‍රමාණවත් කෙරේ; නැතහොත්, b ප්‍රමාණවත් කෙරේ.

if ප්‍රකාශන සමඟ සංසන්දනය: ත්‍රික සැකසුම්කරණය භාවිතා කිරීමට හේතුව කුමක්ද?

ත්‍රික සැකසුම්කරණය if-else ප්‍රකාශන සමඟ ලිවිය හැකි තර්කය ලිවීමට ඔබට අවශ්‍ය වන විට වැදගත් වේ, නමුත් වඩාත් සංක්ෂිප්තව. පහත සංසන්දනය බලන්න.

if-else ප්‍රකාශනයක් භාවිතා කිරීම:

int a = 5;
int b = 10;
int min;
if (a < b) {
    min = a;
} else {
    min = b;
}

ත්‍රික සැකසුම්කරණය භාවිතා කිරීම:

int min = (a < b) ? a : b;

ත්‍රික සැකසුම්කරණය සමඟ, ඔබට තත්ත්ව ප්‍රකාශනයක ප්‍රතිඵලය සෘජුව විචල්‍යයකට ප්‍රමාණවත් කළ හැකි වන අතර, කේත පේළි සංඛ්‍යාව අඩු කරයි. සරල තත්ත්ව පරීක්ෂණ සඳහා, එය ඔබේ කේතය සංසුන් සහ කාර්යක්ෂම කරයි.

ත්‍රික සැකසුම්කරණය භාවිතා කිරීමේදී අනතුරු ඇඟවීම්

කෙසේ වෙතත්, පහත දේ මතක තබා ගන්න:

• ත්‍රික සැකසුම්කරණය සරල, තනි-පේළි තර්කය සඳහා හොඳම වේ. ඔබ ඒවා එකිනෙකට යවා තබන විට, පාඨකත්වය අඩු වේ—මෙය පසුකාලීන කොටසක ආවරණය වේ.
• ත්‍රික සැකසුම්කරණය භාවිතා කිරීමේදී, ආපසු ලබා දෙන වටිනාකම් දෙකම එකම වර්ගයේ විය යුතු වේ. උදාහරණයක් ලෙස, true සඳහා int ආපසු ලබා දීම සහ false සඳහා String ආපසු ලබා දීම සංකලන දෝෂයක් ඇති කරයි.

3. ප්‍රායෝගික භාවිත උදාහරණ

ඔබ ව්‍යාකරණය තේරුම් ගත් පසු, සැබෝ ලෝක සංවර්ධනයේ ත්‍රික සැකසුම්කරණය භාවිතා වන ආකාරය බලමු. පහත දී සංඛ්‍යා සංසන්දනය, වාක්‍ය රීති සහ null පරීක්ෂණ වැනි ප්‍රායෝගික අවස්ථා ඇත.

සංඛ්‍යා සංසන්දනය සඳහා භාවිතා කිරීම

මූලිකම භාවිතය සංසන්දනයක ප්‍රතිඵලය ප්‍රමාණවත් කිරීම වේ. උදාහරණයක් ලෙස, සංඛ්‍යා දෙකෙහි විශාලම හෝ කුඩාම ලබා ගැනීමට:

උදාහරණය: උපරිම වටිනාකම ලබා ගැනීම

int a = 8;
int b = 12;
int max = (a > b) ? a : b;
System.out.println("Larger value: " + max); // Output: Larger value: 12

උදාහරණය: අවම වටිනාකම ලබා ගැනීම

int min = (a < b) ? a : b;

පෙන්වා ඇති පරිදි, ඔබට තත්ත්වයකට අනුව විචල්‍යයක් සෘජුව ප්‍රමාණවත් කළ හැකි වන අතර, කේත පේළි අඩු කරයි.

වාක්‍ය රීති සඳහා භාවිතා කිරීම

ත්‍රික සැකසුම්කරණය පරිශීලක තත්ත්වය හෝ වෙනත් තත්ත්ව මත පදනම්ව විවිධ පණිවිඩ පෙන්වීමට ඔබට අවශ්‍ය වන විටද වැදගත් වේ.

උදාහරණය: ලොගින් තත්ත්වය මත පණිවිඩ පෙන්වීම

boolean isLoggedIn = true;
String message = isLoggedIn ? "You are logged in" : "You are logged out";
System.out.println(message); // Output: You are logged in

ඔබට කොන්දේසි මත පදනම්ව පෙළ පහසුවෙන් මාරු කළ හැකි අතර, UI සංදර්ශන සහ ඒවගේම තත්ත්වයන් සඳහා මෙය ප්‍රයෝජනවත් වේ.

Null පරීක්ෂණ සඳහා භාවිතා කිරීම

ඔබට වස්තුවක් null නම් පෙරනිමි අගයක් නියම කිරීමට අවශ්‍ය වන විට ternary මෙහෙයුම්කරුද ප්‍රයෝජනවත් වේ.

උදාහරණය: null නම් පෙරනිමි අගයක් නියම කිරීම

String input = null;
String result = (input != null) ? input : "Default Value";
System.out.println(result); // Output: Default Value

එය null පරීක්ෂණ සරල කිරීම සඳහා ඉතා හොඳයි, විශේෂයෙන් බාහිර ආදානයක් හෝ null විය හැකි දත්ත ගබඩා අගයන් සමඟ කටයුතු කරන විට.

බහු කොන්දේසි හසුරවීම

කොන්දේසියේ තාර්කික මෙහෙයුම්කරු (&& සහ ||) භාවිතා කිරීමෙන් ternary මෙහෙයුම්කරු බහු කොන්දේසිද හසුරවිය හැක.

උදාහරණය: ලකුණු මත පදනම්ව ශ්‍රේණි පෙන්වීම

int score = 85;
String grade = (score >= 90) ? "A" :
               (score >= 70) ? "B" :
               (score >= 50) ? "C" : "D";
System.out.println("Grade: " + grade); // Output: Grade: B

මෙය nested ternary මෙහෙයුම්කරු එකක් උදාහරණයකි. කොන්දේසි වැඩි වීමත් සමඟ එය කියවීමට අමාරු වේ—ඊළඟ කොටසේ මෙය විස්තරාත්මකව පැහැදිලි කරනු ඇත.

පෙන්වා ඇති පරිදි, ternary මෙහෙයුම්කරු විවිධ සැබෑ-ලෝක තත්ත්ව සඳහා ලවච්චිත මෙවලමකි. ඊළඟ කොටසේ, nested ternary මෙහෙයුම්කරු භාවිතා කිරීම සහ හොඳ පුරුදු පිළිබඳව කතා කරමු.

4. Nested Ternary මෙහෙයුම්කරු

ternary මෙහෙයුම්කරු කොන්දේසියක් මත පදනම්ව අගයක් ආපසු ලබා දීමට පහසු කරයි. ඔබට අනුක්‍රමයෙන් බහු කොන්දේසි ඇගයීමට අවශ්‍ය නම්, ternary මෙහෙයුම්කරු nested කළ හැක. එහෙත්, nested කිරීම කියවීමට ගැටළුවක් සෑදිය හැකි බැවින්, අවධානයෙන් භාවිතා කරන්න.

Nesting හි මූලික ව්‍යුහය සහ භාවිතය

nested ternary මෙහෙයුම්කරු යනු expression1 හෝ expression2 තුළ තවත් ternary මෙහෙයුම්කරු තැබීමයි. එය සංඛ්‍යාත්මක අගයකට ශ්‍රේණි හෝ ශ්‍රේණිගත කිරීම සඳහා සාමාන්‍යයෙන් භාවිතා වේ.

උදාහරණය: ලකුණු මත පදනම්ව ශ්‍රේණි නියම කිරීම

int score = 78;

String result = (score >= 90) ? "Excellent" :
                (score >= 70) ? "Good" :
                (score >= 50) ? "Pass" : "Fail";

System.out.println("Result: " + result); // Output: Result: Good

මෙම උදාහරණය ලකුණු මත පදනම්ව “Excellent”, “Good”, “Pass”, හෝ “Fail” නියම කිරීම සඳහා 3-පට්ටම් nested ternary එකක් භාවිතා කරයි.

Nested Ternary මෙහෙයුම්කරු කියවීමට අමාරු වීමට හේතු

ආකර්ෂණීය වුවද, nesting මඟින් පහත ගැටළු ඇති විය හැක:

• අඩු ඉන්ඩෙන්ටේෂන් මඟින් කොන්දේසිය කුමකට අදාළද යන්න පැහැදිලි නොවේ
• දෝෂ නිරාකරණය අමාරු වේ
• විවිධ ඉංජිනේරුවන් ලොජික් එක වෙනස් ලෙස අර්ථ දැක්විය හැක

විශේෂයෙන් ඔබේ ප්‍රකාශන සංකීර්ණ ක්‍රියාකාරකම් හෝ string මෙහෙයුම් ඇතුළත් නම්, කියවීමට හැකියාව තීව්‍රව අඩුවේ.

කියවීමට හැකියාව රැක ගැනීම සඳහා උපදෙස්

ඔබට nested ternary මෙහෙයුම්කරු භාවිතා කළ යුතු නම්, මෙම උපදෙස් අනුගමනය කරන්න:

1. ඉන්ඩෙන්ටේෂන් සහ පේළි බිඳුම් භාවිතා කරන්න

පෙර උදාහරණය මෙන්, කියවීමට පහසු කිරීම සඳහා එක් එක් කොන්දේසිය නව පේළියක සකස් කරන්න.

2. අදහස් (comments) එක් කරන්න

ලොජික් එක පැහැදිලි නොවන්නේ නම්, නඩත්තු හැකියාව වැඩි කිරීමට එක් එක් කොන්දේසියට අදහස් එක් කරන්න.

String grade = (score >= 90) ? "A" :      // 90 or above
               (score >= 75) ? "B" :      // 75 or above
               (score >= 60) ? "C" : "F"; // below 60

3. දේවල් අතිශය සංකීර්ණ වූ විට if-else භාවිතා කරන්න

nesting ගැඹුරු වීම හෝ ලොජික් සංකීර්ණ වීමේදී, if-else ප්‍රකාශන වෙත මාරු වීම වඩා හොඳය. මතක තබා ගන්න, ternary මෙහෙයුම්කරු “කෙටි, සරල කොන්දේසි” සඳහා වන අතර, සියලු තත්ත්ව සඳහා නොවේ.

සැබෑ-ලෝක භාවිතය සඳහා මාර්ගෝපදේශ

මෙම තත්ත්වයන්හි nested ternary මෙහෙයුම්කරු වලක්විය යුතුය:

• ලොජික් එකේ අරමුණ අනෙකුත් පාඨකයන්ට පැහැදිලි නොවන්නේ නම්
• අනාගතයේ තවත් කොන්දේසි එකතු කිරීමට ඔබ බලාපොරොත්තු වනවා නම්
• කේතය අනෙකුත් අය නඩත්තු කරනවා නම්

අනෙක් පැත්තෙන්, ලොජික් එක සරල වන අතර, අගයන් මාරු කිරීම ගැන පමණක් නම්, හොඳින් ආකෘතිගත කළ nested ternary මෙහෙයුම්කරු ඔබේ කේතය කෙටිව තබා ගත හැක.

5. ත්‍රි‑අංග ක්‍රියාකාරකමේ වාසි සහ අවාසි

ත‍්‍රි‑අංග ක්‍රියාකාරකම යනු Java හි කොන්දේසි තර්ක ලිවීමට ඇති ඉතා සංකුචිත සහ අවබෝධයට පහසු ක්‍රම之一 වේ. එ obstante, එහි ශක්තියත් දුර්වලතාත් දෙකම දැන ගැනීම වැදගත් වේ.

ත්‍රි‑අංග ක්‍රියාකාරකමේ වාසි

1. කේතය සංක්ෂිප්ත කරයි

ත‍්‍රි‑අංග ක්‍රියාකාරකමේ විශාල වාසිය වන්නේ එය කොන්දේසි එක පේළියක ලිවීමට ඉඩ දෙන බවයි. if‑else ප්‍රකාශයක් සමඟ කිහිප පේළි ගත විය හැකි කාර්යය මෙය වඩා පැහැදිලිව කරයි.

// Standard if statement
String result;
if (score >= 60) {
    result = "Pass";
} else {
    result = "Fail";
}

// Ternary operator
String result = (score >= 60) ? "Pass" : "Fail";

මෙම ආකාරයෙන්, ඔබේ කේතය පරීක්ෂා කර ගැනීමට සහ අවබෝධයට පහසු වේ.

2. කොන්දේසිය පරීක්ෂා කරන අතරම අගයක් නියම කළ හැක

if‑else සමඟ වෙනස්ව, ත‍්‍රි‑අංග ක්‍රියාකාරකම කොන්දේසිය පරීක්ෂා කරන සමඟම වෙනස්කමක් නියම කිරීමට ඉඩ සලසයි. UI එකේ පණිවුඩ වෙනස් කිරීමක් හෝ කොන්දේසි මත පදනම්ව සැකසුම් අගයන් තෝරා ගැනීම සඳහා මෙය ඉතා ප්‍රයෝජනවත් වේ.

3. සමහරවිට කියවීමට පහසුකම වැඩි කරයි

ඉතා සරල කොන්දේසි සඳහා, ත‍්‍රි‑අංග ක්‍රියාකාරකම ඇත්තටම කියවීමට පහසුකම වැඩි කරයි. අදහස එක දිගටම පැහැදිලි නම්, මෙය හොඳ තේරීමකි.

ත්‍රි‑අංග ක්‍රියාකාරකමේ අවාසි

1. අන්තර්ගත කිරීම කියවීමට පහසුකම අඩු කරයි

බහු ත‍්‍රි‑අංග ක්‍රියාකාරකම් එකට අන්තර්ගත කිරීම කේතය කියවීමට, නඩත්තු කිරීමට අමාරු කරයි, සහ පහසුවෙන් දෝෂ ඇති කරයි.

// Hard to read
String label = flag1 ? "A" : flag2 ? "B" : flag3 ? "C" : "D"; // Hard to read

2. සංකීර්ණ තර්ක සඳහා සුදුසු නොවේ

ත‍්‍රි‑අංග ක්‍රියාකාරකම අගයන් පමණක් ආපසු ලබා දීමට පමණක් භාවිතා වේ. සංකීර්ණ ක්‍රියාවලීන් හෝ එක් එක් කොන්දේසියට බහු පියවරක් අවශ්‍ය නම්, if‑else හෝ switch භාවිතා කරන්න.

3. වර්ග අසමතුලිත දෝෂ වලට පත් විය හැක

දෙකම ප්‍රකාශන එකම වර්ගයක් ආපසු ලබා දිය යුතුය. උදාහරණයක් ලෙස, සත්‍ය අවස්ථාවේ int එකක්, අසත්‍ය අවස්ථාවේ String එකක් ආපසු ලබා දුන්නේ නම්, සංග්‍රහණ දෝෂයක් සිදුවේ.

// NG example: Type mismatch
String result = (isSuccess) ? "Success" : 0; // Compile error

ත්‍රි‑අංග ක්‍රියාකාරකම භාවිතා කළ යුතු අවස්ථා: ඉක්මන් යොමුකිරීම

නිගමනය: වැදගත් කරුණ වන්නේ පාඨකයා ඔබේ කේතය ඉක්මනින් අවබෝධ කර ගත හැකිද යන්නයි.

6. පොදු දෝෂ සහ ඒවා සකස් කිරීමේ ක්‍රම

ත‍්‍රි‑අංග ක්‍රියාකාරකම සරල වුවද, ආරම්භකයන්ට අනපේක්ෂිත දෝෂ ඇති කරවිය හැක. මෙන්න සාමාන්‍ය වැරදි සහ ඒවා සකස් කිරීමේ ක්‍රම.

වර්ග අසමතුලිතතාවය නිසා ඇතිවන සංග්‍රහණ දෝෂ

සාමාන්‍ය අවස්ථාව

සත්‍ය සහ අසත්‍ය ප්‍රතිඵල වර්ගවලට වෙනස් නම්, ත‍්‍රි‑අංග ක්‍රියාකාරකම සංග්‍රහණ දෝෂයක් ඇති කරයි.

// This will cause an error
boolean isAdmin = true;
Object role = isAdmin ? "Admin" : 0;

මෙහි, "Admin" යනු String එකක්, 0 යනු int එකක්, එබැවින් වර්ග නොගැලපේ.

සකස් කිරීමේ ක්‍රම

දෙකම ප්‍රකාශන එකම වර්ගයක් ආපසු ලබා දෙන බවට සහතික වන්න.

Object role = isAdmin ? "Admin" : "User";

අවශ්‍ය නම්, Object වැනි පොදු පියාම පන්තියක් භාවිතා කර වර්ග වෙනස්කම් අඩු කළ හැක.

Null අගයන් ගැන සැලකිල්ලෙන් සිටින්න

සාමාන්‍ය අවස්ථාව

null අගයන් සමඟ ත‍්‍රි‑අංග ක්‍රියාකාරකම භාවිතා කිරීම NullPointerException එකක් ඇති කරයි.

String input = null;
String result = input.equals("OK") ? "Success" : "Failure"; // This throws an exception

මෙහි, input යනු null වුවත් equals ක්‍රියාවලිය තවමත් කැඳවයි.

සකස් කිරීමේ ක්‍රම

පළමුව null පරීක්ෂා කරන්න:

String result = ("OK".equals(input)) ? "Success" : "Failure";

equals ක්‍රියාවලිය පදනම් පදයක් (literal string) මත කැඳවීම, input null වුවත් ආරක්ෂිත වේ.

ක්‍රියාකාරකම් ප්‍රමුඛත්වය නිසා ඇතිවන අනපේක්ෂිත හැසිරීම

සාමාන්‍ය අවස්ථාව

ත‍්‍රි‑අංග ක්‍රියාකාරකම බොහෝ අනෙකුත් ක්‍රියාකාරකම් වලට වඩා අඩු ප්‍රමුඛත්වයක් ගනී, එබැවින් වරහන් (parentheses) නොමැතිව එය අපේක්ෂිත ලෙස ක්‍රියා නොකරනු ඇත.

int a = 10, b = 20;
System.out.println("Result: " + a > b ? "A" : "B"); // Not as intended

මෙහි, "Result: " + a පළමුව ගණනය කර, පසුදා b සමඟ සැසඳේ, එය තේරුම්ගත නොහැක.

සකස් කිරීමේ ක්‍රම

වගකීම් අනුක්‍රමය පැහැදිලි කිරීම සඳහා වරහන් (parentheses) සෑම විටම භාවිතා කරන්න.

System.out.println("Result: " + ((a > b) ? "A" : "B"));

This way, a > b is evaluated first.

බොහෝ නෙස්ට් කිරීමෙන් පසු කියවීමට ඇති ගැටළු

සාමාන්‍ය අවස්ථාව

තර්නරි නෙස්ට් කිරීමේ බහු මට්ටම් කේතය කියවීමට අසීරු කරයි, වාක්‍ය රීතිකව නිවැරදි වුවත්.

String label = flag1 ? "A" : flag2 ? "B" : flag3 ? "C" : "D"; // Hard to read

විසඳුම්

• සංකීර්ණ තර්ක සඳහා if-else වෙත මාරු කරන්න
• ඔබට නෙස්ට් කිරීමේ මට්ටම් දෙකකට වඩා වැඩි අවශ්‍ය නම්, ඔබේ කේතය ප්‍රතිරූපනය කරන්න

  String label;
  if (flag1) {
      label = "A";
  } else if (flag2) {
      label = "B";
  } else if (flag3) {
      label = "C";
  } else {
      label = "D";
  }
  

සාරාංශය: තර්නරි මෙහෙයුම්කරු ආරක්ෂිතව භාවිතා කරන ආකාරය

7. සාමාන්‍ය ප්‍රශ්න (FAQ)

තර්නරි මෙහෙයුම්කරු පහසුය, නමුත් එය ආරම්භකයන් සහ මධ්‍යම මට්ටමේ දැනුම ඇති අය අතර සාමාන්‍ය ප්‍රශ්න උත්පාදනය කරයි. මෙන්න Java ඉගෙනුම්කරුවන් සහ සංවර්ධකයන්ගෙන් ලබාගත් සමහර FAQ.

ප්‍ර.1. මට if ප්‍රකාශයක් වෙනුවට තර්නරි මෙහෙයුම්කරු භාවිතා කළ යුත්තේ කවදාද?

ප. කොන්දේසිය සරල වන අතර ප්‍රතිඵලය එක පියවරකින් පවරා හෝ ප්‍රදර්ශනය කළ හැකි නම්, තර්නරි මෙහෙයුම්කරු ප්‍රයෝජනවත් වේ. බහු-පේළි හෝ සංකීර්ණ තර්ක සඳහා, වැඩි කියවීමට සහ නඩත්තු කිරීමට if ප්‍රකාශයක් භාවිතා කරන්න.

ප්‍ර.2. තර්නරි මෙහෙයුම්කරු නෙස්ට් කිරීම සම්මතද?

ප. නෙස්ට් කිරීම තාක්ෂණිකව ඉඩ ඇත, නමුත් කියවීමට හැකියාව ගැඹුරු ලෙස අඩුවේ. ඔබට අවශ්‍ය නම්, ඉන්ඩෙන්ටේෂන් සහ අදහස් භාවිතා කර පැහැදිලි කිරීම වැඩි කරන්න. මට්ටම් තුනක් හෝ ඊට වැඩි නම්, if-else ප්‍රකාශ වෙත මාරු කිරීම සලකා බලන්න.

ප්‍ර.3. තර්නරි මෙහෙයුම්කරු වෙනත් භාෂා වලද පවතීද?

ප. ඔව්. JavaScript, C, C++, PHP, සහ Python (වෙනත් ව්‍යවස්ථාවක් සමඟ) වැනි බොහෝ භාෂා තර්නරි මෙහෙයුම්කරු ඇත. Java හි, ආකාරය condition ? expr1 : expr2 වන අතර, Python හි එය expr1 if condition else expr2 වේ.

ප්‍ර.4. තර්නරි මෙහෙයුම්කරු කාර්ය සාධනයට බලපාද?

ප. එතරම් නොවේ. තර්නරි මෙහෙයුම්කරු if-else ප්‍රකාශවලට සමාන ලෙස ක්‍රියා කරයි, එබැවින් සංක්ෂිප්තභාවය සහ කියවීමට පහසුව සඳහා භාවිතා කරන්න, වේගය සඳහා නොවේ.

ප්‍ර.5. null අගයන් භාවිතා කරන විට දෝෂ වලින් කොහොමද වැළැක්විය හැක්කේ?

ප. ඔබ null විය හැකි විචල්‍යයක .equals() භාවිතා කරන්නේ නම්, NullPointerException එකක් ලැබිය හැක. මෙය වැළැක්වීමට, string literal එකේ equals ක්‍රියාව භාවිතා කරන්න හෝ පළමුව null බව පරීක්ෂා කරන්න.

ප්‍ර.6. ප්‍රතිඵලය void ක්‍රමයක් වන විට තර්නරි මෙහෙයුම්කරු භාවිතා කළ හැද?

ප. නැත. තර්නරි මෙහෙයුම්කරු අගයක් ලබා දෙන ප්‍රකාශන සඳහාය. void-ආපසු ලබා දෙන ක්‍රම හෝ ක්‍රියා සඳහා, if ප්‍රකාශයක් භාවිතා කරන්න.

ප්‍ර.7. තර්නරි මෙහෙයුම්කරු පමණක් ප්‍රදර්ශනය සඳහා භාවිතා කළ හැද?

ප. නියමයෙන්. ඔබට එය System.out.println() තුළ භාවිතා කර පණිවුඩයන් පහසුවෙන් මාරු කළ හැක.

System.out.println(isSuccess ? "Operation succeeded" : "Operation failed");

එය කෙටි ප්‍රදර්ශන වෙනස්කම් සඳහා විශේෂයෙන් ප්‍රයෝජනවත් වේ.

ප්‍ර.8. තර්නරි මෙහෙයුම්කරු කී වරක් නෙස්ට් කළ හැකිය?

ප. තාක්ෂණික සීමාවක් නැත, නමුත් ප්‍රායෝගිකව 1–2 මට්ටම් පමණක් තබා ගන්න. එයට වඩා වැඩි නම්, කියවීමට if-else භාවිතා කිරීම වඩා හොඳය. සමහර කණ්ඩායම් තම කේතන ප්‍රමිතීන්හි ගැඹුරු නෙස්ට් කිරීම සීමා කරති.

8. නිගමනය

මෙම ලිපිය Java තර්නරි මෙහෙයුම්කරු පැහැදිලි කරයි, ව්‍යවස්ථා මූලිකතා සිට ප්‍රායෝගික භාවිතය, සාමාන්‍ය දෝෂ, සහ FAQ දක්වා සියල්ල ආවරණය කරයි. ඔබ ඉගෙන ගත් දේ සාරාංශ කර, ඉදිරියේදී එය කෙසේ යොදා ගත හැකිද බලමු.

තර්නරි මෙහෙයුම්කරු මූලිකතා සාරාංශය

තර්නරි මෙහෙයුම්කරු සරල ව්‍යවස්ථාවක් ඇත, එය කොන්දේසිය මත අගයක් ලබා දේ:

condition ? expression1 : expression2;

එය if-else සඳහා සංක්ෂිප්ත විකල්පයකි, විශේෂයෙන් අග තේරීම සඳහා. මතක තබා ගන්න, එය අග අතර මාරු කිරීම සඳහාය—ශාඛාගත තර්ක හෝ ක්‍රියාවලීන් සඳහා නොවේ.

තර්නරි මෙහෙයුම්කරු ප්‍රයෝජනවත් වන අවස්ථා

• කොන්දේසිය මත පෙන්වීමේ පණිවුඩ හෝ සැකසුම් මාරු කිරීමට අවශ්‍ය වන විට
• පවරා ගැනීම් සංක්ෂිප්ත කිරීමට අවශ්‍ය වන විට
• සරල ප්‍රදර්ශන ප්‍රකාශන ලිවීමට අවශ්‍ය වන විට

නමුත් නෙස්ට් කිරීම හෝ සංකීර්ණ තර්ක සඳහා, if-else වඩා හොඳය.

තර්නරි මෙහෙයුම්කරු ආරක්ෂිතව භාවිතා කිරීම සඳහා උපදෙස්

. වර්ගයන් සමග සමානව තබා ගන්න : දෙකම එකම වර්ගය ලබා දිය යුතුය
null අගයන් සැලකිල්ලෙන් හසුරවන්න : NullPointerExceptions වලින් වැළැක්වීමට
ප්‍රමුඛත්වය පැහැදිලි කරන්න : අවශ්‍ය විට වෘත්තකෝණ භාවිතා කරන්න
කියවීමට පහසුකම ප්‍රමුඛ කරගන්න : අන් අය පහසුවෙන් තේරුම් ගත හැකි කේතයක් ලියන්න

තවත් ඉගෙනුම සඳහා

Java හි පළමු අවස්ථාවේ ternary operator එක පෙනේ, එහි ප්‍රායෝගික භාවිතය පුළුල් වන අතර, සැබෑ ව්‍යාපෘතිවල සාමාන්‍යය වේ.
ඉදිරියට, ඔබට අධ්‍යයනය කිරීමට අවශ්‍ය විය හැක:

• switch සහ ternary අතර කවදා භාවිතා කළ යුතුද
• ලැම්බ්ඩා හෝ Optionals භාවිතා කරන රටා
• වෙනත් වැඩසටහන් භාෂා වල ternary operator කෙසේ ක්‍රියා කරයි

අවසාන අදහස්

ඔබ ternary operator එක පරිපූර්ණව අධ්‍යයනය කළ පසු, ඔබේ කේතය තවත් බුද්ධිමත් වන අතර මුළු කියවීමට පහසුකම සහ නඩත්තුකිරීමේ හැකියාව වැඩිදියුණු කරයි.
ගැලපෙන්නේ “සින්තැක්ස් දැන ගැනීම” පමණක් නොව “එය සුදුසු ලෙස භාවිතා කිරීම” ය. ඔබේ දිනපතා කේත කිරීමේදී මෙම දැනුම ප්‍රයෝජනවත් කරගන්න!