14. Array

 අද අපි කතා කරන්න යන්නේ ජාවා Array ගැනය. Array එකක් මගින් අපිට පුළුවන් යම් කිසි දත්තයක් Array එක තුල ගබඩා කර තබන්න.  හරි අපි එහෙනම් බලමු Array එකක් හැදෙන්නේ කොහොමද කියල.......

     class Test{
            public static void main(String args[]){
                  int x[] = new int [3];
               }
            }  

ඔන්න ඔය ආකාරයට තමයි Array එකක් හැදෙන්නේ. මම මෙතන හදල තියෙන්නේ int Array එකක්. අපිට කැමති Data Type එකකින් Array හදාගත හැක. අපි එහෙනම් බලමු ඔය හදල තියෙන Array එකට Data ඇතුලත් කරන්නේ කොහොමද කියල.

     class Test{
           public static void main(String args[]){
              int x[ ] = new int [3];
                  x[0]=10;
                  x[1]=20;
                  x[2]=30;
            System.out.println(x[0]);  //print 10
            System.out.println(x[1]);  //print 20
            System.out.println(x[2]);  //print 30
          }
      }

ඔන්න ඔය විදියට තමයි Array එකකට Data ඇතුලත් කරන්නේ. හරි එහෙනම් මේකෙදි වෙන වැඩේ අපි පොඩ්ඩක් පැහැදිලි කරගමු.

අපි ඔය ඉහතින් සාදා තියෙන්නේ 1D Array එකක්. මේකට 1D Array එකක් කියන්න හේතුව පැහැදිලි කර ගනිමු. 

int x [ ] = new int [ ]; 
ඔය නිල පාට  කොටු වරහනෙන් තමයි තීරණය වෙන්නේ මේ Array එක 1D ද , 2D ද , 3Dද, කියලා. (තමන්ට කැමති ගානක Array එකක් හදාගන්න පුළුවන්. එක 10D උනත් අවුලක් නෑ.)


2D Array එකක් හදනවනම්  int x [ ] [ ] = new int [ ] [ ] ;
3D Array එකක් හදනවනම්  int x [ ] [ ] [ ] = new int [ ] [ ] [ ]; 

ඉහත රුපයේ පරිදි new int [3] ; යනුවෙන් සදහන් කර ඇත්තේ අපි සාදන ලද 1D Array එක කොටස් කීයකට බෙදිය යුතුද කියල.  එහිදී මුල්ම index එක පටන් ගන්නේ 0 වෙනි. 

දැන් බලමු 2D Array එකක්. 

මෙම 2D Array එකේදී වෙන්නේ පළමු array එක කැබලි 3කට බෙදිලා ඒ එක කැබැල්ලක් නැවත දෙකට බෙදෙන එකයි. පහත code එක බලන්න. 

  class Test{
           public static void main(String args[]){
              int x[ ][ ] = new int [3][2];
                  x[0][0]=10;
                  x[0][1]=20;
                  x[1][0]=30;
                  x[1][1]=40;
                  x[2][0]=50;
                  x[2][1]=60;
            System.out.println(x[0][0]);  //print 10
            System.out.println(x[0][1]);  //print 20
            System.out.println(x[1][0]);  //print 30
            System.out.println(x[1][1]);  //print 40
            System.out.println(x[2][0]);  //print 50
            System.out.println(x[2][1]);  //print 60
          }
      }

3D Array හැදෙනකොට වෙන්නේ කොටස් 3න කට වෙන් වීමයි. 

             int x[ ][ ][ ] = new int [3][2][3];
                  

මෙහිදී වෙන්නේ පළමු කොටස කොටස් 3නකටද, දෙවන කොටස කොටස් 2ක කටද , තුන්වන කොටස නැවතත් කොටස් 3න කටද වෙන් වීමයි.  

අදට එහෙනම් මෙපමණයි. Array දෙවන කොටසින් හමුවෙමු!......

Read More

13.FLOW CONTROLS (දෙවන කොටස)

ඔන්න එහෙනම් අදත් අලුත් පොස්ට් එකකින් හමුවෙන්න අවා. අලුත් පොස්ට් එකක් කිවුවට පරණ පොස්ට් එකේම ඉතිරි ටික...... කලින් පොස්ට් එකෙන් if සහ else ගැන කතා කළා. ඉතිරි ටික ගැන මේ පොස්ට් එකෙන් කතා කරන්න බලාපොරොත්තු වෙනවා......


for

for loop එක සෑදෙනුයේ පහත ආකාරයටය. 

class Test{
   public static void main(String args[]){
      for(int i=0;i<20;i++){ 
      System.out.println("number is "+i);
     }
   }
}

