Java Variables & Data Types - Java විචල්‍ය සහ දත්ත වර්ග - SC Guide

Java Variables & Data Types - Java විචල්‍ය සහ දත්ත වර්ග - SC Guide

Java Variables and Data Types Explained

කොහොමද යාලුවනේ, ඔයාලා හැමෝම හොඳින් ඉන්නවා කියලා හිතනවා. අද අපි කතා කරන්න යන්නේ Java Programming වල මූලිකම පදනම, ඒ කියන්නේ variables සහ data types ගැන. Java විතරක් නෙවෙයි, ඕනෑම programming language එකක් ඉගෙන ගන්නකොට මුලින්ම හරියටම තේරුම් ගන්න ඕන concepts දෙකක් තමයි මේ variables සහ data types කියන්නේ.

සරලවම කියනවා නම්, ඔයා කොම්පියුටර් එකට මොකක් හරි data එකක් දෙනවා නම්, උදාහරණයක් විදිහට ඔයාගේ නම, වයස, දුරකථන අංකය, නැත්නම් මොකක් හරි ගණනය කිරීමක ප්‍රතිඵලයක් වගේ දෙයක්, ඒ data එක කොම්පියුටර් මතකයේ (memory) තියාගන්න ක්‍රමයක් තියෙන්න ඕනනේ. මේකට තමයි variables කියන්නේ. මේවා හරියට ඔයාගේ පොත් පත්, බඩු දාන්න තියෙන පෙට්ටි වගේ.

හැබැයි, ඒ පෙට්ටියට දාන්නේ මොනවගේ දෙයක්ද කියන එකත් වැදගත්. පොත් දාන පෙට්ටියකට අපි දාන්නේ පොත් මිසක් වතුර බාල්දියක් නෙවෙයිනේ. ඒ වගේ, අපේ variable එකට දාන්නේ මොනවගේ data එකක්ද (අංකයක්ද? අකුරක්ද? වචනයක්ද?) කියලා පෙන්නන්න data types භාවිතා කරනවා. මේක Java programming වලට අත ගහන හැමෝටම වැදගත් වෙන guide එකක්, ඒ නිසා අන්තිම වෙනකල්ම කියවලා දැනුම එකතු කරගන්න.

විචල්‍යයක් (Variable) කියන්නේ මොකක්ද?

ඉතින්, variable එකක් කියන්නේ සරලවම කිව්වොත්, අපිට මොකක් හරි data එකක් store කරලා තියාගන්න පුළුවන් memory location එකක්. මේකේ තියෙන data එක program එක run වෙන අතරතුරේදී අපිට අවශ්‍ය විදිහට වෙනස් කරන්නත් පුළුවන්. ඒකනේ variable (විචල්‍ය) කියන්නේ – වෙනස් කරන්න පුළුවන් කියන එක. හරියට ඔයාගේ කුස්සියේ තියෙන හාල් ටින් එක වගේ. අද හාල් තියෙනවා, හෙට නැති වෙන්න පුළුවන්, අලුත් හාල් ටිකක් දාන්නත් පුළුවන්. ටින් එක එකම එකක් වුණාට ඒකේ තියෙන දේ වෙනස් වෙනවා.

Java වල variable එකක් ප්‍රකාශ කරන (declare කරන) සාමාන්‍ය ක්‍රමය මෙන්න මේ වගේ:

dataType variableName = value;

උදාහරණයක් විදිහට:

int age = 25;
String name = "Kamal";
double price = 99.99;
boolean isActive = true;
  • int, String, double, boolean කියන්නේ මේවායේ data types. ඒ කියන්නේ මේ variable එකට දාන්න පුළුවන් මොනවගේ වර්ගයේ data එකක්ද කියලා මේවායින් කියනවා.
  • age, name, price, isActive කියන්නේ variable names. ඒ කියන්නේ මේ memory location එක හඳුන්වන්න අපි දීපු නම.
  • 25, "Kamal", 99.99, true කියන්නේ අපි ඒ variable එකට දීපු values.

Variable Naming Rules (විචල්‍ය නම් කිරීමේ නීති)

