Variables සහ Data Types (3 කොටස)

Variables සහ Data Types පාඩමේ ඉතිරි කොටස අද අවසන් කරන්න බලාපොරොත්තු වෙනවා. Variables සහ Data Types 2වන කොටස අවසන් කළේ data types භාවිතයේදී ඇති වන error කිහිපයකින්. අද අපි බලමු ඒ errors ඇති වන ආකාරය සහ ඒවා වලක්වා ගන්නා විදිය.
මේ code එක compile කරලා බලන්න.

class A {
 public static void main(String[] args) {
  byte b = 200;
  System.out.println(b);
 }
}

compile කරන විට පහත දැක්වෙන ආකාරයේ error එකක් ඒවි.

හොඳින් බලන්න error එකේ කියල තියෙන්නේ මොකක්ද කියලා. 

"A.java:3: error: possible loss of precision"
කියලයි error  එක තියෙන්නේ. මේ කියන්නේ, A.java කියන ෆයිල් එකේ 3වන පේලියේ possible loss of precision කියන error එකක් තිබෙනවා කියලයි.
ඊට යටින් ඒ error  එක ඇති වුන තැන පෙන්වනවා. ඊළඟ පේළියෙන්  අදාල error එක පිලිබඳ තවත් තොරතුරක් ලබා දෙනවා.
required: byte - අවශ්‍ය කරන්නේ byte වර්ගයේ දත්තයක්.
found:    int - හමුවූයේ int වර්ගයේ දත්තයක්.

මේ error report එක තුල error එක ඇති වෙන්න හේතුව පැහැදිලිවම සඳහන් කරලා තිබෙනවා. Java ඉගෙන ගැනීමේදී හැම කෙනෙක්ම මේ error එක කියවල තේරුම් ගන්න දැන ගන්න ඕන. Error එකක් ආවම ඒ error එක හොදින් කියවන්න. එතකොට අපිට ඉක්මනින්ම ඒ වැරැද්ද නිවැරිදි කර ගන්න හැකියාව ලැබෙනවා. දැන් අපි බලමු ඉහලින් දක්වපු error එක එන්න හේතුව මොකක්ද කියල.
Error එකේ පහළින්ම කියල තියෙනවා required: byte, found: int කියල. මේ කියන්නේ අදාල variable එකට, අවශ්‍ය byte වර්ගයේ අගයක්. නමුත් වැඩසටහනෙන් ලබා දීල තිබෙන්නේ int අගයක් කියලයි. දැන් බලමු line 3 එකට ගිහින් මේ කතාව ඇත්තද කියල.

byte b = 200;

අපි Variables සහ Data Types 1 කොටසේදී කිවුව byte වර්ගයේ variable එකක ගබඩා කරන්න පුළුවන් වැඩිම අගය 127 කියල. එත් මෙතැනදී අපි වැඩසටහන මගින් bට 200 කියල අගයක් ආදේශ කරලා තියෙනවා. මෙන්න මේක තමයි මේ error එකට හේතුව. 200 වෙනුවට -128ත් 127ත් අතර අගයක් ආදේශ කලොත් මේ error එක එන්නේ නෑ.
අපේ වැඩසටහනට 200 කියන අගය අත්‍යාවශ්‍ය අගයක්නම් අපිට් සිදු වෙනවා byte එකක් වෙනුවට int variable එකක් පාවිච්චි කරන්න.

දැන් අපි බලමු මේ වගේම තවත් program එකක්.

class A {
    public static void main(String[] args) {
        int i = 10;
        byte b = i;
        System.out.println(b);
    }
}

මේ වැඩසටහන compile කරනකොට පහල දැක්වෙන විදියේ error එකක් ඒවි.

වැඩසටහනේ main method එක තුල පළමු පෙලියේදී int වර්ගයේ variable එකක් i නමින් හදල ඒකට 10 කියල අගයක් ආදේශ කරලා තිබෙනවා.

ඊලග පෙලියේදී b නමින් byte වර්ගයේ variable එකක් හදල එයට මුලින් හදපු i ආදේශ කරලා තිබෙනවා.

Error එකේ කියල තියෙන්නේ, A.java:4: error: incompatible types: possible lossy conversion from int to byte කියලයි. මේ error එකට හේතුව පැහැදිලි කරන්න ලේසිම ක්‍රමය Variables සහ Data Types 1 කොටසේ මං උදාහරණ වශයෙන් ගත්ත විවිද ප්‍රමාණයේ භාජන. මේ වැඩසටහන තුල byte b = i; කියන විධානයෙන් කියන්නේ i කියන int වර්ගයේ (ප්‍රමාණයෙන් විශාල) variable එකේ ඇති අගය byte වර්ගයේ b කියන (ප්‍රමාණයෙන් කුඩා) variable එකට ආදේශ කරන්න කියලයි. මේ විධානයෙන් කරන්න කියල තියෙන දේ සමාන කරන්න පුළුවන්, 

 මෙන්න මේ වතුර ටැංකිය(ටැංකිය ඇතුලේ තියෙන වතුර නෙමෙයි), 

 මේ වගේ පොඩි වතුර බෝතලයකට දාන්න කියල දෙන විධානයකට.

