Java ඔපරේටර් සම්පූර්ණ මාර්ගෝපදේශය: වර්ග, භාවිත උදාහරණ, ප්‍රමුඛත්වය, පොදු දෝෂ, සහ හොඳම ක්‍රම

1. විෂය පරිච්ඡේදය

ජාවා යනු ව්‍යාපාරික පද්ධති, වෙබ් යෙදුම් සහ ඇන්ඩ්‍රොයිඩ් යෙදුම් සංවර්ධනය ඇතුළු විවිධ ක්ෂේත්‍රවල භාවිතා වන ඉතා ජනප්‍රිය ක්‍රමගත භාෂාවකි. ජාවා ඉගෙන ගන්නා විට ඔබට මුලින්ම හමුවන මූලික අංගවලින් එකක් වන්නේ “operator” යි. Operators යනු වැඩසටහනක ගණනය කිරීම් හෝ සංසන්දනයන් සිදු කිරීම සඳහා භාවිතා වන අත්‍යවශ්‍ය සංකේත සහ නීති වන අතර, ඒවා ඕනෑම ජාවා කේත පදනමක නිතර පෙන්වයි.

“Java operators” යන මූලික වචනය සෙවීමේදී බොහෝ පුද්ගලයින් මුහුණ දෙන ප්‍රශ්න මෙසේ විය හැක:

• Operators වල විවිධ වර්ග සහ අර්ථයන් සංවිධානය කිරීමට අවශ්‍ය වීම
• Operators භාවිතා කරන ආකාරයේ නිශ්චිත උදාහරණ දැකීමට අවශ්‍ය වීම
• Operators අතර වෙනස්කම් සහ අවවාද සම්බන්ධයෙන් තේරුම් ගැනීමට අවශ්‍ය වීම

මෙම ලිපිය ජාවාහිදී භාවිතා වන ප්‍රධාන operators පිළිබඳ විස්තරාත්මකව පැහැදිලි කරයි, මූලික සිට ප්‍රායෝගික යෙදුම් දක්වා සියල්ල ආවරණය කරමින්, පැහැදිලි සහ ආරම්භකයින්ට හිතකර ආකාරයකින්. එය බහුලව සිදුවන දෝෂ, වැදගත් සලකා බැලීම් සහ සැබෑ ලෝක සංවර්ධනය සඳහා උපකාරී උපදෙස් සාරාංශගත කරයි. Operators ප්‍රවේශ කිරීම යනු කළමනාකරණය කළ හැකි සහ දෝෂ අඩු කේත ලිවීමේ පළමු පියවර වේ.

ඔබ ජාවා ආරම්භ කරන්නේද හෝ මූලික දේ පුනරීක්ෂා කරන්නේද යන බව සලකා නොවේ, මෙම ලිපිය ඔබේ “ප්‍රධාන යොමුකිරීම” ලෙස ක්‍රියා කිරීමට අරමුණු කරයි, ඔබ ගැටලුවකට මුහුණ දුන් විට. උදාහරණ සහ සිතිසිලිකරණ සමඟ, අපි ජාවා operators හරියටම තේරුම් ගැනීමට ඔබට උපකාර කරන්නෙමු.
අවසානය දක්වා කියවන්න සහ ජාවා operators පිළිබඳ ඔබේ ප්‍රවේශය ශක්තිමත් කරන්න.

2. ජාවා Operators විශ්ලේෂණය (වේගවත් යොමුකිරීම් පිළිවෙල සමඟ)

ජාවා විවිධ අරමුණු අනුව වර්ගීකරණය කරන ලද operators විවිධත්වයක් ලබා දෙයි. මෙහිදී, අපි ජාවාහිදී භාවිතා වන නියෝජිත operators සංවිධානය කරමු, ඔබට මහා රූපය ග්‍රහණය කිරීමට උපකාර කිරීම සඳහා. පළමුව, සෑම operator එකකින්ම භූමිකාව සහ සංකේතනය එක බැල්මකින් පෙන්වන වේගවත් යොමුකිරීම් පිළිවෙලක් බලමු.

ජාවා Operator වේගවත් යොමුකිරීම් පිළිවෙල

ජාවා operators ගණනය කිරීම්, සංසන්දනයන් සහ කොන්ඩිෂනල් බ්‍රැන්චිං වැනි විවිධ තත්ත්වයන්හි භාවිතා වේ. ගණිතමය, පැවරුම්, සංසන්දන සහ ලොජිකල් operators ඇති කිසියම් වැඩසටහනකදීද ඇති වේ.

බිට්වයිස් operators, තර්ණාන්තර operator සහ instanceof operator වඩාත් උසස් වන නමුත්, ඒවා ඉගෙන ගැනීම ජාවාහිදී ඔබේ ප්‍රකාශන ශක්තිය බොහෝ දුරට ව්‍යාප්ත කරයි.