Variable එකකට නමක් දානකොට Java වල පොඩි නීති ටිකක් තියෙනවා. මේවා අනිවාර්යයෙන්ම පිළිපැදිය යුතු දේවල්:

  1. අකුරකින්, Underscore එකකින් හෝ ඩොලර් සලකුණකින් පටන් ගත යුතුයි: Variable නමක් අකුරකින් (A-Z, a-z), underscore (_) එකකින් හෝ dollar sign ($) එකකින් පටන් ගන්න ඕන. ඉලක්කමකින් (0-9) පටන් ගන්න බැහැ.
  2. අකුරු, ඉලක්කම්, Underscore, Dollar Sign විතරයි: නමේ ඉතුරු ටිකට ඕන නම් අකුරු, ඉලක්කම්, underscore, dollar sign භාවිතා කරන්න පුළුවන්.
  3. Space දාන්න බැහැ: Variable නමේ හිස්තැන් (spaces) තියෙන්න බැහැ.
  4. Keywords භාවිතා කරන්න බැහැ: int, public, class වගේ Java වලටම අදාළ keywords variable නම් විදිහට භාවිතා කරන්න බැහැ.
  5. Case Sensitive: Java කියන්නේ Case Sensitive language එකක්. ඒ කියන්නේ age කියන variable එකයි Age කියන variable එකයි දෙකක් විදිහට තමයි Java සලකන්නේ.
  6. CamelCase භාවිතා කිරීම සිරිතක්: සාමාන්‍යයෙන් variable නම් කරනකොට camelCase භාවිතා කරනවා. ඒ කියන්නේ පළමු වචනයේ පළමු අකුර පොඩි අකුරකින් පටන් අරන්, ඊට පස්සේ එන හැම වචනයකම පළමු අකුර ලොකු අකුරකින් ලියන එක (උදා: myAge, firstName, totalAmount). මේක අනිවාර්ය නීතියක් නෙවෙයි, හැබැයි programmersලා අතර තියෙන හොඳ පුරුද්දක්.

Java වල දත්ත වර්ග: Primitive Types

Java වල ප්‍රධාන වශයෙන් දත්ත වර්ග දෙකක් තියෙනවා: Primitive Data Types සහ Reference Data Types. මුලින්ම අපි Primitive Data Types ගැන බලමු.

Primitive Data Types කියන්නේ සරල, තනි data value එකක් (raw value) මතකයේ කෙලින්ම ගබඩා කරන data types. මේවා Java language එකේම pre-defined කරලා තියෙන දේවල්. මේවා object නොවන නිසා memory එකේ ඉඩ අඩුයි, වැඩ කරන වේගයත් වැඩියි.

Java වල ප්‍රධාන Primitive Data Types 8ක් තියෙනවා:

  1. byte:
    • ප්‍රමාණය: 8-bit signed integer.
    • අගය පරාසය: -128 සිට 127 දක්වා.
    • භාවිතය: පොඩි පූර්ණ සංඛ්‍යා (integers) ගබඩා කරන්න, විශාල array එකක ඉඩ ඉතිරි කරගන්න (Memory saving) සුදුසුයි.
  2. short:
    • ප්‍රමාණය: 16-bit signed integer.
    • අගය පරාසය: -32,768 සිට 32,767 දක්වා.
    • භාවිතය: byte එකට වඩා ටිකක් ලොකු පූර්ණ සංඛ්‍යා සඳහා.
  3. int:
    • ප්‍රමාණය: 32-bit signed integer.
    • අගය පරාසය: ආසන්න වශයෙන් -2 බිලියන සිට +2 බිලියන දක්වා.
    • භාවිතය: සාමාන්‍යයෙන් පූර්ණ සංඛ්‍යා සඳහා බහුලවම භාවිතා වන data type එක. ඔයාට විශාල පූර්ණ සංඛ්‍යාවක් අවශ්‍ය නැත්නම්, int හොඳම විකල්පය.
  4. long:
    • ප්‍රමාණය: 64-bit signed integer.
    • අගය පරාසය: ඉතා විශාල පූර්ණ සංඛ්‍යා සඳහා (බිලියන ගණනාවකට එහා).
    • භාවිතය: දුරකථන අංක, ග්‍රහලෝකවල ජනගහනය වගේ ඉතා විශාල පූර්ණ සංඛ්‍යා ගබඩා කරන්න. අගය අවසානයේදී L හෝ l අකුරක් දමනු ලැබේ.
  5. float:
    • ප්‍රමාණය: 32-bit floating-point (දශම ස්ථාන සහිත සංඛ්‍යා).
    • භාවිතය: තනි නිරවද්‍යතාවයක් (single precision) අවශ්‍ය වන දශම සංඛ්‍යා සඳහා. අගය අවසානයේදී F හෝ f අකුරක් දමනු ලැබේ.
  6. double:
    • ප්‍රමාණය: 64-bit floating-point (දශම ස්ථාන සහිත සංඛ්‍යා).
    • භාවිතය: float එකට වඩා වැඩි නිරවද්‍යතාවයක් (double precision) අවශ්‍ය වන දශම සංඛ්‍යා සඳහා. මෙය දශම සංඛ්‍යා සඳහා බහුලවම භාවිතා වන data type එකයි.
  7. boolean:
    • ප්‍රමාණය: 1-bit.
    • අගය පරාසය: true හෝ false යන අගයන් දෙකෙන් එකක් පමණයි.
    • භාවිතය: තර්කානුකූල තත්ත්වයන් (logical conditions) පරීක්ෂා කිරීමට.
  8. char:
    • ප්‍රමාණය: 16-bit Unicode character.
    • භාවිතය: තනි අකුරක් (character) ගබඩා කිරීමට. අගය තනි උද්ධෘත ලකුණු (single quotes) ඇතුලේ දමනු ලැබේ.

