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