Programming SL

Programming SL

Programming SL

Sunday, November 22, 2015

HTML හැදින්වීම

By No comments
HTML (Hyper Text Morkup Language) Programming Language එකක් නොවන අතර මෙය Morkup Language වේ. මේ නිසා Morkup Tag භාවිතා කර වෙබ් අඩවි නිර්මාණය කරයි. මෙම වෙබ් අඩවි නිර්මාණය සදහා වෙනමම software පරිගණකයට Install කල යුතු නැත. ඒ සදහා පරිගණකයේ ඇති notepad software එක පාවිච්චි කල හැක. 
  • මුලින්ම notepad open කර ගන්න 
  • එහි පහත ආකාරයට code කරන්න 



<html>
<head>
<title> Programming sl </title>
</head>
<body>
HELLOW WORLD
</body>
</html>
මෙහි නිල පාටින් ඇති කොටස් තමාට කැමති ආකාරයට වෙනස් කර ගත හැක.

  • ඉන්පසු මෙය තමන්ට කැමති ස්ථානයක save කර ගන්න. 
  • මෙහි File Name කියන තැනට තමන් කැමති නමක් ලබා දීල අන්තිමට .html ලෙස දැමිය යුතුය. (මම මෙහි යොදා ඇත්තේ a.html ලෙසය)
  • Save as type යන ස්ථානයට All types ලබා දී SAVE කරන්න. 
  • ඔබ save කරගත් එම file එක තමන් තෝරාගත් location එකේ පහත පරිදි දිස් වේ. (මම මෙය සේව් කරගනු ලැබුවේ desktop එකෙහිය.)  

  • ඉන්පසු එය double click කර open කරන්න.
  • එවිට ඔබගේ web browser එක open වී අපි හදන ලද web page එක open වෙයි. 
 
හරි අදට පාඩම ඉවරයි. ඊලග පාඩමෙන් හමුවෙමු.........




Read More

Monday, November 2, 2015

14. Array

By No comments
 අද අපි කතා කරන්න යන්නේ ජාවා 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

Wednesday, September 23, 2015

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

By No comments
ඔන්න එහෙනම් අදත් අලුත් පොස්ට් එකකින් හමුවෙන්න අවා. අලුත් පොස්ට් එකක් කිවුවට පරණ පොස්ට් එකේම ඉතිරි ටික...... කලින් පොස්ට් එකෙන් 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

Sunday, September 20, 2015

12.Flow Controls

By 1 comment
හරි එහෙනම් ඔන්න තවත් අලුත් පොස්ට් එකකින් ඔබව හමුවෙන්න අවා. මේ පොස්ට් එකෙන් කතාකරන්න බලාපොරොත්තු 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

Saturday, September 19, 2015

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

By No comments
ඔන්න එහෙනම් අද කතා කරන්න යන්නේ 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

Thursday, September 17, 2015

10.Operators

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



  • 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

Monday, April 27, 2015

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

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

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