ඉහත code  එක බලන්න. එහි for loop එකක් යොදා ඇත. එහි i ට 0 ආදේශ කර ඇත. 0ට වඩා 20 විශාලද බැලීම, ඉන්පසු සගල වරහන් තුලට ගමන් කර අගය ප්‍රින්ට් කරයි. ඉන්පසු නැවතත් for loop  එක වෙත jvm එක ගමන් කරයි. කලින් iට ආදේශ වී තිබුනේ 0, දැන් iට 1  ආදේශ වී ඇත. එම නිසා තවමත් boolean එක true වී පවතී. මෙලෙස boolean එක false වෙනකම් මෙම කියාවලිය සිදුවේ. 

number is 0 සිට number is 19 වෙනකම් ප්‍රින්ට් වේ. 

while

class Test{
      public static void main(String args[]){
           int x=10;
          while(x<20){
            System.out.println("number is "+x);
           x++;
          }
     }
}

මෙහිදී   int x=10; යන්න while එකට පෙර සදා ඇත.

do.....while

 class Test{
     public static void main(String args[]){
       int x = 10;

       do{
         System.out.println("number is "+x);
       x++;
       }while(x<20);
    }
}

ඉහත while සහ do.....while දෙකෙහිම ප්‍රින්ට් වනුයේ එකම පිළිතුරුය...

number is 0
number is 1
number is 2
number is 3
number is 4
number is 5
number is 6
number is 7
number is 8
number is 9
number is 10
number is 11
number is 12
number is 13
number is 14
number is 15
number is 16
number is 17
number is 18
number is 19

Read More

12.Flow Controls

හරි එහෙනම් ඔන්න තවත් අලුත් පොස්ට් එකකින් ඔබව හමුවෙන්න අවා. මේ පොස්ට් එකෙන් කතාකරන්න බලාපොරොත්තු Flow Controls වන්නේ ගැනය. Flow Controls වර්ග 4ක් තියෙනවා මුලින්ම බලමු ඒ මොනාද කියලා. ඉන් පස්සේ ඒ එකිනෙක ගැන වෙන වෙනම කතා කරමු. 

• if / else
• for
• while
• do.....while

if 

Basic Format.........

   if    ( boolean )      {            }

මෙහිදී සිදුවනුයේ if එකට දකුණු පසින් ඇති වරහන් තුල තිබෙන boolean එක true නම් පමණක් සගල වරහන් දෙක තුල තිබෙන කාර්ය jvm එක මගින් කරයි.  වරහන් තුල තිබෙන boolean එක false නම් jvm එක සගල වරහන් තුලට නොයයි. මේ පිලිබදව පහත උදාහරණය මගින් තවත් පැහැදිලි වෙනු ඇත. 

class A{
    public static void main(String args[]){
          int i = 10;
           if(i<20){                 // 1 st if condition
        System.out.println("print true 1");
          }if(i<12){                 // 2 nd if condition
        System.out.println("print true 2");
          }if(i<8){                  // 3rd if condition
        System.out.println("print false ");
          }
      }
}

print true 1
print true 2

• ඉහත code එකෙහි i නමැති variable එකක් සාදා එයට 10 අගය ආදේශ කර ඇත. 1st if condition  පේලියේ වරහන් තුල boolean එකක් ලියා  ඇත. එහි ලියා ඇත්තේ i ට වඩා 20 විශාල බවයි. එම boolean එක true වන නිසා JVM එක සගල වරහන් තුලට යයි ඉන්පසු එහි ඇති print true ලෙස ප්‍රින්ට් කරයි. 
• 2nd if condition එකෙහි boolean එකද true වන නිසා එහිත් සගල වරහන් තුලට JVM එක ගමන් කරයි. ඉන්පසු එහි ඇති print true 1 ලෙස ප්‍රින්ට් කරයි. 
• 3rd if condition එකෙහි boolean එකද false වන නිසා එහි සගල වරහන් තුලට JVM එක ගමන් නොකරයි. එම නිසා print false යන්න print නොවේ. 

else

else condition එක යොදනුයේ if condition එකට පසුවය. else condition එක ක්‍රියාත්මක වනුයේ if condition එක false වූ විටය. මේ පිලිබදව පහත උදාහරණය මගින් තවත් පැහැදිලි වෙනු ඇත. 

class A{
    public static void main(String args[]){
          int i = 10;
           if(i<5){                            // 1 line
        System.out.println("print true ");
          }else{                                // 2 line
        System.out.println("print else");
          }
       }
}

print else