ඉදිරි කොටස්වලදී, අපි සෑම operator කාණ්ඩයක්ම පැහැදිලි කරන්නෙමු, ඔබට ක්ෂණිකව භාවිතා කළ හැකි ප්‍රායෝගික උදාහරණ සමඟ.

3. සෑම Operator කාණ්ඩයකම පැහැදිලි කිරීම සහ ප්‍රායෝගික උදාහරණ

ජාවා විවිධ වර්ගයේ operators බොහෝක් ලබා දෙයි. මෙම කොටසේදී, අපි සෑම කාණ්ඩයකම භාවිතය, ලක්ෂණ, උදාහරණ සහ බහුලව සිදුවන අඩුපාඩු පැහැදිලි කරමු. සෑම operator වර්ගයකම වෙනස් හැසිරීම හරියටම තේරුම් ගන්නා බව සහතික කරන්න.

3-1. ගණිතමය Operators (+, -, *, /, %)

ගණිතමය operators භාවිතා වන්නේ සංඛ්‍යාත්මක ගණනය කිරීම් සිදු කිරීමටයි. ඒවා එකතුව, අඩුව, ගුණනය, ඩිවිෂන් සහ අවශේෂ ගණනය කිරීම් වැනි කාර්යයන් සඳහා මූලික මෙහෙයුම් වේ.

• + (එකතුව): දෙකම සංඛ්‍යාත්මක වටිනාකම් එකතු කරයි. විලාසයන් සමඟ භාවිතා කළ විට, එය සම්බන්ධකරණය සිදු කරයි.
• - (අඩුව): දෙකකින් සංඛ්‍යා දෙකක වෙනස ගණනය කරයි.
• * (ගුණනය): සංඛ්‍යා දෙක ගුණ කරයි.
• / (ඩිවිෂන්): වම් operand යම් දකුණු operand මගින් ඩිවිඩ් කරයි. සම්පූර්ණාංක ඩිවිෂන් දශමස්ථානික කොටස ඉවත් කරයි.
• % (මෝඩුලෝ): ඩිවිෂන්කරණයක අවශේෂය ආපසු ලබා දෙයි.

උදාහරණය:

int a = 10;
int b = 3;
System.out.println(a + b); // 13
System.out.println(a - b); // 7
System.out.println(a * b); // 30
System.out.println(a / b); // 3 (decimal part is discarded)
System.out.println(a % b); // 1

සටහන්:

• int වටිනාකම් අතර ඩිවිෂන් සම්පූර්ණාංක ප්‍රතිඵලයක් ලබා දෙයි (දශමස්ථානික කොටස ඉවත් කරයි).
• විලාසයන් සමඟ + operator භාවිතා කිරීම ගණිතමය එකතුව නොව සම්බන්ධකරණයක් ජනනය කරයි.

3-2. පැවරුම් Operators (=, +=, -=, *=, /=, %=)

පැවරුම් operators භාවිතා වන්නේ විචල්‍යයක වටිනාකම සකස් කිරීමට හෝ යාවත්කාලීන කිරීමටයි. සංයෝජිත පැවරුම් operators කේතය වඩාත් සංක්ෂිප්ත කිරීමට උපකාරී වේ.

• = (පැවරුම): දකුණු පැත්තේ වටිනාකම වම් පැත්තේ විචල්‍යයට පැවරයි.
• += (එකතු කර පැවරුම): දකුණු පැත්තේ වටිනාකම එකතු කර ප්‍රතිඵලය නැවත පැවරයි.
• අනෙකුත් සංයෝජිත operators ඇතුළත් වන්නේ -= , *= , /= , %= .

උදාහරණය:

int x = 5;
x += 3;  // Equivalent to x = x + 3 → x becomes 8
x *= 2;  // Equivalent to x = x * 2 → x becomes 16

ප්‍රධාන කරුණ:

• සංයුක්ත අනුයෝජන ක්‍රියාකාරකම් (compound assignment operators) නැවත නැවත ගණනය කිරීමේ හෝ ලූප් මෙහෙයුම් වල විශේෂයෙන් ප්‍රයෝජනවත් වේ.

3-3. සසඳන ක්‍රියාකාරකම් (==, !=, >, <, >=, <=) සහ instanceof

සසඳන ක්‍රියාකාරකම් අගයන් නියමිත කොන්දේසි සපුරාලනවාදැයි පරීක්ෂා කරයි.

