Literals in Java and Data Type Casting

අපි අද අලුත් පාඩමක් ගැන කතා කරන්න යන්නෙ. නමුත් මේක මම variables ගැන ලියපු පාඩමට සම්බන්ධයි. ඒ ලිපිය කියෙව්වේ නැත්තම් මෙතනින් ගිහින් ඒක කියවන්න.
හරි මොකක් ගැනද අපි දැන් කතා කරන්න යන්නෙ. අපි කතා කරන්න යන්නෙ literals ගැන. මොනවද literals කියන්නෙ? Literal එකක් කියන්නෙ මොකක් හරි අගයක් (value එකක්). Literal එකක් කුමක් හෝ සංඛ්‍යාවක්, අකුරක්, වචනයක් හෝ වෙනත් තොරතුරක් විය හැකියි. සරලවම කිව්වොත් අපි variables වලට දෙන අගයන් තියෙන්නෙ, ඒව තමයි literals කියන්නෙ. දැන් ඔයාල බලයි ඕකෙ මොනවද ඉගෙනගන්න තියෙන්නෙ කියල. ඉතිරි ටිකත් කියවලම බලන්නකෝ මොනවද තියෙන්නෙ කියල.
අපි මුලින්ම බලමු තියෙන literals වර්ග මොනවද කියල.

• Boolean literals
• Numeric literals
  • Character literals
  • Integer literals
  • Floating point literals
• String literals
• null

Boolean Literals

Boolean expression එකක් කියන්නෙ පිළිතුර සත්‍ය හෝ අසත්‍ය දෙකෙන් එකක් වන ප්‍රකාශනයක්. උදාහරණයක් විදිහට ගන්නකො මේක x = y මේ ප්‍රකාශනය එක්කො සත්‍යයි(true) නැත්තන් අසත්‍යයි(false) x හා y හි අගයන් මත තමා true ද false ද කියන ඒක රඳාපවතින්නෙ. එතකොට boolean literals තමයි true සහ false කියන්නෙ.

Numeric Literals

Numeric literals කියන්නෙ සංඛ්‍යාත්මක අගයන්. සංඛ්‍යාත්මක අගයන් කොටස් තුනකට බෙදල දක්වන්න පුළුවන්. අපි එකින් එක අරගෙන බලමු.

Character Literals

