Variables ....

Reference Types (or class types)

මේ කියන්නේ type එක විදියට අපි (හරි SUN එකේ කට්ටිය හරි) ලියපු class එකක් Reference  කරන variables 

මේ type එකේ default value එක null ,අපි value එකක් දුන්නොත් එක reefer කරන්නේ memory එකේ තියෙන object එකකට 

මේ type එකේ store කරන්න පුලුවන් data වල ප්‍රමානය .. හැඩය ..class එකෙන් class එකට වෙනස් වෙනවා .අපි ඒ ගැන ඉදිරියට කතා කරමු

String s = null; 

මෙතෙන්දි String s කියන variable එක stack එකේ සෑදෙනවා . නමුත් එය සදහා තවම reference object එකක් නෑ .. ඒ නිසා එය null pointer මගින් රදවා තබාගෙන ඉන්නවා

String s = new String("Hello"); 

 String("Hello"); කියන object එක heap එකට එකතු වෙලා තියෙන්නේ.. එය stack  කොටසෙ තියන String s කියන variable එකට point වෙලයි තියෙන්නේ

අපි මෙක ගැන තවත් ඉදිරියට කතා කරමු ..

variables use කරන්න කලින් අනිවාර්යෙන්ම declare කරලා initiate කරලා ඉන්න ඕනි ක්‍රම කීපයක් තියෙනවා

String s = new String("Hello"); 

මේ සිංගල් ලයින් method එක

String s;
s = new String("Hello");

මේ තියෙන්නේ සාමාන්‍ය ක්‍රමය

int x=10,y=5,z=55; 

මේ සිංගල් ලයින් multiple method එක

int x ,y ,z=55;  

මෙහෙම කලොත්නම් z විතරයි initiate වෙන්නෙ


variables අපි තවදුරටත්

• Global Variables 
• Local Variables 

විදියට තව දුරටත් වෙන් කරන්න පුලුවන්න
අපි මෙතඩ් එකක් (method) හරි වෙන කිසියම් scope එකක් ඇතුලෙ හරි declare කරන  variables  Local Variables ගණයට වැටෙනවා මේ Local Variables  සදහා යොදන්න පුලුවන් එකම modifier එක final කියන modifier එක පමනයි

එතකොට ඒ හැර වෙන ඕනෑම class scope එකක ලියන  Variables  Global Variables  වෙනවා

public,{default},protected,private

යන access modifier වලින් එකකුත්

final,static,transient,volatile

modifier  වලින් අවශ්‍යතවය අනුව කිහිපයකුත් යොදා ගන්න පුලුවන් නමුත් කිසිම අවස්තාවක volatile හා transient එකට යොදා ගන් නෑ

අද අපි අලුතෙන් ඉගෙන ගත්ත keyword ගැන පැහිදිලි කිරීමක් කරමුකෝ

final
මේ keyword එක යෙදීමෙන් පසුව තව දුරත් ඒ holder ව වෙනස් කිරීමකට ලක් කරන්න බෑ

final int i = 10;

i=15;

කරොත් compile error එකක් එනවා

static

static keyword එකමගින් යම් කිසි දෙයක් class එකකට අයිති බව හගවනවා .. ඒකියන්නේ static holder ලගෙ පවතින්නේ එක instance එකයි ... තව දෙයක් තමා .. class එකක් RAM එකට ලෝඩ් වෙන අවස්තාවෙ ඒ class එකට අයත් සියලුම static දේවලුත්  RAM එකට ලෝඩ් වෙනවා
ඒ වගේම  static holders ලව access කරන්න පුලුවන් static holders ලට විතරයි

transient

මේක ගැන ඉදිරියට කතා කරන්න නම්  Serialization ගැන කතා කරන්න වෙනවා වෙනවා
Serialization : Serialization කියන්නේ යම් කිසි variable එකක් media (HDD,CD,Network) එකකට save (persistent) කරන එක ..මෙහෙම persist කරපු එකක් ආපහු java වෙත ඒ ආකරයෙන්ම ලබා ගැනීම de-serialization කියලා කියනවා .. මේ ගැන අපි ඉදිරියට කතා කරමු

..නමුත් දැනට මතක තිය ගන්න transient modifier  එක යොදපුවාම ඒ variable එකේ දැනට අඩංගු දත්ත persist වෙන අවස්තාවේදි default value එකට හැරවෙනවා .. අපි ආපහු de-serialization හරහා ලබා ගනිද්දි .. කලින් තිබ්බ ඩේටා අපිට ලැබෙන් නෑ

volatile

මේ keyword එකෙන් දැනට තියෙන variable status එකේ copy එකක් ගන්නවා ... අපිට access කරන්න ලැබෙන්නේ ඒ copy එකයි ...කරන සියලු වෙනස් කම් වෙන්නෙත් ඒ copy එකටයි .. අපි නැවත වරක් වෙන තැනකින් access කලොත් නැවතත් අපිට ලැබෙන්නේ variable එකේ මු status එකයි


මේ කී වර්ඩ්ස් ගැන ඉදිරියට තව කතා කරනම් දැන් අපි Arrays ගැන සුලුවෙන් ටිකක් කතා කරමු

Arrays

Arrays කියන්නේ එක වර්ගයකට අයත් වෙන Variables  set එකක්

int i[] = new int [5]

මෙතනදි අපි හැදුවේ element 5 ක් තියෙන int type එකේ array එඅක් සෑම විටම  Array එකක index එක පටන් ගන්නේ 0 න්

i[0]

i[1]

i[2]
i[3]

i[4] 

කියන index වල තමා element 5 තියෙන්නේ array එකක් හදන්න අපිට class types හරි primitive type එකක් හරි use කරන්න පුලුවන් නමුත් primitive type Variables වල පාවිච්චි වෙන casting කියන සංකල්පය මෙතන්ට වැඩ කරන් නෑ කියලා දැනට මතක තියා ගන්න