• == (සමාන): අගයන් දෙක සමානදැයි පරීක්ෂා කරයි.
• != (සමාන නොවන): අගයන් දෙක වෙනස්දැයි පරීක්ෂා කරයි.
• > , < , >= , <= : ප්‍රමාණය සසඳීම.
• instanceof : වස්තුවක් නියමිත වර්ගයක උදාහරණයක්දැයි පරීක්ෂා කරයි.

උදාහරණය:

int a = 5, b = 7;
System.out.println(a == b); // false
System.out.println(a < b);  // true

String str = "hello";
System.out.println(str instanceof String); // true

වැදගත් සටහන:

• ස්ට්‍රින් හෝ වස්තු වල අන්තර්ගතය සසඳීමට equals() භාවිතා කරන්න. == ක්‍රියාකාරකම යොමුකිරීම් (references) සසඳයි (එකම උදාහරණයක් යොමු කර තිබේදැයි).

3-4. තාර්කික ක්‍රියාකාරකම් (&&, ||, !)

සංයුක්ත කොන්දේසි ඇගයීමට අවශ්‍ය වන විට තාර්කික ක්‍රියාකාරකම් භාවිතා කරයි.

• && (AND): දෙකම කොන්දේසි සත්‍ය නම් පමණක් true ලබා දේ.
• || (OR): අවම වශයෙන් එක් කොන්දේසියක් සත්‍ය නම් true ලබා දේ.
• ! (NOT): බූලියන් අගයක් ප්‍රතිලෝම කරයි.

උදාහරණය:

int age = 20;
boolean isMember = true;
System.out.println(age >= 18 && isMember); // true
System.out.println(!(age < 18));           // true

කෙටි-පථ ඇගයීම:

• && සහ || වම්පාර්ශ්වයේ (right-hand side) ඇගයීම අත්හිටුවයි, වමපාර්ශ්වයේ කොන්දේසිය ප්‍රතිඵලය තීරණය කර ඇති විට.

3-5. බිට්-මට්ටමේ ක්‍රියාකාරකම් (&, |, ^, ~, <<, >>, >>>)

බිට්-මට්ටමේ ක්‍රියාකාරකම් පූර්ණ සංඛ්‍යා අගයන් බිට් මට්ටමේ පරිවර්තනය කරයි. පද්ධති සංවර්ධනය හෝ කාර්ය සාධන-අත්‍යවශ්‍ය සැකසීමේදී ඒවා ප්‍රයෝජනවත් වේ.

• & (AND): දෙකම බිට් 1 නම් පමණක් 1 ලබා දේ.
• | (OR): ඕනෑම බිට් එකක් 1 නම් 1 ලබා දේ.
• ^ (XOR): බිට් එකක් පමණක් 1 නම් 1 ලබා දේ.
• ~ (NOT): සියලු බිට් පළලේ වෙනස් කරයි.
• << (වමට සර්කය): බිට් වමට සර්කයි.
• >> (දකුණට සර්කය): අත්සන් සමඟ දකුණට සර්කයි.
• >>> (අත්සන් රහිත දකුණට සර්කය): අත්සන් රහිතව දකුණට සර්කයි.

උදාහරණය:

int x = 5;   // 0101
int y = 3;   // 0011
System.out.println(x & y); // 1 (0001)
System.out.println(x | y); // 7 (0111)
System.out.println(x ^ y); // 6 (0110)
System.out.println(~x);    // -6
System.out.println(x << 1); // 10

3-6. වැඩි කිරීම සහ අඩු කිරීම ක්‍රියාකාරකම් (++, –)

මෙම ක්‍රියාකාරකම් විචල්‍යයක අගය 1කින් වැඩි හෝ අඩු කරයි. පෙර-වැඩි කිරීම (pre) සහ පසු-වැඩි කිරීම (post-increment) වෙනස් ලෙස ක්‍රියා කරයි.

• ++ : 1කින් වැඩි කරයි.
• -- : 1කින් අඩු කරයි.

උදාහරණය:

int i = 0;
i++; // i becomes 1
++i; // i becomes 2

පෙර vs පසු:

• ++i පළමුව වැඩි කරයි, පසු අගය ලබා දේ.
• i++ වත්මන් අගය ලබා දේ, පසු වැඩි කරයි.