• 1line  එකේ boolean එක false වේ. එම නිසා සගල වරහන් තුලට JVM එක ගමන් නොකරයි. 
• 2 line එකේ  else තිබෙන නිසා  එහි ඇති සගල වරහන්  තුලට JVM එක ගමන් කර එහි ඇති print else  ලෙස ප්‍රින්ට් කරයි. (else යන්නෙන් අදහස් කරනුයේ 'එසේත් නැතිනම්' යන්නයි.....)

 එහෙනම් අදට ඇති වගේ. දෙවන පොස්ට් එකෙන් හමුවෙමු .......

Read More

11.Operators(දෙවන කොටස)

ඔන්න එහෙනම් අද කතා කරන්න යන්නේ Relational Operators සහ Logical Operators ගැනය. මේකෙත් ඉතින් එච්චර දෙයක් නෑ...... හරිම ලේසියි. හරි එහෙනම් අපි බලමුකෝ මේක කරන්නේ කොහොමද කියලා. 

== (equal to)        Example: 10 == 10   true

!= (not equal to)    Example: 10 != 11   true

> (greater than to)  Example: 10 > 9     true

< (less than to)     Example: 10 < 11    true

>= (greater than or equal to) Example: A >= B     not true(false)

<= (less than or equal to)    Example: A <= B     true

 හරි එහෙනම් ඉහත Relational Operators යොදාගෙන අපි පොඩි Code එකක් ලියා බලමු. 

class A{
   public static void main(String args []){
            int x = 10;
            int y = 11;
     System.out.println(x==y);   //Answer   false
     System.out.println(x!=y);   //Answer   true 
     System.out.println(x>y);    //Answer   false
     System.out.println(x<y);    //Answer   true
     System.out.println(x<=y);   //Answer   true
     System.out.println(x>=y);   //Answer   false
  }
}

Relational Operators වල ලැබෙන පිළිතුර Boolean වලින් ලැබේ. එනම් true සහ false ය.....  

Logical Operators 

&& (logical and)    Example: (A && B)   false

|| (logical or)     Example: (A || B)   true

! (logical not)     Example: !(A && B)  true

class A{
    public static void main(String args []){
           boolean b = true && false;
           boolean b1 = true || false;
           boolean b2 = !(true && false);

        System.out.println(b);   //false
        System.out.println(b1);  //true
        System.out.println(b2);  //true
    }
}

Read More

10.Operators

ඔන්න එහෙනම් ගොඩක් කාලෙකින් අලුත් පොස්ට් එකක් අරගෙන අවා. මේකෙන් පැහැදිලි කරන්න යන්නේ ජාවා වල තියෙන ඔපරෙටස් ගැනයි. ඔපරෙටස් වර්ග කිහිපයක්ම ජවා වල තිබෙනවා. ඒවා මෙසේය. 

• Arithmetic Operators
• Relational Operators
• Bitwise Operators
• Logical Operators
• Assignment Operators යන ඒවාය. 

මෙම Operators වලින්  අද කතාකරන්න යන්නේ Arithmetic Operators ගැනය. 

• Arithmetic Operators

ගණිතමය කටයුතු සදහා යොදා ගනු ලබන්නේ මෙම Arithmetic Operators ය. එනම් +,-,*,/,% යන Operators ය. 

හරි එහෙනම් මේ එක එක ලකුණින් කෙරෙන කාර්ය කියන්න ඕන නැනේ. ඕනෑම පොඩි ළමයෙක් උනත් ඕකෙන් වෙන දේ දන්නවනේ. % මෙන්න මේ ලකුණෙන් වෙන දේ ගැන පොඩ්ඩක් කියන්නම්.

මෙහෙම හිතමු.....

20%3............    මේකෙන් වෙන්නේ 20 තුනෙන් බෙදුවම ඉතිරි ගාන පෙන්වීමයි. (වම් පස අගය දකුණු පස අගයෙන් බෙදු විට ඉතුරු අගය) 

class Test {
   public static void main(String args[]){
      int a = 10;
      int b = 5;

      System.out.println(a+b);
      System.out.println(a-b);
      System.out.println(a/b);
      System.out.println(a*b);
      System.out.println(a%b);
   }
}

ඉහත code එකෙහි ලැබෙන පිළිතුරු මෙසේය......

15
5
2
50
0 

ජාවා වලදී ගණිත කාර්ම සිදුවනුයේද අප ගණිත කාර්ම විසදන ආකාරයටමය. එනම් පළමුව වරහන් තුල තිබෙන ඒවා සුළු වී ඉන්පසුව බෙදීම ගුණකිරීම ධන ඍණ යන ආකාරයට සුලුවීම් සිදුවේ. 