int i කියන්නේ උඩින් තියෙන විශාල වතුර ටැංකිය වගේ එකක්නම්, byte b කියන්නේ පහලින් තියෙන පොඩි වතුර බෝතලය වගේ එකක්. int i කියන variable එකට ආදේශ කරපු 10, int වර්ගයේ variable එකට සාපේක්ෂව වතුර බින්දු 4, 5ක් පමණයි. ඔබට හිතේවි, 

"ඉතින්, මේ පොඩි බෝතලෙටත් වතුර බින්දු 4, 5ක් දාන්න පුළුවන්නේ!"

 කියල. 
ඔවු, පුළුවන්! අපි කලින් උදාහරණේදීත් සඳහන් කළා byte වර්ගයේ variable එකකට -128ත් 127ත් අතර ඕනෑම අගයක් ආදේශ කරන්න පුළුවන් කියල. නමුත් මේ වැඩසටහනේදී අපි විධානය ලබා දීල තියෙන්නේ byte b = 10; කියල නෙමෙයි. byte b = i; කියල. i කියන සම්පුර්ණ variable එකම bට අදේශ කරන්න කියලයි විධානය ලබාදීලා තියෙන්නේ. i කියන variable එක(iට ආදේශ කල අගය නෙමෙයි) b කියන variable එකට වඩා විශාල නිසයි මේ error එක එන්නේ.

විශාල වර්ගයේ data type එකක අගයක් ඊට වඩා කුඩා data type එකකින් හදපු variable එකකට ආදේශ කරන්න යන බොහෝ වෙලාවලදී මේ විදියේ errors එන්න පුළුවන්.

මේ error එක හදා ගන්නේ කොහොමද?

මේ error එක හදා ගන්නනම්, අපිට් සිද්ද වෙනවා ආදේශය සිදු කරනකොට int වර්ගයේ variable එක byte වර්ගයේ variable එකක් විදියට හරවලා ආදේශ කරන්න. මේ ක්‍රමය java වලදී casting කියල හඳුන්වනවා.

ඉහත වැඩසටහනම පහතින් දක්වල තියෙන විදියට වෙනස් කරලා compile කලොත් error එක අයින් වෙලා සාර්ථකව compile වෙනවා.

class A {
    public static void main(String[] args) {
        int i = 10;
        byte b = (byte) i;
        System.out.println(b);
    }
}

byte b = i; කියන පේළියේ iට ඉදිරියෙන් වරහන් තුල අදාළ variable එක වෙනස් කල යුතු data type එක ලබා දීමෙන් මේ cast කිරීම කරන්න පුළුවන්.
Variable cast කිරීම සම්බන්ධවත් විශේෂ කරුණු තිබෙනවා. ඒ ගැන ඉදිරි පාඩමකදී කියල දෙන්නම්.

Data Type සහ Variables කියන්නේ java වල සෑමතැනකදීම මුණගැහෙන දේවල්. මේ ගැන වැඩි වැටහීමක් සහ තවත් අලුත් කරුණු බොහොමයක් ඉදිරියේදී පල කරන හැම පාඩමකිනම වගේ ඉගෙන ගන්න ලැබේවි.
මේ පාඩමින් සාකච්ඡ කලේ අපිට නිතරම වගේ ඇතිවන error කිහිපයක් ගැන විතරයි. මේ වගේ තවත් errors බොහොමයක් අපි java මගින් වැඩ කරන විට ඇති වෙන්න පුළුවන්. ඒ එකින් එක ගැන වෙන වෙනම පැහැදිලි කරන්නවට වඩා සුදුසු, error එකක් ඇති වූ විට ඒ ගැන තනිවම සිතා පිලියමක් සොයා ගැනීමට වෙහෙසිමයි. අන්තර්ජාලය ඇසුරින් අපිට ඇතිවන සෑම error එකකටම විසඳුමක් සොයා ගැනීමට හැකියි.
Java වලදී ලැබෙන compile errors කියවා තේරුම් ගන්න පුරදු වූ තරමට ඒ errors වලට විසදුම් සොයා ගැනීමටද පහසුයි. ඉතාමත් සරල ඉංග්‍රීසි වලින් තමයි මේ error report එක පෙන්වන්නේ. මුලින්ම error එකේ මාතෘකාවත්, error එක ඇති වූ පේළියත් file name එකත් පෙන්වනවා. ඊට යටින් අදාළ විධානය සහිත line එකත්, error එක ඇති වූ තැනත් පෙන්වනවා (කාක පාදයක් වැනි සලකුණකින්). ඉන්පසු error එක පිලිබඳ තවත් විස්තර පෙනවනවා. මේ විස්තර කියවීමෙන්, ඇති වූ error එකට විසදුමක් ඉක්මනින්ම සොයා ගන්න පුළුවන්.
නොපැහැදිලි දෙයක් තිබෙනවානම් comment කරන්න. නැතිනම් අපේ Facebook page එකේ post කරන්න.