උදාහරණ:

char grade = 'A';
char initial = 'S';

උදාහරණ:

boolean isStudent = true;
boolean hasPermission = false;

උදාහරණ:

double pi = 3.1415926535;

උදාහරණ:

float temperature = 25.5f;

උදාහරණ:

long worldPopulation = 8000000000L;

උදාහරණ:

int population = 1000000;

උදාහරණ:

short year = 2023;

උදාහරණ:

byte myAge = 30;

Reference Data Types

Primitive Data Types වගේ නෙවෙයි, Reference Data Types කියන්නේ direct value එකක් store කරන්නේ නැති data types. මේවා store කරන්නේ memory address එකක්. ඒ memory address එකෙන් තමයි actual object එක තියෙන්නේ කොතනද කියලා පෙන්නන්නේ. හරියට ඔයාගේ පොතක පිටු අංකයක් වගේ. පිටු අංකයෙන් පොතේ ඒ කොටස තියෙන තැන පෙන්නනවා වගේ. මේවා complex data types.

Reference Data Types වලට උදාහරණ විදිහට String, Arrays, Classes, Interfaces වගේ දේවල් ගන්න පුළුවන්. මේවා new keyword එකෙන් Object එකක් හැදුවම තමයි memory එකේ ඉඩ වෙන් කරන්නේ.

String Data Type එකට විශේෂ අවධානයක්!

String කියන්නේ Java වල ගොඩක්ම භාවිතා වෙන Reference Data Type එකක්. String එකක් කියන්නේ අකුරු ගොඩක් (characters) එකට එකතු වෙලා හැදුණු එකක්. char එකකින් තනි අකුරක් store කරනවා වගේ නෙවෙයි, String එකකින් වචන, වාක්‍ය store කරන්න පුළුවන්.

String greeting = "Hello, Developers!";
String city = "Colombo";

මෙහිදී, greeting කියන variable එක "Hello, Developers!" කියන String object එක තියෙන memory address එකට reference කරනවා.

Primitive සහ Reference Data Types අතර වෙනස

  • Primitive Types: actual value එක direct store කරනවා. memory එකේ stack එකේ store වෙනවා. වේගවත්.
  • Reference Types: actual object එකේ memory address එක store කරනවා. actual object එක heap memory එකේ store වෙනවා. මීට වඩා සංකීර්ණයි.

Reference type එකක value එකක් නැති වෙලාවට අපිට null කියන keyword එක භාවිතා කරන්න පුළුවන්. null කියන්නේ කිසිම object එකකට refer කරන්නේ නැහැ කියන එකයි. Primitive data types වලට null assign කරන්න බැහැ.

String myCar = null; // Valid
int myNumber = null; // Invalid! Primitive types cannot be null.

Type Conversion (දත්ත වර්ග වෙනස් කිරීම)