ඔන්න එහෙනම් අදට පාඩම ඉවරයි. අලුත් පාඩමකින් හමුවෙමු.

Read More

9. Variables(දෙවන කොටස)

ඔන්න ගොඩක් කාලෙකට පස්සේ අලුත් පොස්ට් එකක් අරන් ආවා. වෙනදා වගේම අදත් එහෙනම් වැඩි කතා නැතුව පාඩමට යමු. කලින් පොස්ට් එක බැලුවේ නැත්තම් මෙතන ක්ලික් කරලා බලන්න. 



Variable කොටස් 4 කට බෙදා දැක්විය හැක.
ඒවා නම්,

1. Method Local Variable
2. Block Variable
3. Static Variable
4. Instance Variable

මෙහි ඇති Method Local Variable හා Block Variable යන දෙකට පොදුවේ Local Variable යැයි  කියනු ලැබේ. 


1.Method Local Variable

• Method  තුල සෑදෙන ඕනෑම Variable එකක්  Method Local Variable වේ.  

   මෙහි 20 print වේ. 

2.Block Variable

පහත උදාහරණ මගින් ඔබට ඒ පිලිබදව තවත් වටහා ගත හැක.

3.Static Variable

• Static Variable එකක් නම් අනිවාර්යෙන් Static ලෙස නම් කර ඇත.

4.Instance Variable

• class තුල ඇති static modifier එක නැති methods සහ blocks වලට පිටින් පිහිටන variables, Instance Variable වේ. 
• Instance Variable  access කිරීමට object එකක් සැදීම අවශ්‍ය වේ. 

අද පොස්ට් එකනම් ටිකක් දිගයි. දිග උනයි කියල ඉතින් බාගෙට කියල දීලත් බැනේ. එහෙනම් තවත් අලුත් පොස්ට් එකකින් හමුවෙමු. 

Read More

8. Variables

 ජාවා පරිගණක භාෂාව තුලදී යම් කිසි දත්තයක් ගබඩා කිරීම සදහා Variables (විචල්‍යය) බාවිතා කරයි. මෙම Variables සැකසීමට ජාවා තුලදී  Declaring  යන නම පාවිච්චි කරනු ලැබේ. Variables එකක් සකස් කිරීම සදහා කොටස් දෙකක් අවශ්‍ය වේ. එනම් Data type සහ Variable Name වේ.   

දැන් අපි බලමු ජාවා තුල Variable එකක් හදන්නේ කොහොමද කියලා. 

ඉහත පැහැදිලි කර ඇත්තේ Variable එකක් සාදා ගන්නා ආකාරය වේ. මීලගට අපි බලමු එම සාදා ගත්  Variable එකට දත්තයක් ගබඩා කරන්නේ කෙසේද කියා.......

පහත code එක බලන්න 

output

අපි ඉහත දී  declare කිරීම සහ initialize කිරීම පියවර දෙකකට කරගත්ත. අපට ඕනනම් declare සහ  initialize කිරීම එකම පියවරෙන් කරගැනීමටද පුළුවන. එය පහත පරිදි වේ. 

පහත code එක බලන්න 

output

මෙහිදී අප ඔබට කියා දුන්නේ යම් අගයක් ආදේශ කිරීම පමණි. තමන්ට කැමතිනම් මෙම අගයන් වෙනුවට නමක්ද යොදා ගත හැක, නමක් යොදා ගන්නවානම් අපි int/short/byte/long boolean පාවිච්චි නොකරයි. ඒ සදහා අපි String යන්න යොදා ගනු ලැබේ. (S අකුර කැපිටල් විය යුතුය.) String යන්න පාවිච්චි කරනවානම් value එක සදහා පෙරලි කමා (" ") අනිවාර්යෙන් භාවිත කර යුතුය. 

පහත උදාහරණය බලන්න, 

output

හොදයි එහෙනම් මම හිතනවා අද පාඩම හැමෝටම තේරුණා ඇති කියල. තවත් අලුත් පාඩමකින් හමුවෙමු. හැමෝටම ජය වේවා! 

Read More

7. Data Types (දෙවන කොටස)

කොහොමද ? ගොඩක් දවසකින් post එකක් දාන්නත් බැරි උනා. ඔන්න අද තමයි ටිකක් වැඩ අඩු දවසකට සෙට් උනේ...... මේ පාඩමෙන් කියල දෙන්න යන්නේ කලින් පාඩමේ ඉතුරු ටික. කලින් පාඩම බැලුවේ නැත්තම් මෙතනින් බලන්න.  හරි එහෙනම් අපි අද පාඩමට  යමු. 