Character කියන්නෙ අකුරු. මේක මොකක්ද numeric literals ඇතුලෙ කරන්නෙ? ජාවා සිංහලෙන් මල්ලිට වරදිලාවත්ද? නෑ නෑ මෙන්න මේකයි හේතුව. පරිගණකය අකුරු හඳුනගන්නෙ විශේෂ සංඛ්‍යාත්මක කේතයකින්. ඔයාල අහලත් ඇති ASCII code කියල කියන්නෙ ඒ කේතයට තමයි. සියලුම ඉංග්‍රීසි අකුරු හා වෙනත් සංකේත (උදා : &, $, %, #) වලට විශේෂ ASCII code එක බැගින් තියෙනව. මෙතනින් ගිහිල්ල අවශ්‍ය කෙනෙකුට සියලුම ASCII codes බලාගන්න පුළුවන්.
අපි කතා කරන මාතෘකාව literals නෙ. ඉතිං character literals කියන්නෙ ඕනෑම තනි අකුරක් හෝ සංකේතයක්. අපිට ඕනෙනම් කෙලින්ම ASCII codes වලින්ම මේ values දෙන්න පුළුවන්.

උදා : char c = 65;

එත් ඉතිං ඒකට ASCII codes මතක තියන් ඉන්න එපැයි. ඒක ඉතිං කරන්න පුළුවන් වැඩක නෙමෙයිනෙ. ඉතිං character literals ඉදිරිපත් කරන්න විශේෂ ක්‍රමයක් තියෙනව. පහල තියෙන උදාහරණ වල තියෙන විදිහට (') සලකුණු මැද්දෙ අපිට අවශ්‍ය අකුර type කරන්න ඕනෙ.


char ex1 = 'A'; char ex2 = '$'; char ex3 = '5';

මෙන්න මේ විදිහට තමයි character literals ඉදිරිපත් කරන්නෙ. ASCII values 0 – 65665 දක්වා තියෙනව. මේක අවශ්‍ය නම් unicode ආකාරයෙන් ඉදිරිපත් කරන්නත් පුළුවන්. ඒකට \u සමග unicode අංකය hexadecimal වලින් ලබා දෙන්න ඕනෙ.

උදා: char x = \u001A;

මෙම Unicode characters වල පරාසය \u0000 සිට \uffff දක්වා විහිදෙනවා.


Integer Literals

Integer literals කියන්නෙ පූර්ණ සංඛ්‍යා. එතකොට integer literals කියන්නෙ පූර්ණ සංඛ්‍යාත්මක අගයන්. මෙම අගයන් ඉදිරිපත් කරන්න පුළුවන් ක්‍රම කිහිපයක්ම තියෙනව. 

• 10 පාදයේ සංඛ්‍යා (Decimal Numbers) ලෙස - 
   decimal numbers කියන්නෙ අපි සාමාන්‍යයෙන් භාවිත කරන සංඛ්‍යා පද්ධතිය. ඒ නිසා මේ ගැන වැඩි දෙයක් කියන්න නෑ. data types ගැන ලියපු ලිපියෙ මම සඳහන් කළා පූර්ණ සංඛ්‍යා සඳහා භාවිත වන විවධ data types කිහිපයක්ම. මෙයින් long කියන data type එකේ සංඛ්‍යාවක් ඉදිරිපත් කරනකොට l හෝ L සංඛ්‍යාවේ අගට එකතු කරන්න ඕනෙ. පහල තියෙන උදාහරණය බලන්නකො.
  
  long x = 9874661754718l; long y = 567L; long z = 456l;       long a = 567683936189L;
   
• 8 පාදයේ සංඛ්‍යා (Octal Numbers) ලෙස - 
  
  
  Octal numbers ගැන ඔයාල කලින් ඉගෙනගෙන ඇති. ගණිතය හා IT කියන විෂයයන් දෙකටම මේ number systems ගැන කියල දෙනව. ඒ නිසා මම ඒ ගැන කියල දෙන්න යන්නෙ නෑ. එහෙම වුණොත් මේක ගණිතය පාඩමක් වෙනවනෙ. කවුරු හරි නොදන්නා කෙනෙක් ඉන්නවනම් පහල ලින්කුවෙන් ගිහිල්ල බලන්නකො.
  
  http://learntv.lk/index.php/secondary-education/year-10/viewcategory/358/---binary-octal-hexa-decimal
  
  හරි අපි කතා කර කර හිටියෙ octal numbers ගැනනෙ. අපි බලමු java වලදි කොහොමද octal number එකක් ඉදිරිපත් කරන්නෙ කියල. පහත උදාහරණ බලන්නකො.
  
  int x = 0114; int y = 041770;
  
  මෙන්න මෙහෙම තමයි octal number එකක් අපි ඉදිරිපත් කරන්නෙ. ඉස්සරහට බිංදුව (0) සහිතව අදාළ සංඛ්‍යාව type කරන්න ඕනෙ. එතකොට compiler දන්නව මේක octal number එකක් කියල.

• Hexadecimal numbers ලෙස - 
  Hexadecimal numbers කියන්නෙ පාදය 16 වන සංඛ්‍යා පද්ධතියක්. මේ සංඛ්‍යා පද්දතියෙ 0 – 9 දක්වා ඉලක්කම් සහ 10 – 15 දක්වා සංඛ්‍යා වෙනුවට A,B,C,D,E,F භාවිත වෙනව. මෙවැනි සංඛ්‍යාවක් අපි java වල ඉදිරිපත් කරනකොට (0x) හෝ (0X) ඉදිරියට යොදන්න ඕනෙ. පහත උදාහරණ බැලුවම තවත් පැහැදිලි වෙයි. 

          int x = 0x15AC790F; int y = 0XFDCAEB; int z = 0X1234FD;

• 2 පාදයේ සංඛ්‍යා (Binary Numbers) ලෙස - 
  
  
  සංඛ්‍යාව ඉදිරියට (0b) හෝ (0B) යෙදීමෙන් දෙකේ පාදයේ සංඛ්‍යා ලෙස සංඛ්‍යා ඉදිරිපත් කරන්න පුළුවන්. ඔන්න මේකටත් උදාහරණ දැම්ම. ඔය පහල තියෙන්නෙ.  

         int x = 0b101101; int y = 0B100100111; 

වැදගත්!!
 

1. මේ විදිහට දෙකේ පාදයේ සංඛ්‍යා ඉදිරිපත් කරන්න පුළුවන් java 7 වල හා ඊට පසුව එන සංස්කරණ වල විතරයි.
    
2. java 7 හෝ ඊට පසු සංස්කරණ වල සංඛ්‍යා පද්දතිය හඳුන්වන්න ඉදිරියට යොදන කොටස හා සංඛ්‍යාව අතර (_) underscore සලකුණක් යෙදිය හැකියි.

                   උදා : int x = 0x_15AC790F;

Floating Point Literals

Floating point literals කියන්නෙ දශම සංඛ්‍යාත්මක අගයන්. මේ ගැනත් වැඩිය කියන්න දෙයක් නෑ. හැබැයි float කියන data type එකට අගයක් දෙනකොට f හෝ F අකුර සංඛ්‍යාව අගට එකතු කරන්න ඕනෙ. නැත්තන් compiler එක හිතන්නෙ ඒ දශම සංඛ්‍යාව double අගයක් කියල. මොකද දශම සංඛ්‍යා සඳහා java වල තියෙන default data type එක තමයි double කියන්නෙ. මේ වගේම double data type එක සඳහා අගයක් දෙනකොට අගට d හෝ D එකතු කරන්න පුළුවන්. නමුත් double කියන්නෙ default data type එක නිසා එය අත්‍යවශ්‍ය නෑ. 

float x = 3.14f; float y = 45F; double a = 5667.4d; 
double b = 8.990;

මතකද මම කලින් ලිපියෙ කියල දුන්න program එක. අපි පරිධිය සහ වර්ගඵලය හෙව්වෙ. ඒක ඔයාල කලානම් මතක ඇති මම ඒකෙ යොදල තිබුනේ කුඩා අගයන් උනාට මම double variables භාවිත කරලා තිබුනෙ. ඒ මම literals ගැන කියල දීල නැති නිසා. මම කිව්වනෙ memory ඒක ඉතිරි කරගන්න ගැලපෙන data type එක තෝරාගන්න ඕනෙ කියල. ඔයාල හිතුවද දන්නේ නෑ මටම ඒක අමතක වෙලා කියල. නෑ නෑ ඒ නිසා නෙමෙයි. හරි දැන් ඔයාලට පුළුවන් ඒ program ඒක වෙනස් කරන්න.

String Literals

ඔයාල දැනටමත් භාවිත කරල පුරුදු literal එකක් ගැන තමයි දැන් කතා කරන්න යන්නෙ. String එකක් කියන්නෙ අකුරු වල එකතුවක්. මේක වචනයක් හෝ වචන පේලියක් වෙන්න පුළුවන්. මේ string literal එකක් ඉදිරිපත් කරනකොට ඒක double quotation marks (") මැද්දෙ ඉදිරිපත් කරන්න ඕනෙ. දැන් කට්ටියට මතක වෙන්න ඇති මේ මොකක් ගැනද කියන්නෙ කියල නේද? මතකද print statement ඇතුලෙ double quotations ඇතුලෙ type කරා. ඒ ගැනම තමයි මේ කතා කරන්නෙ. අපි ඒ print statement එකේදි කරන්නෙ string එකක් print කරගන්න අවශ්‍ය value එක විදිහට දෙන එක. 

System.out.println("String Literal");

අපිට මේ string literals මෙහෙම කෙලින්ම type නොකර variable එකක් විදිහට (ඇත්තටම variable එකක් නෙමෙයි. දැනට එහෙම කියමු) හදාගන්නත් පුළුවන්. String කියල data type එකක් තියෙනව. ඇත්තටම මේක class type එකක්. ඒ නිසා මේක primitive data type එකක් නෙමෙයි. නමුත් අපිට සාමාන්‍ය variable එකක් විදිහටම හදාගන්න පුළුවන්. හැබැයි මතක තියාගන්න string කියල ලියද්දි කැපිටල් S අකුරෙන් පටන් ගන්න ඕනෙ. පහල උදාහරණය බලන්නකො.

String s = "This is a string";

මේ ක්‍රමයට පුළුවන් අපිට string variables හදාගන්න. මේක print කරන්නෙත් සාමාන්‍ය variable එකක් print කරනව වගේම තමයි.

System.out.println(s);

මේ ටික තමයි String literals ගැන දැනගන්න තියෙන්නෙ. මම literals වර්ග ගැන දාල තියෙන ලිස්ට් එකේ තව එකක් තියෙනව null කියල. Null කියන එකේ තේරුම නම් මුකුත් නෑ කියන එක. නමුත් මේ literal එක භාවිත වෙන්නෙ Objects සමග. අපි තවම objects ගැන කතා කරල නැති නිසා ඒ ගැන අපි පස්සේ කතා කරමු. 

අද  අපි කතා කලේ කුඩා කොටසක් නිසා තව පොඩි කොටසක් ආවරණය කරලම පාඩම ඉවර කරමු. දැන් කරන්න යන්නෙ data type casting කියන කොටස. Data type casting කියන්නෙ එක data type එකක් තවත් එකක් බවට හැරවීම. අපි මෙතැනදි කතා කරන්නෙ  primitive data type casting ගැන විතරයි. මොකටද අපිට මේ casting වැදගත් වෙන්නෙ? මම උදාහරණයකින්ම පැහැදිලි කරන්නම්කො. පහල තියෙන code segment එක බලන්නකො.

int x = 4, y = 3;

float z = x/y;

මේකෙ මුල් පේලියේ integer type එකේ variables දෙකක් හදල තියෙනව. බලන්න ඒ syntax එක. එකම data type එකේ variable කිහිපයක් හදනකොට මේ විදිහට කරන්නත් පුළුවන්. නැත්තම් වෙන වෙනම කලත් ප්‍රශ්නයක් නෑ. ඊළඟට තව float variable එකක් හදල ඒකට දීල තියෙනව x/y හි අගය. ඒ කියන්නෙ 4/3 මේකෙ පිළිතුර 1.33 වෙන්න ඕනනෙ. ඔයාල දැන් ඔය z කියන variable එක print කරල බලන්නකො 1.33 print වෙනවද කියල. කරල බැලුවොත් පෙනෙයි print වෙන්නෙ 1 විතරයි. ඒකට හේතුව තමයි පරිගණකය හිතන්නෙ පූර්ණ සංඛ්‍යාවක් තවත් පූර්ණ සංඛ්‍යාවකින් බෙදුවම පිළිතුරත් පූර්ණ සංඛ්‍යාවක් කියල. ඒ නිසා අපිට සිද්ධ වෙනව පරිගණකයට කියන්න මේක දශම සංඛ්‍යාවක් කියල. ඒකට තමයි casting අවශ්‍ය වෙන්නෙ. තව හේතු තියෙනව. අපි යම කිසි සංඛ්‍යාවක් long වගේ වැඩි memory එකක් භාවිත කරන variable එකක් තියෙනවනම්, අපිට ඒ variable එකේ අගය වෙනත් අඩු මතකයක් භාවිත කරන data type එකක උපරිම අගය ඉක්මවන්නෙ නෑ කියල විශ්වාස නම් අපිට පුළුවන් casting භාවිතයෙන් භාවිත කරන මතකය අඩු කරගන්න. හරි අපි බලමු කොහොමද මේක කරන්නෙ කියල.

Primitive data type casting වර්ග තුනක් තියෙනව. 

• ·         Implicit casting

• ·         Explicit casting

• ·         Boolean casting

අපි මෙතැනදි Boolean casting ගැන කතා කරන්නෙ නෑ. ඉදිරි පාඩමකදි මම ඒ ගැන කියන්නම්.

Implicit Casting

 

ඇත්තටම කියනවනම් implicit casting වල අපිට කරන්න දෙයක් නෑ. ඒක ඉබේම වෙන දෙයක්. Implicit casting කියන්නෙ අඩු මතක ධාරිතාවක් සහිත variable එකක් වැඩි මතක ධාරිතාවක් සහිත variable එකක් බවට හැරවීමයි. මේක නිකන් පොඩි පෙට්ටියක් අරගෙන ඒක වැඩ ලොකු පෙට්ටියක් ඇතුලට දානව වගේ වැඩක්. ඉතිං හැමෝටම තේරෙනවනෙ පොඩි පෙට්ටියක් ලොකු එකකට දානකොට කිසි දෙයක් අමුතුවෙන් කරන්න ඕනෙ නෑනෙ. පහල උදාහරණ ටික බලන්නකො.

byte b = 100(8 bit) --> int i = b;(32 bit) --> long l = b;(64 bit)

float f = 3.4f; --> double d = f;

char c = ‘A’; --> int x = c; / double d = c;

Explicit Casting

Explicit casting කියන්නෙ implicit එකේ විරුද්ධ එක. ඒ කියන්නෙ ලොකු පෙට්ටියක් පොඩි එකකට දාන්න යනව වගේ. ඒක එකපාරටම කරන්න පුළුවන් වැඩක නෙමෙයිනෙ. ලොකු පෙට්ටිය එක්කො නවල හෝ වෙන ක්‍රමයකින් වෙනස් කරන්න වෙනව. ඒ වගේම තමයි මෙතනදිත් අපිට වෙනසක් කරන්න වෙනව. අපිට කරන්න තියෙන්නෙ සරල වැඩක් අපිට අවශ්‍ය data type එක වරහන් ඇතුලෙ සඳහන් කරන එක විතරයි. පහත උදාහරණ ටික බලන්නකො.

int x = 100; --> byte b = (byte)x;

long l = 123456789L --> int j = (int)l;

char c = (char)80000; (char variable එකක් තුල රඳවන්න පුළුවන් උපරිම අගය 65665 නිසා මෙතැනදී අපි cast කරල තියෙනව)

මම ඉතා සරල ක්‍රමයකට තමයි මේ casting පාඩම කලේ. මේක සංඛ්‍යාවක binary form එක අරගෙන ගොඩක් පැහැදිලිව විස්තර කරන්න පුළුවන්. නමුත් එතකොට ටිකක් සංකීර්ණ වැඩි වෙනව. අපිට දැනට මේ ටික ඇති. දැන් ඔයාලට පුළුවන් මම උදාහරණයට ගත්ත සංඛ්‍යා දෙකක් බෙදන code එක cast කරල නිවැරදි උත්තරේ ගන්න.

float z = (float)x/y; කියල වෙනස් කරානම් හරි.

 
එහෙනම් අද පාඩම ඉවරයි. අපි ඊළඟ ලිපියෙන් ඉතා වැදගත් කොටසක් ආවරණය කරන්න බලාපොරොත්තු වෙනව. ඒ තමයි java වල තියෙන operators ගැන. අද අපි program එකක් කරේ නෑ. අපි තම මුල් හරියේ ඉන්න නිසා වැඩිය program කරන්න විදිහක් නෑ. මූලික දේවල් ඉගෙනගත්තට පස්සෙ දිගටම program කරන්න පුළුවන්. අපි operators ගැන කතා කරල ඊටපස්සෙ flow control statements ගැන කතා කරනකොට ගොඩක් programming කරන්න පුළුවන්. ඉවසල ඉන්නකො එතකන්.


යන්න කලින් තියෙනව පොඩි දෙයක් කියන්න. අපේ රටේ ඉන්නව java ඉගෙනගන්න කැමති ගොඩක් අය. නමුත් ඒ අයට වෙලාවක් නැතිව හෝ වෙන මොකක් හරි කරුණක් නිසා java course එකක් කරන්න හැකියාවක් නැති වෙන්න පුළුවන්. ඉතිං ඒ වගේ අයට හොඳ java class එකක් තමයි අපේ blog එක. ඒ නිසා මේ blog එක ගැන දන්නා හැමෝටම කියන්න. ඕනෑම කෙනෙක්ට මෙමගින් නොමිලේම java ඉගෙනගන්න පුළුවන්. තව දෙයක් තමයි අපේ facebook fan page එක. ඔයාල ඒකට like එකක් දාල තිබුණොත් ඔයාලට ලේසියෙන්ම අපේ බ්ලොග් එකේ අලුතෙන් පලවන ලිපි ගැන දැනගන්න පුළුවන්. තව twitter භාවිත කරන යාලුවන්ටත් java_sinhalen කියන userව follow කලොත් ලිපි ගැන updates දැනගන්න පුළුවන්. එහෙනම් යාලුවනේ අපි අපහු ඉක්මනට හමුවෙමු.