3-7. ත්‍රි-අංග ක්‍රියාකාරකම (? 🙂

ත්‍රි-අංග ක්‍රියාකාරකම (ternary operator) ඔබට කොන්දේසි තර්කයක් සංග්‍රහිත එක්-පේළි ප්‍රකාශයක් ලෙස ලිවීමට ඉඩ දෙයි.

වින්‍යාසය:

condition ? value_if_true : value_if_false

උදාහරණය:

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

ඉඟිය:

• කේතය සරල කරගත හැකි නමුත් සංකීර්ණ කොන්දේසි සඳහා එය අධික ලෙස භාවිතා කිරීමෙන් වැළකී සිටින්න.

4. ක්‍රියාකාරකම් ප්‍රමුඛත්වය සහ සම්බන්ධතාවය

එකම ප්‍රකාශයක බහු ක්‍රියාකාරකම් පෙනී සිටින විට, Java ඒවා “ක්‍රියාකාරකම් ප්‍රමුඛත්වය” (operator precedence) නම් නියමිත නීති අනුව ඇගයයි. එසේම, එකම ප්‍රමුඛත්වය ඇති ක්‍රියාකාරකම් එකට පෙනී සිටින විට, ඒවා ඇගයීමේ ක්‍රමය “සම්බන්ධතාවය” (associativity) මගින් තීරණය වේ. ඔබ මෙම නීති වැරදි ලෙස තේරුම් ගතහොත්, ඔබේ කේතය අනපේක්ෂිත ප්‍රතිඵල හෝ දෝෂ පෙන්විය හැක.

4-1. ක්‍රියාකාරකම් ප්‍රමුඛත්ව වගුව

පහත වගුව Java හි ප්‍රධාන ක්‍රියාකාරකම් ප්‍රමුඛත්ව අනුව ශ්‍රේණිගත කරයි. කුඩා අංකයන් ඉහළ ප්‍රමුඛත්වය පෙන්වයි.

4-2. ප්‍රමුඛත්වය සහ සම්බන්ධතාවය දෘශ්‍යමාන කිරීම

පහත ප්‍රකාශය සලකා බලන්න:

int result = 2 + 3 * 4;

* (ගුණනය) + (එකතු කිරීම) ට වඩා ඉහළ ප්‍රමුඛත්වයක් ඇති බැවින්, ගුණනය පළමුව ඇගයෙයි:
3 * 4 = 12,
පසුව 2 + 12 = 14.

4-3. ප්‍රාථමිකත්වය පැහැදිලිව පාලනය කිරීම සඳහා වෘත්තකෝෂ භාවිත කිරීම

ප්‍රකාශනයක් සංකීර්ණ වන විට හෝ පැහැදිලි බව තහවුරු කිරීමට අවශ්‍ය නම්, මූලිකවම වෘත්තකෝෂ () භාවිතා කරමින් ඇගයීමේ ක්‍රමය පැහැදිලිව පාලනය කරන්න.

උදාහරණය:

int result = (2 + 3) * 4; // 2+3 is evaluated first → result becomes 20

4-4. පොදු වැරදි සහ වැදගත් සටහන්

• ප්‍රාථමිකත්වය පිළිබඳ වැරදි අනුමාන අනපේක්ෂිත ප්‍රතිඵල ලබා දිය හැක.

• උදාහරණය: boolean flag = a > 0 && b < 10 || c == 5; wp:list /wp:list

  • && හි || ට වඩා ඉහළ ප්‍රාථමිකත්වයක් ඇති බැවින්, මෙම ප්‍රකාශනය සමාන වේ: (a > 0 && b < 10) || c == 5
  • දෝෂ වැළැක්වීමට, සංකීර්ණ ප්‍රකාශන සඳහා සෑම විටම වෘත්තකෝෂ භාවිතා කරන්න.

ක්‍රියාකාරක ප්‍රාථමිකත්වය සහ සම්බන්ධතාවය නවකයන්ට බොහෝ විට ගැටළුවක් වේ, නමුත් නීති තේරුම් ගත් පසු, ඔබට ඉතා නිරවද්‍ය සහ විශ්වාසනීය Java කේතයක් ලිවිය හැක.

5. පොදු දෝෂ සහ නිතර හමුවන වැරදි

Java ක්‍රියාකාරක සරල බවක් පෙනුනත්, නවකයන් සහ මධ්‍යම මට්ටමේ සංවර්ධකයන්ට නිතර අනපේක්ෂිත හැසිරීම් සහ සුක්ෂ්ම වැරදි සිදුවේ. මෙම කොටස ක්‍රියාකාරක සම්බන්ධ පොදු වාස්තුක දෝෂ සහ සාමාන්‍ය වැරදි සාරාංශ කරයි.

5-1. පූර්ණ සංඛ්‍යා බෙදීමෙන් අනපේක්ෂිත ප්‍රතිඵල

Java හි දෙකේ int අගයන් බෙදාහරින විට, ප්‍රතිඵලය සෑම විටම පූර්ණ සංඛ්‍යාවක් වේ—දශම කොටස ඉවත් කරයි.

int a = 5;
int b = 2;
System.out.println(a / b); // Output: 2

ඔබට දශම ප්‍රතිඵලයක් අවශ්‍ය නම්, මෙවලම් වලින් එකක් double (හෝ float) ලෙස cast කරන්න:

System.out.println((double)a / b); // Output: 2.5

5-2. ද්‍රව්‍ය-බින්දු නිරවද්‍යතාව ගැටළු

double හෝ float භාවිතා කිරීම සුක්ෂ්ම වටාපිටු දෝෂ හඳුන්වා දිය හැක.

double d = 0.1 + 0.2;
System.out.println(d); // Output example: 0.30000000000000004

කඩිනම් නිරවද්‍යතාව අවශ්‍ය ගණනය (උදාහරණයක් ලෙස, මූල්‍ය අගයන්) සඳහා, BigDecimal භාවිතා කරන්න.

5-3. == සහ equals() අතර වෙනස

== සහ equals() අතර වෙනස වැරදි ලෙස තේරුම් ගැනීම, විශේෂයෙන් strings වැනි වස්තු සසඳන විට, ඉතා පොදු වැරදි වේ.

• == : දෙකේ යොමුකිරීම් එකම උදාහරණයක් වෙත යොමු කරයිදැයි සසඳයි.
• equals() : වස්තු වල සැබෑ අන්තර්ගතය (අගය හෝ පෙළ) සසඳයි.

  String s1 = new String("abc");
  String s2 = new String("abc");
  
  System.out.println(s1 == s2);      // false (different instances)
  System.out.println(s1.equals(s2)); // true  (contents are identical)
  

5-4. කෙටි-පථ ඇගයීම නිසා පාර්ශවික ප්‍රතිඵල අහිමි වීම

තර්කීය ක්‍රියාකාරක && සහ || “කෙටි-පථ ඇගයීම” භාවිතා කරයි, එනම් වම් පැත්තේ ප්‍රතිඵලය දැනටමත් තීරණය වූ විට දකුණු පැත්තේ ප්‍රකාශනය අත්හැරේ. මෙම හැසිරීම තේරුම් නොගත් විට, අපේක්ෂිත පාර්ශවික ප්‍රතිඵල (වෙනස්කම් යාවත්කාලීන කිරීම හෝ ක්‍රම ඇමතුම් වැනි) සිදු නොවිය හැක.

int a = 0;
if (a != 0 && 10 / a > 1) {
    // This block is never executed
}

මෙහි, a != 0 වැරදියි (false) බැවින්, 10 / a ප්‍රකාශනය කිසිදාම ඇගයීම නොකෙරේ, ඒ නිසා ශූන්‍යයෙන් බෙදීමේ දෝෂයක් වැළැක්වේ.

5-5. වෘත්තකෝෂ අස්ථානගත කිරීම නිසා වැරදි තර්කය

සංකීර්ණ නියමිත ප්‍රකාශනවල වෘත්තකෝෂ අතුරුදහන් කිරීම, ප්‍රාථමිකත්වය වැරදි ලෙස තේරුම් ගැනීම නිසා, වැරදි ඇගයීම් වෙත හේතු වේ.

boolean flag = a > 0 && b < 10 || c == 5;
// Intended meaning: ((a > 0) && (b < 10)) || (c == 5)
// But depending on context, interpretation may differ

5-6. සාරාංශය

• දත්ත වර්ග (int vs double) සහ සසඳුම් ක්‍රම (== vs equals) සෑම විටම පරීක්ෂා කරන්න.
• සංකීර්ණ ප්‍රකාශන සඳහා වෘත්තකෝෂ භාවිතා කිරීමේ පුරුද්දක් ගොඩනඟන්න.
• කෙටි-පථ ඇගයීම වැනි Java-විශේෂ හැසිරීම් ගැන අවධානයෙන් සිටින්න.

මෙම කරුණු මතක තබා ගතහොත්, Java හි සාමාන්‍ය ක්‍රියාකාරක-සම්බන්ධ දෝෂයන් ගණනාවක් වැළැක්විය හැක.

6. ප්‍රායෝගික උදාහරණ: ක්‍රියාකාරක භාවිතා කරන නියැලූ කේත

මෙම කොටස ප්‍රායෝගික නියැලූ කේතයක් හඳුන්වා දෙයි, Java ක්‍රියාකාරක වාස්තුක දෘශ්‍යයන්හි කෙසේ භාවිතා කරන්නේද යන්න පෙන්වයි. මෙම උදාහරණයන් පොදු භාවිතා අවස්ථා ප්‍රදර්ශනය කරමින්, අවබෝධය ගැඹුරු කර ගැනීමට සහ ප්‍රායෝගික කුසලතා වැඩිදියුණු කිරීමට උපකාරී වේ.

6-1. if ප්‍රකාශනවල සසඳුම් සහ තර්කීය ක්‍රියාකාරක භාවිතය

Comparison and logical operators are essential when combining multiple conditions for branching.

int age = 25;
boolean isMember = true;

if (age >= 18 && isMember) {
    System.out.println("Service is available.");
} else {
    System.out.println("Conditions not met.");
}

6-2. ලූප් වල ඉන්ක්‍රිමෙන්ට් මෙහෙයුම්කරු භාවිතය

ඉන්ක්‍රිමෙන්ට් (++) සහ ඩික්‍රිමෙන්ට් (–) මෙහෙයුම්කරු ලූප් සැකසීමේදී ගණකයන් පාලනය කිරීමේදී නිතර භාවිතා වේ.

for (int i = 0; i < 5; i++) {
    System.out.println("Count: " + i);
}

6-3. තර්නරි මෙහෙයුම්කරු සමඟ කොන්දේසිමය නියෝජනය සරල කිරීම

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

int score = 75;
String result = (score >= 60) ? "Pass" : "Fail";
System.out.println(result); // Pass

6-4. සංයුක්ත නියෝජන මෙහෙයුම්කරු සමඟ කේතය සරල කිරීම

සංයුක්ත නියෝජන මෙහෙයුම්කරු පාරිභෝගික අගයන් නැවත නැවත යාවත්කාලීන කිරීමේදී ප්‍රයෝජනවත් වේ.

int total = 0;
for (int n = 1; n <= 10; n++) {
    total += n; // Equivalent to total = total + n
}
System.out.println("Total: " + total);

6-5. ප්‍රායෝගික බිට්වයිස් මෙහෙයුම්කරු උදාහරණය: ධජ කළමනාකරණය

බිට්වයිස් මෙහෙයුම් බහු ON/OFF ධජයන් කාර්යක්ෂමව කළමනාකරණය කිරීමේදී ප්‍රයෝජනවත් වේ.

int FLAG_READ = 1;   // 0001
int FLAG_WRITE = 2;  // 0010
int FLAG_EXEC = 4;   // 0100

int permission = FLAG_READ | FLAG_WRITE; // 0011

// Check if write permission exists
if ((permission & FLAG_WRITE) != 0) {
    System.out.println("Write permission granted.");
}

6-6. වාස්තුක තත්ත්වයන්හි බහු මෙහෙයුම්කරු එකතු කිරීම

කොන්දේසි සංකීර්ණ වන විට, අර්ථගත ගැටළු වැළැක්වීමට වටකුරු (parentheses) භාවිතා කරන්න.

int a = 3, b = 7, c = 5;
if ((a < b && b > c) || c == 5) {
    System.out.println("Condition satisfied.");
}

6-7. කියවීමට පහසු කේතය ලිවීම සඳහා උපදෙස්

• සංකීර්ණ ප්‍රකාශන කුඩා, කියවීමට පහසු කොටස් ලෙස බෙදන්න.
• ගණනයේ අනුක්‍රමය පැහැදිලි කිරීමට වටකුරු (parentheses) භාවිතා කරන්න.
• චරිත නාමයන් දී, අදහස පැහැදිලිව පෙන්වන අදහස් ලියන්න.

ඔබම මෙම නියැලූ වැඩසටහන් ධාවනය කිරීමෙන් මෙහෙයුම්කරු පිළිබඳ ඔබේ අවබෝධය ගැඹුරු වේ. ඔබට මෙහෙයුම්කරු නිදහස්ව යොදා ගැනීමට හැකි වූ පසු, ජාවා සංවර්ධනය වැඩි කාර්යක්ෂමතාවක් සහ රසවත් බවක් ලබා ගනී.

7. සාරාංශය

මෙතෙක්, අපි ජාවා භාවිතා කරන ප්‍රධාන මෙහෙයුම්කරු පිළිබඳව—මූලික සංකල්ප වලින් ප්‍රායෝගික යෙදුම් දක්වා—ආවරණය කර ඇත. මෙහෙයුම්කරු වැඩසටහන් තුළ ගණනය, ඇගයීම සහ දත්ත සැකසීම සඳහා මූලික වේ. ඒවා නිවැරදිව අවබෝධ කර නිවැරදිව භාවිතා කිරීමෙන් වැඩි කාර්යක්ෂම සහ දෝෂ රහිත කේත ලිවීම සලස්වයි.

7-1. මෙම ලිපියේ සමාලෝචනය

• ජාවා අංකගණිත, නියෝජන, සසඳන, තාර්කික, බිට්වයිස්, තර්නරි, ඉන්ක්‍රිමෙන්ට්/ඩික්‍රිමෙන්ට්, සහ instanceof වැනි බොහෝ මෙහෙයුම්කරු වර්ග ලබා දේ; ඒවා සෑම එකක්ම වෙනස් අරමුණු සහ හැසිරීම් සපයයි.
• මෙහෙයුම්කරු ප්‍රමුඛත්වය, සම්බන්ධතාවය, සහ කෙටි-පථ (short‑circuit) ඇගයීම වැනි ජාවා‑විශේෂ නීති දැන ගැනීමෙන් අනපේක්ෂිත දෝෂ වැළැක්වීමට උපකාරී වේ.
• if ප්‍රකාශ, ලූප්, සහ කොන්දේසිමය ශාඛාකරණ වැනි ප්‍රායෝගික උදාහරණ මඟින් ඉගෙනීමෙන් අවබෝධය ගැඹුරු වේ.
• දත්ත වර්ග අතර ගැලපීමේ ගැටළුවක් හෝ වස්තු සසඳීමේදී == වෙනුවට equals() භාවිතා කිරීම වැනි පොදු දෝෂ ගැන අවධානයෙන් සිටීම වැදගත් වේ.

7-2. අධ්‍යයන උපදෙස්

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

ජාවා මෙහෙයුම්කරු මූලික කරුණු පාලනය කිරීමෙන් ඔබට ඕනෑම ජාවා වැඩසටහනක් මත වැඩ කිරීමේ විශ්වාසය ලැබේ. මෙම දැනුම ඔබේ අඛණ්ඩ අධ්‍යයනය සහ සංවර්ධනයට සහාය වීමට භාවිතා කරන්න.

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

මෙම කොටස ජාවා මෙහෙයුම්කරු පිළිබඳ ඉගෙනුම්කරුවන් සහ ක්‍රියාත්මක සංවර්ධකයන්ගෙන් ඇති නිතර අසන ප්‍රශ්න ආවරණය කරයි. මෙම පිළිතුරු ඔබේ අවබෝධය ශක්තිමත් කර, සැකයන් ඉක්මනින් විසඳීමට භාවිතා කරන්න.

ප්‍රශ්න 1. විලාසයන් සංයෝජනය කිරීම සඳහා භාවිතා වන ක්‍රියාකාරකය කුමක්ද?
උත්තර 1. විලාසයන් සංයෝජනය කිරීම සඳහා + ක්‍රියාකාරකය භාවිතා වේ.
උදාහරණයක් ලෙස, "Hello" + " World" යන්නෙන් "Hello World" ප්‍රතිඵලය ලැබේ.
විලාසයක් සහ සංඛ්‍යාවක් සංයෝජනය කිරීමේදී, ප්‍රතිඵලය විලාසයක් බවට පත් වේ.

ප්‍රශ්න 2. == ක්‍රියාකාරකය සහ equals() ක්‍රමය අතර වෙනස කුමක්ද?
උත්තර 2.

• == දෙකම එකම වස්තු ආකෘතියට යොමු වන යොමුකිරීම් සංසන්දනය කරයි.
• equals() වස්තු තුළ ඇති අන්තර්ගතය සංසන්දනය කරයි.

විලාසය වැනි වස්තු සඳහා, වටිනාකම් සංසන්දනය කිරීමට අවශ්‍ය නම් සැමවිටම equals() භාවිතා කරන්න.

ප්‍රශ්න 3. පෙරගෑ ( ++i ) සහ පිටගෑ ( i++ ) වැඩිකිරීම් ක්‍රියාකාරක අතර වෙනස කුමක්ද?
උත්තර 3.

• පෙරගෑ ( ++i ): වටිනාකම පළමුව වැඩි කර, ඉන්පසු යාවත්කාලීන වූ වටිනාකම ආපසු ලබා දෙයි.
• පිටගෑ ( i++ ): වර්තමාන වටිනාකම පළමුව ආපසු ලබා දෙන අතර, ඉන්පසු වැඩි කරයි.

  int i = 5;
  System.out.println(++i); // Outputs 6
  System.out.println(i++); // Outputs 6, then i becomes 7
  

ප්‍රශ්න 4. තාර්කික ක්‍රියාකාරකවල කෙටි-සංඛ්‍යාලේඛන මූල්‍යනය යනු කුමක්ද?
උත්තර 4. තාර්කික ක්‍රියාකාරක && සහ || වම් පැත්තේ ප්‍රකාශනයෙන් අවසාන ප්‍රතිඵලය තීරණය වූ විට, දකුණු පැත්තේ ප්‍රකාශනය මූල්‍යනය කිරීම නොකර හරිනවා.
මෙය අනවශ්‍ය ගණනය කිරීම් වළක්වා, කිසිවකුම සීරෝ මගින් බෙදීම වැනි සම්භාව්‍ය දෝෂ වළක්වයි.

ප්‍රශ්න 5. මම ක්‍රියාකාරක ප්‍රමුඛත්වය පැහැදිලිව වෙනස් කරන්නේ කෙසේද?
උත්තර 5. පරිශීලන () භාවිතා කරන්න.
පරිශීලන තුළ ඇති කොටස පළමුව මූල්‍යනය කිරීමට බල කරයි, සංකීර්ණ ප්‍රකාශන පැහැදිලි සහ ආරක්ෂිත බවට පත් කරයි.

int result = (2 + 3) * 4; // 2+3 is evaluated first

ප්‍රශ්න 6. බිට්-වයිස් ක්‍රියාකාරක භාවිතා වන තත්ත්වයන් කුමක්ද?
උත්තර 6. බිට්-වයිස් ක්‍රියාකාරක මේවායේ උපකාරී වේ:

• සංඥා කළමනාකරණය
• හාඩ්වෙයා-පෙළ මට්ටම් පාලනය
• කාර්ය සාධනය-අනුකූල කරණ ගණනයන්

උදාහරණයක් ලෙස, ඒවා එකම ගුණාංග සංඛ්‍යාවක බහු ON/OFF තත්ත්වයන් කාර්යක්ෂමව ගබඩා කිරීමට ඉඩ සලසයි.

ප්‍රශ්න 7. මට ජාවාහි මගේම ක්‍රියාකාරක නිර්වචනය කළ හැකිද?
උත්තර 7. ජාවා C++ වැනි නව ක්‍රියාකාරක නිර්වචනය කිරීම හෝ ක්‍රියාකාරක බරකිරීම සඳහා සහාය නොදක්වයි.
කෙසේ වෙතත්, ඔබේම ක්‍රම නිර්මාණය කිරීමෙන් සමාන හැසිරීම ක්‍රියාත්මක කළ හැකිය.

ඔබ පුහුණුව දිගටම කරන විට වෙනත් ප්‍රශ්න ඇති විය හැකිය. එවිට සිදු වන විට, ඔබේ අවබෝධය ගැඹුරු කිරීම සඳහා නිල ලේඛන හෝ විශ්වාසනීය ඉගෙනුම් සම්පත්වලට යොමු වන්න.

9. යොමු සබැඳි සහ නිල බාහිර සම්පත්

ජාවා ක්‍රියාකාරක ගැඹුරින් ගවේෂණය කිරීමට හෝ නිල විනිශ්චයන් තහවුරු කිරීමට අවශ්‍ය වන කියවන්නන් සඳහා, විශ්වාසනීය යොමු සහ ඉගෙනුම් සම්පත් එකතුවක් මෙහි ඇත. මෙම සබැඳි සැබෑ සංවර්ධනය හෝ පර්යේෂණයේදී ද උපකාරී වේ.

9-1. නිල ලේඛන

• Java SE Documentation (English, Official) ක්‍රියාකාරක විනිශ්චයන්, මූල්‍යන නීති සහ ප්‍රකාශන හැසිරීම් පිළිබඳ සම්පූර්ණ විස්තර.
• Java Platform SE 8 API Documentation (English, Official) විස්තරාත්මක පන්ති සහ ක්‍රම තොරතුරු සෙවීමේදී උපකාරී.

9-2. උපකාරී බාහිර ඉගෙනුම් සම්පත්

• Dotinstall – Java Basics (Japanese) ජාවා මූලික සඳහා ආරම්භකයින්ට හිතකර වීඩියෝ පාඩම්.
• Progate – Java Course (Japanese) ජාවා මූලික පුහුණු කිරීම සඳහා අන්තර්ක්‍රියාකාරීව ක්‍රියාකාරී ඉගෙනුම් වේදිකාවක්.
• Qiita – Java Tag Article List (Japanese) ප්‍රායෝගික උපදෙස්, උදාහරණ සහ නවතම ප්‍රජා දැනුම ඇතුළත්.

9-3. තවදුරටත් අධ්‍යයනය කිරීමට අවශ්‍ය අය සඳහා

• paiza Learning – Java Introductory Course (Japanese)

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

ඉහත සබැඳි 2025 මැයි වන විට ප්‍රධාන ඉගෙනුම් සම්පත් සහ නිල යොමු නියෝජනය කරයි.
අනාගතයේ අන්තර්ගතය සහ URL වෙනස් විය හැකි බැවින්, නවතම යාවත්කාලීන කිරීම් නිතිපතා පරීක්ෂා කරන්න.

මෙම සම්පත් මෙම ලිපිය සමඟ ඒකාබද්ධ කිරීමෙන්, ඔබට ජාවා ක්‍රියාකාරක පිළිබඳ ඔබේ අවබෝධය තවදුරටත් ගැඹුරු කර, ප්‍රායෝගික සංවර්ධන කුසලතා වැඩිදියුණු කළ හැකිය.