• ඕනෑම දශම සංඛ්‍යාවක් සැදෙනුයේ 64 bit තුලය.

මෙය cmd එකෙහි compile කර විට පහත පරිදි error ලැබේ 

මෙම error එක මගින් අපට දැනුම් දෙනු ලබන්නේ අපි ඇතුලත් කල අගයන්  float වලින් නොතබා   double තබන ලෙසයි. එයට හේතුව float සැදෙනුයේ 32bit තුලය. මම මුලදී පැවසු ආකාරයට දශම සංඛ්‍යා සැදෙනුයේ 64bit තුලය. එම නිසා මෙම error එක ලැබේ. 

අප දැන් float වෙනුවට double යොදා compile කර බලමු. 

දැන් හරි.....     8.3969 කියා print වේ. 

ඔන්න දැන් තමයි අපේ අද පාඩම පටන් ගන්නේ. 

දැන් කවුරු හරි කෙනෙක් කියනවා එයට double වලින් එපා. එයට float වලින්ම ඕනෑමයි කියල. එතකොට අපි මොකද කරන්නේ. එකටත් ක්‍රමයක් තියෙනවා එක තමයි දැන් කියල  දෙන්න යන්නේ...............

අපි දශම සංඛ්‍යාවක් float වලින් තබනවානම් එයටත් ක්‍රමයක් තිබේ. පහත ඇති චාට් එක බලන්නකෝ........ 

මෙහි පළමු ක්‍රමයට හැර අනෙකුත් සියලු ක්‍රමයන්ට දශම සංඛ්‍යා ආදේශ කල හැක. 

මෙලෙස යොදන ක්‍රමයට casting ලෙස හදුන්වයි. එය ඉදිරි පාඩමකදී පැහැදිලි කරන්නෙමු. 

Read More

6.Data Types

මෙම පාඩමෙන් අපි කතා කරනු ලබන්නේ data types ගැනය. මුලින්ම ඉතින් data types ගැන පැහැදිලි කරලා ඉන්නම්කො. එකට මෙහෙම උදාහරණයක් ගමුකො. 


හිතන්න අපිට වතුර ලීටර 1 ක් පුරවගන්න බෝතලයක් ඕනයි කියල. ඒ සදහා අපි තෝරා ගනු ලබන්නේ ලීටර 1 හෝ ලීටර 2කෙ බෝතලයකි.  අපට අවශ්‍ය නම් ලීටර 10 බෝතලයක්ද මේ සදහා යොදා ගත හැක. නමුත් ලීටර 1ක් පුරවාගැනීමට ලීටර 10 බෝතලයක් ගැනීම අවාසිදායකය. එනම් එහි ප්‍රමාණය, ගබඩා කර තබා ගැනීමට අවශ්‍ය ඉඩ ප්‍රමාණය වැඩිය, රැගෙන  යාමේ අපහසුව, ආදී අවැසි බොහොමයක් තිබේ.

අන්න ඒ වගේ තමයි ජාවා වලත්, අපි යොදන දත්ත තැම්පත් කිරීම සදහා විවිද පරාසයන් තිබේ. පහත චාට් එක බලන්න. 

integer = පුර්ණ සංඛ්‍යා 

floating point = දශම සංඛ්‍යා 

integer/ floating point / characters / Boolean වල memory capacity එකිනෙකට වෙනස්ය. එය පහත පරිදි වේ. 

අපි මෙහි උදාහරණ කිහිපයක් බලමු. 

byte  -128 to 127

මෙහිදී byte data type  එකට -128 සිට  127 දක්වා යෙදිය හැක. 

අපි හිතමු අපිට 128 දමාගන්න අවශ්‍යයි කියා. එවිට byte වලට 128 දාගත නොහැකි නමුත් එය short data type එකට දමා  ගත හැකිය. එයට හේතුව නම් short හි data range එක  -32768 සිට 32767 වීමයි.  

Boolean 

ජාවා වලදී boolean වලට යොදා ගත හැක්කේ True හෝ False පමණි. සමහර ක්‍රමලේකන භාෂා වලදී නම් boolean සදහා 1 හෝ 0 යොදා ගත හැක. නමුත් ජාවා වල එසේ යොදා ගත නොහැක. 

floating point

මේ සදහා අපට දශම සංඛ්‍යා යොදාගත හැකි නමුත් පුර්ණ සංඛ්‍යා යොදා ගත නොහැක. 

data type වල තව පොඩි කොටසක් තියෙනවා. ඒ ටික ඊලග post එකෙන්ම දාන්නම්කො....... :)   

Read More