හරි දැන් අපි වේරියබල්ස් ගැන දන්නවා ටිකක්.කොහොමද වේරියබල් එකක් හදන්නේ සහ ඒකට අගයක් දෙන්නේ.මේ වැඩ දෙකට අපි පිලිවෙලින් කියනවා Variable Declaration සහ Initialization.ඒ ගැන දන්නේ නැත්නම් යන්න මෙතනට. එතකොට මේ කියන Initialization-ඉනිශියලයිසේෂන් එහෙමත් නැත්නම් හදාගත්ත වේරියබල් එකකට අගයක් දෙන එක අපි මුලින්ම කලේ සමාන කිරීමක් දාලා අගයක් දීපු එකනේ.මෙන්න මේ විදියට.
int results = 75 ;
අපි මෙන්න මේ ක්රමේට කියනවා Constants Initialization කියලා.ඒ කියන්නේ කෙලින්ම නොවෙනස් අගයක් එක පාරම දීලා දානවා.එතකොට අපිට බැලුව ගමන්ම පේනවා අගය කීයද කියලා.ඇයි කේක් ගෙඩිය වගේ අපි අගය දීල තියෙනවනේ.හැබැයි Dynamic Initialization වල වෙනස් මේ ක්රමේට වඩා.බලමු අපි දැන්.
අපි දැන් බලමු මේ උඩ තියෙන කෝඩ් එක දිහා. මුලින්ම මම double ආකාරයේ ඩේටා ටයිප් එක දාලා a කියලා වේරියබල් එකක් හදලා තියෙනවා.ඒකට අගයක් Initialize-ඉනිශියලයිස් කරලා තියෙනවා 9.0 කියලා.දශම සංඛ්යා එක්ක තමා දීලා තියෙන්නේ මොකද double ආකාරයේ ඩේටා ටයිප් එකක් හන්දා.දශම සංඛ්යා නැතුව උනත් වැඩ අවුලක් නෑ.එතකොට මේ තියෙන්නේ Constants Initialization එකක්.මොකද කෙලින්ම අගය a කියන වේරියබල් එකට දීලා තියෙන හන්දා.
ඊළඟට මම ආයෙම double ආකාරයේ ඩේටා ටයිප් එක දාලා c කියලා වේරියබල් එකක් හදලා තියෙනවා. ඒකට අගයක් Initialize-ඉනිශියලයිස් කරලා නෑ කෙලින්ම.එතැනදී මං යොදාගෙන තියෙනවා sqrt( ) කියන method-මෙතඩ් එක ජාවා වල Math කියන class-ක්ලාස් එකේ තියෙන.මේ මෙතඩ් එක හරහා අපි අගයක් දුන්නම මේ මෙතඩ් එක විසින් අපිට අපි ලබාදුන් අගයේ වර්ගමුලය හොයලා දෙනවා.මේ මෙතඩ් එක දන්නවා වර්ගමුලය හොයන්න කරන්න ඕනේ ගණනය කිරීම්.ඒවා අපි ලියන්න ඕනේ නෑ.ඒවා ජාවා වල ලියලා මෙතඩ් එකක් හදලා තියෙනවා අපි කියනවා එයාට අගයක් දීල මේ අගයේ වර්ගමුලය හොයලා දෙන්න කියලා.හරියට මෙන්න මේ වගේ.අපේ කාර් එකට රෙපෙයාර් එකක් හරි මොකක් හරි වැඩක් හරි කරගන්න ඕනේ උනාම අපි දන්නා ගැරේජ් එකකට ගිහින් මිකැනික් කෙනෙක්ට කියලා වැඩේ කරගන්නවා වගේ තමා.මොකද අපි වැඩේ කරන්න ගියොත් අපි ලේසිම ක්රමෙ දන්නේ නැතුව අමාරුවේ වැටෙන්න පුළුවන්.අනික අපිට පුහුණුවක් නැති හන්දා වැඩේ කරගන්න ගොඩක් වෙලා යනවා.ගැරේජ් එකට ගිහින් වැඩේ කරගන්නවා කියන්නේ පට්ට ලේසිනේ.ඒ වගේ තමා.නොදන්නා ගණිත ක්රම කරනවට වඩා ලේසියෙන් මෙයා කරලා දෙනවා.ඔය වගේ ලේසියෙන් ගණිත වැඩ කරගන්න අපිට ගොඩක් මෙතඩ්ස් තියෙනවා.ඒවා පිළිවෙලට පෙලගස්වලා තියෙනවා Math කියන class-ක්ලාස් එකේ.එතකොට අපි ඒ මෙතඩ් එක තියෙන class එකට කතා කරලා අපිට ඕනේ මෙතඩ් එකටත් කතා කරන්න ඕනේ.අපි මේකට කියනවා Methods Invoking හෝ Method Calling කියලා.ඒ ගැන වැඩි දුර පස්සේ ඉගෙන ගමු.
දැන් මෙතන c කියන වේරියබල් එකට අර Math කියන class-ක්ලාස් එකේ තියෙන sqrt( ) කියන method-මෙතඩ් එකට දීල තියෙන අගයේ වර්ගමුලය ලැබෙනවා.අපි මෙතන දීලා තියෙන්නේ කෙලින්ම අගය නෙවේ.අපි මුලින්ම හදාගත්ත a වේරියබල් එකේ අගය.
දැන් අපි වේරියබල් c දිහා බැලුවට අපිට වේරියබල් c වල අගය කියන්න බෑ අපි අවුට්පුට් එක ප්රින්ට් කරගන්න තුරු.අපි sqrt( ) කියන method-මෙතඩ් එකේ වරහන් අතරට a වේරියබල් එක දැම්මම c වලට අදාළ අගයේ වර්ගමුලය ලැබෙනවා.ඔන්න අපි ඊළඟට System.out.println මෙතඩ් එක යටතේ අපිට ලැබුණු c වල අගය ප්රින්ට් කරගන්නවා.බලමු දැන් අපේ අවුට්පුට් එක.
මෙන්න තියෙනවා අපේ අවුට්පුට් එක.විහිලුවට වගේ c වේරියබල් එකට double ඩේටා ටයිප් එක වෙනුවට int ඩේටා ටයිප් එක දාලා එහෙම බලන්න මොකද වෙන්නේ කියලා.Error එකක් ආවොත් ඇයි කියලා හොයාගන්න උත්සහා කරලා බලන්න.ඊළඟ ලිපිය අපිට ගොඩක් වටිනා ලිපියක්.මොකද අපි ඒකෙන් කතා කරනවා වේරියබල් එකක scope(සීමාව) සහ life time(ආයුකාලය).ඊළඟ ලිපියෙන් හම්බෙමු.
ඔන්න අද පටන් ගන්නවා අලුත් පාඩමක්.ඒ තමා අපේ මුල්ම හඳුන්වාදීමට අනුව Variables.අපි ටික ටික මොනවද මේ වේරියබල්ස් කියන්නේ කියලා දන්නවා.ඒ උනාට ඒ ටික මදි.වේරියබල්ස් ගැන ටිකක් ගැඹුරින් බලන්න දැන් ඉඳං අපි පටන් ගමු.වේරියබල්ස් කියන්නේ ජාවා වල මුලිකම ඩේටා තැන්පත් කරනා ආකාරය කිව්වොත් හරි.එතකොට මේ වේරියබල් එකක් හැදිලා තියෙන්නේ කොහොමද?වේරියබල් එකක් හැදෙන්න නම් identifier(දන්නේ නැත්නම් යන්න මෙතනට ),type(දන්නේ නැත්නම් යන්න මෙතනට),optional initializer (අපි වේරියබල් එකට දෙන අගය.මේක අනිවාර්යම නෑ) මෙන්න මේ ටික එකතු වෙන්න ඕනේ.ඊළඟට වේරියබල් එකකට තියෙනවා scope(සීමාවක්),මේ සීමාවෙන් තමා තීරණය වෙන්නේ මේ වේරියබල් එක කාට කාටද පේන්නේ කියලා.ඒ වගේම වේරියබල් එකේ ආයු කාලය.අන්තිමට කියපු ටික අපි පස්සේ බලමු.
දැන් යමු අපි වේරියබල් එකක් ඩික්ලෙයාර් කරන්න.
ජාවා වල වේරියබල් එකක් පාවිච්චි කරන්න කලින් ඒවා හදලා ඉන්නෝන.හරියට ළමයෙක් ඉස්කෝලේ යවන්න කලින් එයා ඉපදෙන්න ඕනේ වගේ.කොහොමද මේ වේරියබල් එකක් උපද්දවන්නේ?වේරියබල් එකක් හදන මුලිකම ක්රම මෙන්න මෙහෙමයි.
type identifier ;
type identifier = value ;
type identifier = value, identifier = value ;
දැන් මේ type කියන එක ජාවා වල ඩේටා ටයිප් එකක් වෙන්න පුළුවන්.එහෙමත් නැත්නම් class-ක්ලාස් එකක හෝ interface-ඉන්ටෆේස් එකක නමක් වෙන්න පුළුවන්(ඒ දෙක පස්සේ බලමු).identifier කියන්නේ වේරියබල් එකට දෙන නම.ඒවාට නම් දෙද්දී නීති තියෙනවා.ඒවා ගැන දැනගන්න යන්න මෙතනට.හරියටම කිව්වොත් වේරියබල් එකක් initialize කරනවා කියන්නේ හදාගත්ත වේරියබල් එකට අගයක් දෙනවා.අගය දෙන්න නම් අගය සහ වේරියබල් නම අතරට සමාන කිරීමේ සලකුණ යොදන්න ඕනේ.මතක තියාගන්න අපි දෙන අගය අපි වේරියබල් එක හදනකොට දීපු ඩේටා ටයිප් එකට ගැලපෙන්න ඕනේ.මතක නැත්නම් අපි කලින් කරපු ඩේටා ටයිප් පාඩම් ටිකට යන්න ආයෙ මෙතනින්.
int value = 100f ; (මේක වැරදී.අපේ ඩේටා ටයිප් එක int.ඒ උනාට දීපු අගය float)
එකම ඩේටා ටයිප් එකට අදාලව වේරියබල් කීපයක් ඩික්ලෙයාර් කරගන්න ඕනේ නම් අපිට පුළුවන් කොමා සලකුණ ( , ) මගින් වෙන් කරලා ඩික්ලෙයාර් කරන්න.මෙන්න මෙහෙම.
int value, value1, value2 ;
ඒවගේම අගයන් දීලා initialize-ඉනිශියලයිස් කරගෙනම උනත් යන්න පුළුවන්.මෙන්න මෙහෙම.
int value = 100, value1 = 255, value2 = 300 ;
අපි බලමු වේරියබල් declare-ඩික්ලෙයාර් කරන උදාහරණ ටිකක්.සමහරක් ඒවා initialize-ඉනිශියලයිස් කරලත් තියෙනවා බලන්නකෝ.
int a , b , c ;
(අපි a b c කියලා වේරියබල් 03 ක් declare-ඩික්ලෙයාර් කරලා තියෙනවා.initialize-ඉනිශියලයිස් කරලා නෑ.)
int d = 500 , e , m = 55 ;
(අපි d කියලා int වේරියබල් එකක් declare-ඩික්ලෙයාර් කරලා තියෙනවා වගේම ඒකට අගයක් දීල තියෙනවා එහෙමත් නැත්නම් initialize-ඉනිශියලයිස් කරලා තියෙනවා 500.ඊළඟට e කියලා වේරියබල් එකක් declare-ඩික්ලෙයාර් කරලා තියෙනවා ඒ උනාට ඒක initialize-ඉනිශියලයිස් කරලා නෑ.අන්තිමටම අපි m කියලා වේරියබල් එකක් declare-ඩික්ලෙයාර් කරලා තියෙනවා වගේම ඒකට දීල තියෙනවා අගයක් එහෙමත් නැත්නම් initialize-ඉනිශියලයිස් කරලා තියෙනවා 55.දැන් මෙතන වේරියබල් 03 ක් තිබුනට අපි දීල තියෙන්නේ එක ඩේටා ටයිප් එකක් විතරයි.කොමා දාලා තියෙන හන්දා මේ වේරියබල් 03 ම int වලට තමා වැටෙන්නේ.)
byte z = 22 ;
(අපි z කියලා byte වේරියබල් එකක් declare-ඩික්ලෙයාර් කරලා තියෙනවා වගේම ඒකට දීල තියෙනවා එහෙමත් නැත්නම් initialize-ඉනිශියලයිස් කරලා තියෙනවා 22)
double pi = 3.14159 ;
(අපි pi කියලා double වේරියබල් එකක් declare-ඩික්ලෙයාර් කරලා තියෙනවා වගේම ඒකට දීල තියෙනවා එහෙමත් නැත්නම් initialize-ඉනිශියලයිස් කරලා තියෙනවා 3.14159)
float f = 100f, g = 125 ;
(මෙතන පොඩි අවුලක් තියෙනවා.බලමු මොකද්ද කියලා.අපි f කියලා float වේරියබල් එකක් declare-ඩික්ලෙයාර් කරලා තියෙනවා වගේම ඒකට දීල තියෙනවා එහෙමත් නැත්නම් initialize-ඉනිශියලයිස් කරලා තියෙනවා 100f. ඒවගේම අපි g කියලා float වේරියබල් එකක් declare-ඩික්ලෙයාර් කරලා තියෙනවා වගේම ඒකට දීල තියෙනවා එහෙමත් නැත්නම් initialize-ඉනිශියලයිස් කරලා තියෙනවා 125.දැන් අපිට float ඩේටා ටයිප් එකේ නීතියක් තියෙනවා අගයේ අවසානයට f අකුර දාන්න ඕනේ කියලා.ඒ උනාට අපි මේ 125 ට f දාලා නැති හන්දා එතන අවුලක් එනවා.float ගැන මතක නැත්නම් යන්න මෙතනට).එහෙනම් අදට මෙච්චරයි.ඊළඟ ලිපියෙන් අපි Dynamic Initialization ගැන බලමු.
අපෙන් කවුරු හරි ප්රශ්නයක් ඇහුවොත් මොකද්ද අපට උත්තර දෙන්න තියෙන ලේසිම ක්රමය? ඔව් හෝ නෑ.ඒ වගේම තමා අපි කෝඩ් එකක් ලියන කොට අපිට ඔව් නෑ වගේ අගයන් දෙන්න පුළුවන් කම තියෙන්න ඕනේ.එහෙනම් කොහොමද මේ ඔව් නෑ අපි ජාවා වල දෙන්නේ.ඒක තමා අද මම කියන්න යන්නේ.මේක තමා ජාවා වල තියෙන සිම්පල්ම ඩේටා ටයිප් එක.අපි මේක යොදා ගන්නවා ලොජිකල් අගයන් පෙන්නන්න.ඒ කියන්නේ තාර්කික අගයන් නිරූපනය කරන්න.මේකට කියන්නේ boolean-බුලියන් ඩේටා ටයිප් එක කියලා.මේකට තියෙන්න පුළුවන් අගයන් එකක් හෝ දෙකක් විතරයි.ඒ තමා true-ත්රූ(සත්ය) හා false-ෆෝල්ස්(අසත්ය).මේ අකාරයේ අගයන් දෙකෙන් එක අගයක් තමා a>b වගේ relational operators වලින් return වෙන්නේ.ඒ ගැන බලමු ඉස්සරහට.ඒ වගේම තමා conditional expressions යොදාගන්න control statements වලදීත්(if එහෙම මතකද? යන්න මෙතනට).
බලමු දැන් පොඩි කෝඩ් එකක්.
පොඩි කිව්වට පොඩිම නෑ නේද?බලමු මේකේ අවුට්පුට් එක මොකද්ද කියල?
දැන් මම හදන්නේ කෝඩ් එක කියලා දෙන්න.මුලින්ම b කියන වේරියබල් එක boolean ටයිප් එක කියලා ඩික්ලෙයාර් කරලා තියෙනවා.ඔන්න ඊළඟට මම ඒ b කියන වේරියබල් එකට අගයක් දානවා false කියලා.ඒ කියන්නේ අසත්ය.අපිට boolean ඩේටා ටයිප් එකට දෙන්න පුළුවන් true හෝ false අගයන් විතරයි.ඕන ඕන අගයන් දෙන්න බෑ.මතකනේ මුලින් කිව්වා.ඊළඟට මම b වල අගය System.out.println එක හරහා ප්රින්ට් කරගන්නවා." " ඇතුලේ තියෙන b is කියන වචන වල කිසිම වෙනසක් නැතිව ප්රින්ට් වෙනවා.ඊළඟට හම්බෙනවා ස්ට්රින්ග් කන්කටිනේෂන් එක.ඒකෙන් පස්සේ අගය ප්රින්ට් කරන්න ඕනේ වේරියබල් එක b කියලා තියෙනවා.ඒ හන්දා b ට අදාළ අගය ප්රින්ට් වෙනවා.false කියලා.ඒ අනුව අපිට පළමු අවුට්පුට් එක ලැබෙනවා b is false කියලා.
ඊළඟට මම ආයෙ b කියන වේරියබල් එකට true කියලා දෙනවා.කලින් b ට තිබුනේ false කියලා.දැන් ඒ false කියන අගය ඉවත් වෙලා true කියන අගය වැටෙනවා.ඒ කියන්නේ සත්ය.ඊළඟට මම b වල අගය System.out.println එක හරහා නැවත ප්රින්ට් කරගන්නවා." " ඇතුලේ තියෙන b is කියන වචන දෙක කිසිම වෙනසක් නැතිව ආයෙත් ප්රින්ට් වෙනවා.ඊළඟට හම්බෙනවා ස්ට්රින්ග් කන්කටිනේෂන් එක.ඒකෙන් පස්සේ අගය ප්රින්ට් කරන්න ඕනේ වේරියබල් එක b කියලා තියෙනවා.ඒ හන්දා b ට අදාළ අගය ප්රින්ට් වෙනවා.true කියලා.ඒ අනුව අපිට දෙවැනි අවුට්පුට් එක ලැබෙනවා b is true කියලා.
දැන් අපි දන්නවා b ට ලැබිල තියෙන අගය තාම true.ඒ කියන්නේ සත්ය.අපිට ඊලගට අපේ කෝඩ් එකේ හම්බෙනවා
if (b)
if එක්ක මෙහෙම වරහන් තුල වේරියබල් එකක් දැම්මොත් ඒකෙන් අදහස් වෙන්නේ මෙන්න මේක.b කියන වෙරියබ්ල් එක true නම් එහෙමත් නැත්නම් b කියන වේරියබල් එක සත්ය නම් පමණක් if ට අදාළ { } තුලට ගිහින් ඒ ඇතුලේ තියෙන ස්ටේට්මන්ට්ස් රන් කරන්න.මේක කෙටි ක්රමයක් මෙන්න මේකට.
if (b == true)
දැන් අපි දන්නවා b කියන වේරියබල් එකේ තාම තියෙන්නේ true.එහෙමනම් අනිවාර්යෙන් if ට අදාළ { } ඇතුලට ගිහින් ඒ ඇතුලේ තියෙන ස්ටේට්මන්ට්ස් රන් වෙන්න ඕනේ.හරිනේ..මේ රන් වෙලා තියෙන්නේ.{ } ඇතුලේ තියෙන්නේ This is executed කියන වචන ටික ප්රින්ට් කරන්න කියලානේ.ඔය ප්රින්ට් වෙලා තියෙන්නේ ලස්සනට.
ඊළඟට කෝඩ් එක බැලුවම පේනවා b කියන වේරියබල් එකට false කියලා දාල තියෙනවා.ඒ කියන්නේ දැන් b වල අගය false.ඔන්න අපිට ආයෙම හම්බෙනවා if (b).මේකෙන් කියන්නේ මොකද්ද?මං මුලින්ම කිව්ව්වනේ.ඔන්න ආයෙම කියනවා මං.if එක්ක මෙහෙම වරහන් තුල වේරියබල් එකක් දැම්මොත් ඒකෙන් අදහස් වෙන්නේ මෙන්න මේක.b කියන වෙරියබ්ල් එක true නම්, එහෙමත් නැත්නම් b කියන වේරියබල් එක සත්ය නම් පමණක් if ට අදාළ { } තුලට ගිහින් ඒ ඇතුලේ තියෙන ස්ටේට්මන්ට්ස් රන් කරන්න.බැරිවෙලාවත් b වේරියබල් එකේ අගය false නම් එහෙම ඔය if ට අදාළ { } ඇතුලට යන්න බෑ.දැන් අපි දන්නවා b කියන වේරියබල් එකේ තියෙන්නේ false.එහෙමනම් if ට අදාළ { } ඇතුලට පනින්න බෑ.ඒ කියන්නේ කෝඩ් එකේ තියෙන This is not executed කියන වචන ප්රින්ට් වෙන්න බෑ.හරිනේ..ප්රින්ට් වෙලා නෑනේ.අපේ අවුට්පුට් එකේ This is not executed කියන එක නෑනේ.
ඊලඟට කෝඩ් එකේ තියෙනවා System.out.println එකේ " " ඇතුලේ 10 > 9 is කියලා.එකේ අවුලක් නෑනේ." " ඇතුලේ තියෙන ඕනේ මගුලක් ප්රින්ට් වෙනවනේ.ඊලඟට ස්ට්රින්ග් කන්කටිනේෂන් එක ඇතුලේ අපිට හම්බෙනවා (10 > 9) කියලා.වරහන් දාලා තියෙන්නේ මේ කොටස වෙන් කරගන්න.අපි වීජ ගණිතයේදී කරන්නේ.(ඇත්තටම කිව්වොත් එතන වෙන්නේ > ට වඩා higher precedence එකක් + ට තියෙනවා.ඒවා ගැන දැන්ම හිතන්න එපා.ඒවා කියන්නම්.නැත්නම් දන්නා අය කියයි කිව්වේ නෑ කියලා.) දැන් 10 අගය 9 ට වඩා අඩුද වැඩිද? අනිවාර්යෙන්ම 10 වැඩිනේ නේද?එහෙනම් මේ කියන 10 > 9
කියන ප්රකාශය සත්යද අසත්යද? සත්යයි නේද? එහෙනම් අපිට අවුට්පුට් එක විදියට එන්න ඕනේ සත්යයි කියන අගය.ඒ කියන්නේ true.ඔන්න ඔය විදියට අපිට හම්බෙනවා 10 > 9 is true කියලා අවුට්පුට් එකට.
නිකමට හිතන්න කෝඩ් එකේ තිබුන කියලා මෙහෙම.
System.out.println("10 > 900 is " + (10 > 900) );
දැන් 10 අගය 900 ට වඩා අඩුද වැඩිද? අනිවාර්යෙන්ම 900 වැඩිනේ නේද? එහෙනම් මේ කියන 10 > 900
කියන ප්රකාශය සත්යද අසත්යද? අසත්යයි නේද? එහෙනම් අපිට අවුට්පුට් එක විදියට එන්න ඕනේ අසත්යයි කියන අගය.ඒ කියන්නේ false.ඔන්න ඔය විදියට අපි කෝඩ් එකක් දැම්මොත් අපිට හම්බෙයි
10 > 900 is false කියලා අවුට්පුට් එකට.දාලා බලන්න.අදට ගිහින් එන්නම්.
සෑහෙන කාලයක් නිවාඩුවක් ගත්තා නේද? අවුලක් නෑ.දැන් අපි පටන් ගමු ජාවා වල Characters කියන ඩේටා ටයිප් ආකාරය.මේකත් එක්ක අපි ඩේටා ටයිප් ආකාර 07 ක් කතා කරලා ඉවරයි.අපිට ඉතුරු වෙන්නේ booleans විතරයි එතකොට.
Characters ඩේටා එකක් සේව් කරගන්න අපි යොදා ගන්නේ char කියන keyword එක.මේ Characters ගැන කියන්න පොඩි විස්තරයක් තියෙනවා.ඊට කලින් අපි බලමු char-චා ඩේටා ටයිප් ඒකෙන් වේරියබල් එකක් ඩික්ලෙයාර් කරලා. මෙන්න මෙහෙමයි කරන්නේ.
char letter = 'A' ;
char කියන ඩේටා ටයිප් අකාරයේ letter කියන වේරියබල් එකට A කියන අගය initialize-ඉනිශියලයිස් කරනවා.මෙහිදී සැලකිය යුතු කරුණු දෙකක් තියෙනවා.
1. දෙන අගය එක Character එකක් විය යුතුයි.
2. දෙන අගය ' ' තුල ලබා දිය යුතුයි. (සමහර අවසථා වලදී අදාළ නොවේ.කියලා දෙන්නම්).
හරි.Characters ගැන කියන්නම් කිව්වනේ.දැන් බලමු එක.C / C++ කට්ටියට ටිකක් ඔලුව හදා ගන්න වෙනවා.
ටිකක් වෙනස් .C / C++ char වලට වඩා ජාවා වල char වල වෙනස්කමක් තියෙනවා.මොනවද මේ Characters? ජාවා Characters භාවිත කරන්නේ unicode-යුනිකෝඩ් ආධාරයෙන්.යුනිකෝඩ් කියන්නේ මොනාද මේ? ඒ කියන්නේ ප්රමුඛව ලොව භාවිත වෙන humen languages(Latin, Greek, Arabic, Katakana) වල අකුරු තමා යොදාගන්නේ.ඉතින් මම මේ කියන යුනිකෝඩ් වල ඔක්කොම Characters 65,536 තියෙනවා. ඒ කියන්නේ මේ රේන්ජ් එක දරා ගන්න නම් ජාවා 16bit වෙන්න ඕනේ. C / C++ වල නම් char 8bit.යුනිකෝඩ් ගැන දැනගන්න යන්න :
http://www.unicode.org/standard/WhatIsUnicode.html
http://en.wikipedia.org/wiki/Unicode
හරි එහෙනම් දැන් අපි පොඩි උදාහරණයකට යමු.දැන් අපි පාවිච්චි කරන්නේ NetBeans.මේ ගැන හැමෝම දන්නවා ඇති කියල හිතනවා.NetBeans ගැන පොඩි හැඳින්වීමක් ඊළඟ ලිපියෙන් කරන්නම්.
බලමුකෝ මොකද්ද මේ කෝඩ් එක කියලා.අපි මුලින්ම char ch1, ch2; ස්ටේට්මන්ට් එක මගින් ch1 හා ch2 කියන්නේ char ආකාරයේ ඩේටා ටයිප් දෙකක් කියලා කියල තියෙනවා .ඒ කියන්නේ ch1 හා ch2 declare-ඩික්ලෙයාර් කරලා තියෙනවා.තාම අගයන් දුන්නේ නෑ.ඊළඟට මම ch1 කියන වේරියබල් (වේරියබල් ගැන දැන ගන්න යන්න මෙතනට ) එකට අගයක් දෙනවා 85 කියලා. මෙතැනදී අපි 85 දෙනකොට ' ' දාන්නේ නෑ.බලන්න මං මුලින් කියපු කරුණු දෙකෙන් දෙවැනි කරුණ.එතන කියනවා මම, සමහර වස්ථා වලදී අපි char කියල වේරියබල් එක ඩික්ලෙයාර් කලාට ' ' දාන්නේ නෑ කියලා.ඊළඟට ch2 වෙරියබල් එකට දෙනවා Y කියලා.ඊට පස්සේ System.out.println මෙතඩ් එක හම්බෙනවා.එකේ වෙන වැඩ ටික මම මුලින්ම කියලා දීලා තියෙනවා.ඒවුනාට මම පහලින් තියෙන කෝඩ් ඒකෙන් ආයේ මතක් කරලා දෙන්නම්.දැන් අපි බලමු මේක රන් කලාම ලැබෙන අවුට්පුට් එක මොකද්ද කියලා.
අහා.. මේ මොකද වෙලා තියෙන්නේ අපි 85 දුන්නම අවුට්පුට් එකට අකුරක් ලැබිලා.බලන්න මෙන්න මේ වගුව දිහා.
දැන් දැක්කද 85 ට තියෙන අකුර U කියලා.කොහොමද එහෙම උනේ?මොකද්ද මේ වගුව? අපි මේකට කියන්නේ ASCII Table-ඇස්කි ටේබල් කියලා.මේ අගයන්ට අනුකුලව ඔයා දෙන ඉලක්කමට අදාලව අකුර අපිට අවුට්පුට් කරලා දෙනවා.ASCII ගැන මම මෙතන කියන්න යන්නේ නෑ.මෙතන අපි char යටතේ අංකයක් දැම්මට ඒක integer වෙන්නේ එහෙම නෑ.හැබැයි ඉතින් integer වගේ තමා වැඩ කරන්නේ ටිකක්.මොකද ඔයාට පුළුවන් මේ char අගයන් increment කරන්න.ඒ කියන්නේ අගයන් එකින් එක වැඩි කරන්න.integer අගයන් එකින් එක වැඩිකරන increment operators ගැන අපි වෙනම ඉස්සරහට කතා කරනවා.දැනට බලමුකෝ මේ උදාහරණය.
දැන් බලමු මොකද්ද රන් කලාම අපිට ලැබෙන අවුට්පුට් එක.
කොහොමද මෙහෙම වුනේ?දැන් බලමු කොහොමද මේක උනේ කියල.අපි පුලින්ම char ch1; මගින් ch1 කියන්නේ char ආකාරයේ ඩේටා ටයිප් එකක් බව කියල තියෙනවා.ඒ කියන්නේ ch1 declare-ඩික්ලෙයාර් කරලා තියෙනවා.තාම අගයක් දුන්නේ නෑ.ඊළඟට මම ch1 කියන වේරියබල් (වේරියබල් ගැන දැන ගන්න යන්න මෙතනට ) එකට අගයක් දෙනවා A කියලා. ඊළඟට මම System.out.println මෙතඩ් එක මගින් දැනට ch1 වල අගය ප්රින්ට් කරලා බලනවා.මම " " අතරින් දීල තියෙන ch1 contains කියන කොටස නිකන්ම ප්රින්ට් වෙනවා.මොකද " " ඇතුලේ තියෙන ඕනෑම දෙයක් අපි System.out.println එකට දුන්නම ඒවා කිසිම අවුලක් නොකර ප්රින්ට් වෙනවා.ඊළඟට මම + සලකුණ දාල තියෙනවා.මේකෙන් මොකද්ද කොරන්නේ? ඒක ආයේ මතක කරලා දෙන්නම්.එකතු කිරීමේ සලකුණ අපි දන්නේ ඉලක්කම් එකතු කරන්න උනාට මෙතන අපි කරන්නේ " " ඇතුලේ දීල තියෙන අකුරු ටිකක් සහ වෙරියබල් එකක් එකට එක පේලියට ප්රින්ට් කරන එක.
" " ඇතුලේ අපි දෙන වචනයකට හෝ ඉලක්කමකට හෝ වචන ගොඩකට අපි පොදුවේ කියනවා String-ස්ට්රින්ග් එකක් කියලා.එතකොට මේ + සලකුණට අපි කියනවා string concatenation-ස්ට්රින්ග් කන්කටිනේෂන් එක කියල.ඕකෙන් කරන්නේ දැන් අපි හරියටම කිව්වොත් වේරියබල් එකක් සහ ස්ට්රින්ග් එකක් එකට බැඳලා ලං කරලා තියා ගන්නවා.+ පස්සේ තියෙන්නේ ch1 හන්දා අපිට ch1 contains වලින් පස්සේ ch1 වලට අදාළ අගය වන A ප්රින්ට් වෙනවා.ඊළඟට අපිට පහල පේලියට ගියාම හම්බෙනවා මෙහෙම දෙයක්.
ch1++
මේකෙන් මොකද්ද කියන්නේ.මේ ++ සලකුණට අපි කියනවා increment operator එකක් කියල.ඒ ගැන ඉස්සරහට අපි කරනවා.මේකෙන් කරන්නේ සාමාන්යයෙන් integer අගයක් එකකින් නංවලා එහෙමත් නැත්නම් එකකින් වැඩි කරලා අවුට්පුට් එක දෙන එක.(10 තිබුනොත් 11 දෙනවා.52 තිබුනොත් 53 දෙනවා.)මෙතන උනේ A අකුර එකකින් නංවලා B අවුපුට් එකට දුන්නා.ඒ වුනාට char කියන්නේ integer නෙවේනේ.කොහොමද එකක් වැඩි කරලා දෙන්නේ? ඒක තමා මම උඩදී කිව්වේ char නිකන් integer වගේ වැඩ කරනවා කියලා.මොකද increment කිරීමේ හැකියාව මෙයාලට තියෙන හන්දා.ඇත්තටම ගත්තොත් increment වෙන්නේ මෙයාලගේ ASCII අගය.බලන්න උඩ වගුව.ඒකෙ A අකුරට අදාළ ASCII අගය 65. B අකුරට අදාළ ASCII අගය 66 .පේනවනේ අගය එකකින් වැඩි කරලා.ඔන්න ඔය විදියට තමා ජාවා Characters වැඩ කරන්නේ ඊළඟ ලිපියෙන් Boolean ගැන ඉගෙන ගමු.
හරි අද මම කියන්න යන්නේ Floating Points නම්බර්ස් ගැන.අපි මේවට Real නම්බර්ස් කියලත් කියනවා.අපි මේ ඩේටාටයිප් යොදාගන්නේ දශම සංඛ්යා නිරූපනය කරන්න.උදාහරණයක් ගත්තොත් සංඛ්යාවක වර්ගමුලය පෙන්නන්න ඕනේ වුනොත් අපිට මේ ඩේටාටයිප් එක ඕනේ වෙනවා.එතකොට ගණිතයේ සයින් කොසයින් අගයන් නිරූපනය කරන්න ඕනේ උනහම අපිට මේ ඩේටා ටයිප් එක ඕනේ වෙනවා.දැන් බලන්න 03 වර්ගමුලය තමයි 1.7320 ආසන්න ලෙස.මේකේ දශම සංඛ්යා තියෙනවා කියලා පේනවනේ.හැබැයි මේ ඩේටා එක ඔයාට int වේරියබල් එකකට එහෙම දාන්න බෑ.දාන්න පුළුවන්.කම්පයිල් කරගන්න බෑ.බලමු int වේරියබල් එකකට දශම අගයක් දාල කම්පයිල මොකද කියන්නේ කියලා.
හොඳයි.අද අපි අලුත් කොටසකට යන්න හදන්නේ.ඒ තමා Data Types.දැනටමත් ඔයාල දන්නවා වේරියබල් එකකට ඩේටාටයිප් එකක් තියෙනවා.ඒවගේම අපි method calling වලදී(මේ ගැන ඉස්සරහට බලමු),පැරාමීටර් පාස් කරද්දී(මේ ගැනත් ඉස්සරහට බලමු) පවා අපි දීල තියෙන ඩේටාටයිප් එක චෙක් කරලා බලනවා.ජාවා කම්පයිලර් සෑහෙන අවධානෙකින් ඉන්නේ අපි දෙන ඩේටාටයිප් ගැන.පොඩ්ඩක් එහෙ මෙහෙ වුනොත් එයා අපිට errors දෙනවා.අපේ ප්රෝග්රෑම් එක කම්පයිල් කරගන්න බැරි වෙනවා.ඒ හන්දා කම්පයිල එයාගේ වැඩේ කරන්න කලින් අපි දීල තියෙන ඩේටා ටයිප් හරියට දීල තියෙනවද කියල අපිට බලන්න වෙනවා.ඒ කියන්නේ ජාවා වල අපි සලකා බැලිය යුතු දරුණුම මූලික කොටසක් තමා මේ ඩේටාටයිප්ස් කියන්නේ.
ජාවා වල සිම්පල් ඩේටාටයිප් 08 ක් ගැන කතා කරනවා.ඒවා තමා
ඔන්න අපේ දෙවෙනි (J2SE - 02) පාඩමේ අවසාන කොටස.හරි අද පාඩම මෙහෙමයි වෙන්නේ.අපි ප්රෝග්රෑම් කීපයක්ම ලිව්වනේ.තැන තැන කියපු නොකියපු පොඩි පොඩි කරුණු ටිකක් ආයේ ලියන්න හිතුනා.ඒවා තමා White-spaces / Identifiers / Literals / Separators / Keywords.මේවා එකතු වෙලා තමා ජාවා හැදිලා තියෙන්නේ.
White-space
අපි දන්නවා ජාවා වල White-space කියන්නේ tab / space / newline වලට කියලා.අපි ලියන පොඩි ප්රෝග්රෑම් එකක් ඔයාට ඕනේ නම් එක ලයින් එකක ලියන්නත් පුළුවන්.අවුලක් නෑ.