සමහර වෙලාවට අපිට එක data type එකක තියෙන value එකක් තව data type එකකට convert කරන්න වෙනවා. මේකට තමයි Type Conversion (හෝ Type Casting) කියන්නේ. මේක ප්‍රධාන ආකාර දෙකකට වෙනවා:

1. Widening Conversion (Implicit / Automatic Type Conversion)

මේක සිදුවන්නේ පොඩි data type එකකින් ලොකු data type එකකට convert කරනකොට. මේක Java වලින් automatically සිදු කරනවා, මොකද මේකේදී data loss වෙන්න තියෙන ඉඩකඩක් නැති නිසා. කුඩා භාජනයක තියෙන වතුර විශාල භාජනයකට දැම්මම වතුර ටික නැති වෙන්නේ නැහැනේ, ඒ වගේ.

අනුපිළිවෙල: byte -> short -> char -> int -> long -> float -> double

int myInt = 100;
double myDouble = myInt; // int එකක් double එකකට convert වෙනවා. Automatic.

System.out.println(myInt);    // Output: 100
System.out.println(myDouble); // Output: 100.0

මෙහිදී myInt කියන int value එක myDouble කියන double variable එකට assign කරනකොට Java වලින්ම ඒක double එකක් විදිහට convert කරනවා. මෙතනදී කිසිම data එකක් නැති වෙන්නේ නැහැ.

2. Narrowing Conversion (Explicit / Manual Type Casting)

මේක සිදුවන්නේ ලොකු data type එකකින් පොඩි data type එකකට convert කරනකොට. මේක Java වලින් automatically කරන්නේ නැහැ, මොකද මේකේදී data loss වෙන්න ඉඩකඩක් තියෙනවා. විශාල භාජනයක තියෙන වතුර කුඩා භාජනයකට දානකොට පිටට වැටෙන්න පුළුවන් වගේ. ඒ නිසා අපිට (dataType) කියන casting operator එක භාවිතා කරලා මේක manual (අතින්) කරන්න වෙනවා.

double myDouble = 9.78;
int myInt = (int) myDouble; // double එකක් int එකකට convert කරනවා. Manual casting.

System.out.println(myDouble); // Output: 9.78
System.out.println(myInt);    // Output: 9 (දශම ස්ථාන කපා හැරෙනවා - data loss)

මෙහිදී 9.78 කියන double value එක int එකකට convert කරනකොට .78 කියන දශම කොටස නැතිවෙලා යනවා. මේක තමයි data loss කියන්නේ. ඒ නිසා Narrowing Conversion කරනකොට ඉතාම ප්‍රවේශමෙන් කටයුතු කරන්න ඕන.

int largeNum = 130;
byte smallNum = (byte) largeNum; // int එකක් byte එකකට convert කරනවා.

System.out.println(largeNum);  // Output: 130
System.out.println(smallNum);  // Output: -126 (Data loss due to overflow/underflow)

byte එකක උපරිම අගය 127. 130 කියන අගය byte එකකට දාන්න උත්සාහ කරනකොට overflow වෙලා අගය වැරදියට පෙන්නනවා (wrap around). මේකත් data loss එකක්.

අවසාන වශයෙන් (Conclusion)

ඉතින් යාලුවනේ, අද අපි Java programming වල මූලිකම පදනම වෙන variables සහ data types ගැන හොඳටම ඉගෙන ගත්තා. මේවා හරියට තේරුම් නොගත්තොත් ඉදිරියේදී ලොකු ලොකු ප්‍රශ්න, වැරදි (bugs) ඇතිවෙන්න පුළුවන් බව මතක තියාගන්න. විශේෂයෙන්ම Primitive සහ Reference data types අතර වෙනස සහ Type Conversion කරන ආකාරය ඉතාම වැදගත්.

මේ concepts ටික ඔයාලගේම code එකක try කරලා බලන්න. පොඩි පොඩි program ලියලා බලන්න. උදාහරණයක් විදිහට, ඔයාලගේ නම, වයස, උස (දශම සහිතව) වගේ දේවල් variables වලට දාලා print කරලා බලන්න. එතකොට මේවා තව පැහැදිලි වෙයි.

මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහලින් comment කරන්න. පුළුවන් ඉක්මනටම මම උත්තර දෙන්නම්. එහෙනම් තවත් අලුත් දෙයක් එක්ක ඉක්මනටම හම්බවෙමු! සුභ දවසක්!