හරි යාලුවනේ ඔන්න මං අයෙත් ආවා අලුත් පාඩම් මාලාවක් සමගින්..😀😀😃…මේ තමයි එහි පලමු දිගහැරුම…පුරුදු විදියටම ආයුබෝවන් කියලා යාලුවෝ හැමෝම පිලිගන්නවා.. the sigma අඩවියට ගියොත් ඔයාලට අපේ කලින් මඟහැරුනු පාඩම් ඔක්කොම බලන්නත් පුලුවන්..හරි එහෙනං අපි බහිමු අද පාඩමට…මම කලින්ම කිව්වනේ අලුත් පාඩමක් පටන් ගන්න යන්නේ කියලා…ඇත්තටම මොකද්ද පටන් ගන්න යන පාඩම…ඒ තමයි graphical user interface ..මොකද්ද මේ graphical user interface එකක් කියන්නේ…මොකටද පාවිච්චි වෙන්නේ…කොහොමද interface එකක් හදන්නේ..ඔන්න ඔය වගේ ප්‍රශ්න load එකක් ඔයාලගේ ඔලුවට එනවා ඇති…the sigma සමග නිරන්තරයෙන් රැදී හිටියොත් ඔන්න ඔය ප්‍රශ්න ඔක්කෝටම සරලව විසදුම් ලබා ගන්න පුලුවන්..ඒ නිසා දිගටම අපිත් සමඟ රැඳී සිටින්න කියලා යාලුවෝ හැමෝටම ආරාධනා කරනවා..

හරි මොකද්ද graphical user interface(GUI) එකක් කියලා කියන්නේ…කෙටියෙන්ම කියනවානම් windows , buttons , icons වගේ graphical elements එකතු කරලා හදපු අතුරු මුහුණතක්…හරි මෙහෙම හිතන්නකෝ… ඔයා code කරනවා programme එකක්…ඒකෙ input දෙන්නේ කොහොමද , ඒක run කරන්නේ කොහොමද වගේ දේවල් ඔයා හොදටම දන්නවා…මොකද කියනවනම් programme එක හැදුවේ ඔයා නිසා…හිතන්නකෝ programming ගැන මොකුත්ම දන්නැති කෙනෙක්ට programme එක පාවිච්චි කරන්න දෙනවා කියලා…එයා නිකං කරකවලා අතහැරියා වගේ නේද.😃😃..ඔන්න ඔය අවුල නැති කරන්න පුලුවන් graphical user interface (user friendly graphical user interface ) එකක් පාවිච්චි කරලා…තවත් විදියකින් කියනවනම් programming ගැන මොකුත් නොදන්නා අයෙකුට පවා programme එකත් සමග වැඩ කරන්න පුලුවන් වෙන විදියට හදපු අතුරු මුහුණතකට තමයි graphical user interface එකක් කියන්නේ.. හරි idea එකක් ආවා නේද මොකද්ද graphical user interface (GUI) එකක් කියන්නේ කියලා…හරි එහෙනං අපි බලමු කොහොමද GUI එකක් හදන්නේ කියලා..මේ සදහා මම පාවිච්චි කරනවා Java programming language එක.

GUI එකක් හදන්න ඉස්සරින් මුලින්ම කරන්න ඕනි දෙයක් තමයි java package එකේ තියන awt library එකකයි swing library එකයි import කරගන්න එක.awt library එක ගත්තොත් ඒක ඇතුලේ තියනවා Dimension , Toolkit , Color වගේ library ගොඩක් predefine කරලා තියනවා…swing library එක ගත්තොත් ..panels,buttons, icons .. වගේ ඒවා predifine කරලා තියනවා..අපි GUI එකක් හදනකොට මේ libraries මුලින්ම import කරගෙන ඉන්න ඕනි.එකින් එක වෙන වෙනම import කරනවට වඩා ලේසියි මෙන්න මේ වගේ ඔක්කොම එකපාර import කරන එක.

import java.awt.*;

import java.swing.*;

හරි ඔන්න ඔහොම තමයි libraries ටික import කර ගන්නේ.. හරි එහෙනන් අපි interface එකක් හදන්න පටාන් ගමු☺☺..

interface එකක් හදන්න පුලුවන් ආකාර දෙකක් තියනවා…පලවෙනි විදිය තමයි inheritance  පාවිච්චි කරලා..අනික් විදිය තමයි inheritance  පාචිච්චි කරන් නැතුව .. ක්‍රම දෙකේ ලොකු වෙනසක් නෑ..හරි මම inheritance  පාවිච්චි කරලම හදන්නම්කෝ…හරි මුලින්ම අපි window එකක් හදාගෙන ඉමු…

import java.awt.*;
import javax.swing.*;

class Gui extends JFrame{
	public static void main(String args[]){
		JFrame MyJavaFrame=new JFrame();

       }
}

හරි ඔන්න ඔය විදියට තමයි window එකක් හදන්නේ..ඇත්තටම මෙතනදි කරලා තියෙන්නේ මේකයි … window එකක් හදන හැටි define කරලා තියෙන්නේ අපි import කරපු package එකේ තියන Jframe කියන Class එකේ .. අපි මෙතනදි කලේ ඒ class එකේ(Jframe) object එකක් හදපු එක.හරි දැන් code එක compile කරන්නකෝ..හදපු window එක පේන්නේ නෑ නේද…දැන් මොකද කරන්නේ…ඒකට අපි setVisible කියන method එක call කරලා argument එකක් විදියට true කියන boolean value එක pass කරනවා…

import java.awt.*;
import javax.swing.*;

class Gui extends JFrame{
	public static void main(String args[]){
		JFrame MyJavaFrame=new JFrame();
		MyJavaFrame.setVisible(true);
       }
}

හරි දැන් compile කරන්නකෝ..දැන් ඔයාගේ screen එකේ කොනක අපි හදාගත්තු window එක චූටිවට තියනවා නේද…

ඔන්න ඕක අපිට ඕනි ප්‍රමාණයට හදා ගන්න පුලුවන් setSize( height,width) කියන method එක call කරලා.. arguments විදියට අපිට අවශය height එකයි width එකයි pass කරන්න පුලුවන්..

import java.awt.*;
import javax.swing.*;

class Gui extends JFrame{
	public static void main(String args[]){
		JFrame MyJavaFrame=new JFrame();
		MyJavaFrame.setVisible(true);
		MyJavaFrame.setSize(300,300);
       }
}

හරි දැන් compile කලාම මෙන්න මේ වගේ window එකක් එනවා නේද…

හරි ..code එක compile වෙලා window එක default හැදෙන්නේ screen එකේ කොනක නේද…අන්න ඒක screen එකේ මැද හදාගන්න ඕනි නම් setLocationRelativeTo() කියන method එක call කරනවා..මෙහිදී argument එකක් විදියට null කියන value එක pass කරනවා..

import java.awt.*;
import javax.swing.*;

class Gui extends JFrame{
	public static void main(String args[]){
		JFrame MyJavaFrame=new JFrame();
		MyJavaFrame.setVisible(true);
		MyJavaFrame.setSize(300,300);
		MyJavaFrame.setLocationRelativeTo(null);
       }
}

හරි දැන් compile කරන්නකෝ…

ඒ වැඩෙත් හරි එතකොට….දැන් හදපු window එක close කරන්නකෝ…දැන් පොඩ්ඩක් compiler එක දිහාත් බලන්නකෝ…compiler එකේ පෙන්න විදියට programme එක තාම run වෙනවා නේද…ඒ කියන්නේ window එක close කලාට programme එක තාමත් run වෙනවා නේද…මෙන්න මේ අව්ල නැති කරන්න පුලුවන් setDefaultCloseOperation() කියන method එක call කරලා…මෙහිදී argument එක විදියට Jframe.EXIT_ON_CLOSE කියන parameter එක තමයි pass කරන්නේ..

import java.awt.*;
import javax.swing.*;

class Gui extends JFrame{
	public static void main(String args[]){
		JFrame MyJavaFrame=new JFrame();
		MyJavaFrame.setVisible(true);
		MyJavaFrame.setSize(300,300);
		MyJavaFrame.setLocationRelativeTo(null);
		MyJavaFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       }
}

හරි දැන් code එක compile කරලා window එක close කරලා compiler එක දිහා බලන්නකෝ…දැන්නම් අව්ලක් නෑ නේද…window එක close කරනකොටම programme එකත් run වෙලා ඉවරයි…

හරි අදට ඇති නේ..😃😃…GUI වල basic ටික ඉගෙන ගෙන ඉවරයි දැන්…මීලඟ පාඩමෙන් අපි බලමු හදාගත්ත window එකට icons සහ buttons add කරන්නේ කියලා…මීලග පාඩමත් සමගින් හමුවෙමු.සුභ දවසක්!

The post Graphical User Interface – පළමු පියවර appeared first on The SIGMA.

ආයුබෝවන් යාලුවවෝ හැමෝටම…oop පාඩම් මාලාවේ අවසන් පාඩමට ඔයාලා හැමෝම සාදරයෙන් පිලිගන්නවා…ඔයාලා දිගටම අපිත් එක්ක රැදී හිටියනම් මේ වෙනකොටත් oop වල තියන ගොඩක් දේවල් ඉගෙන ගෙන හමාරයි…oop වල මොකක් හරි පාඩමක් මග හැරුනනම් මෙතනින් ගිහින් බලන්න පුලුවන්…oop වල අවසාන්ම පාඩමෙන් මං කතා කරන්න බලාපොරොත්තු වෙන්නේ interface ගැන…පුරුදු විදියටම මුලින්ම මම කලින් පාඩම පොඩ්ඩක් මතක් කරලා ඉන්නම්කෝ…කලින් පාඩමේදී අපි කතා කලා abstract classes ගැන…body එකක් නැති එහෙමත් නැත්නම් meaningless body එකක් තියන method එකක් හරි ඊට වැඩි ගානක් හරි තියන class එකකට අපි කිව්වා abstract class එකක් කියලා…තව abstract class ගැන ගොඩක් විස්තර කතා කලා කලින් පාඩමේ..කලින් පාඩමේ තිබුන හැම දෙයක්මනම් මතක් කරන්න යන්නේ නෑ…අමතක නම් හරි අපෙ කලින් පාඩම බැලුවෙ නැත්තම් හරි මෙන්න මෙතනින් ගිහින් ඉක්මනට බලලා එන්නකෝ..

හරි එහෙනම් අපි දැන් බලමු අද පාඩම ගැන..අද පාඩම interface කියලා මම කලින් කිව්වනේ..හරි එහෙනන් අපි මුලින්ම බලමු interface එකක් කියන්නේ මොකද්ද කියලා…interface කියන්නේ මොකද්ද කියලා කියන්න කලින් මං කියන්නම් ඇයි interface පාවිච්චි කරන්නේ කියලා….හරි අපි කලින් පාඩමකින් කතා කලානේ inheritance ගැන…එතනදී අපි කලේ එක class එකකින් තවත් class. එකක් inherit කරපු එකනේ…ඒ කියන්නේ එක inheritance එකයි තිබුනේ…multiple inheritance ගැන අපි කතා කලේ වත් නෑනේ නේද…එහෙම කලේ multiple inheritance java වල නැති නිසා…(C++ වල නම් තියනවා) …multiple inheritance කියන්නේ මේ වගේ එකකට…

class A{

      // statement

}

class B{

    // statement

}

class C extends A,B{

     // statement

}

ඔන්න ඕකට තමයි multiple inheritance කියලා කියන්නේ…එක class එකක් class ගොඩකින් inherit වෙන එකට…ඔන්න ඔය දේ කරන්න java language එකේ ඉඩදෙන්නේ නෑ…අන්න ඒ දුර්වලතාව මගහැර ගන්න තමයි interface පාවිච්චි කරන්නේ…interface එක හැසිරීම class එකකට ගොඩක් දුරට සමානයි…නමුත් class එකක් නම් නෙවෙයි…interface වලින් පුලුවන් class කිහිපයක තියන ලක්ෂණ එක class එකකට ගන්න…හරියට නිකන් inheritance පාවිච්චි කලා වගේ..abstract class ගැන කතා කලා වගේම interface වල තියන ලක්ෂණ ටිකක් මුලින්ම මං කියන්නම්…

interface එකක් අපි define කරන්නේ interface කියලා දාලා interface එකේ නම ලියනවා..මෙන්න මේ විදියට..

interface myInterface{

// statement

}

ඔන්න ඔහොමයි interface එකක් define කරන්නේ…

interface එකක තියෙන තවත් විශේෂත්වයක් තමයි interface එකක තියා ගන්න පුලුවන් abstract methods විතරයි.. interface එකක් ඇතුලේ තියා ගන්නේ abstract method විතරයිනම් interface එකත් abstract වෙන්න ඕනි නේද….interface එක abstract වූනා කියන්නේ object හදන්නත් බැහැ …object හදන්න බෑ කියන්නේ constractor එකකුත් නෑ නේද.. තව දෙයක් තියනවා , interface එකක් ඇතුලේ තියන methods ඔක්කොම public වෙන්නත් ඕනි abstract වෙන්නත් ඕනි static වෙන්නත් ඕනි…ඒ වගේම interface එක ඇතුලේ තියන attributes ඔක්කොම public වෙන්නත් ඕනි static වෙන්නත් ඕනි final වෙන්නත් ඕනි..තවත් දෙයක් තීයනවා.intercace එකක reference variable එකකට පුලුවන් implements වුන class එකේ objects store කරගන්නත්..හරියට නිකන් මෙන්න මේ වගේ..

interface A{
     // statement
}

class B implements A{
     //  statement
}

class Demo {
     public static void main(String a[]){
   
             interface A=new B() // upcasting 

     }

}

ඕන්න ඔය ටික තමයි interface එකක තියන ප්‍රධාන විශේෂත්ව…

හරි දැන් අපි බලමු interface පාවිචි කරන්නේ කොහොමද කියලා…කලින් මං කිව්වනේ interface කියන්නෙත් inheritance වගේ කියලා…inheritance වලදි නම් එක class එකකින් තවත් class එකක් inherit කරන්නේ extends keyword එක පාවිච්චි කරලනේ…interface එකක් නම් implements  keyword එක දාලා තමයි class එකට සම්බන්ද කරන්නේ…මේ විදියට interface ඕනි ගානකින් එක class එකක් imlements කරන්න පුලුවන්..

interface A{

         abstract void a();          // abstract method of interface A..

}

interface B{

         abstract void b();         // abstract method of interface B..

}

class X{

        int x;

        void a(){

        // statement ;               // not an abstract method

        }

}

class Demo extends X implements A,B{

       // statements;

}

Demo class එක X ගෙන් inherit කරලා තියනවා, A හා B ගෙන් imlements කරලා තියනවා…හරි ඔන්න ඔය විදියට තමයි class එකක් interface එකකින් implements කරන්නේ..හරි තේරුනා නේද වැඩේ….interface ගැන ඉතිං ඔච්චරයි කියන්න තියෙන්නේ😃😃😃…තේරුනා නේද අද පාඩම….ඔන්න ඔය පාඩමත් සමගම අපේ oop පාඩම් මාලාවත් නිමාවෙනවා…oop වල මොකක් හරි අව්ලක් ආවොත් ඉක්මනට comment එකක් දාන්න…අපි සූදානම් ඔයාලට උදව් කරන්න..හරි එහෙනන් මට යන්න අවසරයි 😃😃😃…තවත් අලුත් පාඩම් මාලාවක් සමගින් ඉක්මනටම හමුවෙමු…ස්තූතියි !

The post Interface appeared first on The SIGMA.

ආයුබෝවන් ! oop පාඩම් මාලාවේ 11 වන දිගහැරුමත් සමග එකතු වෙන යාලුවෝ හැමෝම සාදරයෙන් පිලිගන්නවා…the sigma blog අඩවියත් සමග නිරන්තරයෙන් රැදී සිටි යාලුවෝ නම් මේ වෙනකොටත් object orianted programming ගැන ගොඩක් දේවල් ඉගෙනගෙන හමාරයි.ඔයා the sigma blog අඩවියට අලුත් සාමාජිකයෙක් නම් හරි , oop අව්ල් කෙනෙක් නම් හරි අපේ මුල් පාඩම් ටික මෙතනින් ගිහින් බලන්න අමතක කරන්නත් එපා හොදේ. හරි එහෙනන් පටාන් ගමු අද පාඩම…අද පාඩම තමයි abstract class …. abstract class ගැන කතා කරන්න ඉස්සරින් කලින් පාඩම පොඩ්ඩක් මතක් කරන්නම්…කලින් පාඩමේදී අපි කතා කලා. encapsulation ගැන…මොකද්ද අපි encapsulation කියලා කිව්වේ… class එකක තියන data protect කරන එක එහෙමත් නැත්නම් data ආරක්ෂා කරන එකට අපි කිව්වා encapsulation කියලා…. අපේ encapsulation පාඩම මතක නැතිනම් මෙතනින් ගිහින් ඉක්මනට බලනකෝ…එතකොට සුපිරියටම මතක් වෙයි.

හරි එහෙනම් අපි දැන් බලමු අද පාඩම ගැන..අද පාඩම තමයි abstract class .
abstract class එකක් ගැන කියන්න ඉස්සරින් මං කියන්නම් abstract method එකක් කියන්නේ මොකක්ද කියලා…ඇත්තටම abstract කියන වචනයෙන්ම කියවෙනවා නේද “මොකුත් නෑ/හිස්” වගේ අදහසක්…ඒකම තමයි මේ class වලත් විශේෂත්වය…හැබැයි පොඩ්ඩක් වෙනස්…ඇත්තටම abstract method එකක් කියන්නෙ body එකක් නැති  එහෙමත් නැත්නම් meaningless body එකක් තියන method එකකට…abstract method එකක් define කරන්නේ method එක ඉදිරියෙන් abstract කියන වචනය දාලා…හරියට නිකන් මෙන්න මේ වගේ…

class Person {

     abstract void Jump(){

     }

}

ඔන්න ඔය විදියට තමයි abstract method එකක් define කරන්නේ…class එකක් ඇතුලේ ඔය වගේ abstract method එකක් හරි ඊට වැඩි ගානක් හරි තිබ්බොත් අන්න ඒ class එකත් abstract class එකක් වෙනවා… හරි එහෙනම් Person class එක ඇතුලෙ තියනවා නේද jump කියලා abstract method එකක් එහෙනම් අපේ Person class එකත් abstract වෙන්න ඕනි නේද…

abstract class Person {

         abstract void Jump(){

      }

}

ඔන්න ඔය වගේ class වලට තමයි abstract class එකක් කියන්නේ…abstract class මොකටද ගන්නේ කියලා අපි පසුව බලමු…දැනට මතක තියාගන්නකෝ abstract class එකක් කියන්නේ ඕන්න ඕකකට කියලා ☺☺..

මේ abstract class ගත්තොත් විශේෂතා ගොඩක් තියනවා….abstract method එකකනම් ඒකේ body එකේ මොකුත් තියා ගන්න බෑ …නමුත් abstract class එකක් ගත්තොත් ඒකේ abstract methods තියෙන්නත් පුලුවන් abstract නොවන methods තියෙන්නත් පුලුවන්…ඔන්න ඕක එක විශේෂත්වයක් abstract class වල තියෙන…තවත් දෙයක් තමයි මේ abstract class වලට objects හදන්න බෑ….object හදන්න බැහැ කියන්නේ constructor එකකුත් නැහැ..ඔන්න ඕක තවත් විශේෂත්වයක්…පොඩ්ඩක් මේ උදාහරණය දිහා බලන්නකෝ…

abstract class Person{

       abstract void jump();

       void run(){

       system.out.println(" i can run fast !");

       }

}

class Student extends Person{

       void study(){

       system.out.println("i am studding !");

       }

}

හරි එහෙනම් ඔය class දෙක දිහා හොදට බලන්නකෝ…Person class එකෙන් Student class එක inherit වෙලා තියනවා .. එහෙනම් Person class එකේ තියන privet නොවන සියලුම attributes හා methods Student class එක ඇතුලට එනවා නේද…ඒ කියන්නේ Person class එකේ තියන jump කියන abstract class එකත් Student class එක ඇතුලට ඇවිත් තියෙන්නේ…කලින් මං කිව්වනේ class එකක් ඇතුලේ අඩුම එක abstract method එකක්වත් තිබ්බොත් class එක abstract වෙනවා කියලා….එහෙනම් අපේ Student class එකත් මෙන්න මේ වගේ abstract කරන්න ඕනි නේද…

abstract class Person{

         abstract void jump();

         void run(){

         system.out.println(" i can run fast !");

         }

}

abstract class Student extends Person{

         void study(){

         system.out.println("i am studding !");

         }

}

හරි ඔන්න ඔහොම තමයි අපේ code එක එන්නේ…කිසි අව්ලක් නෑ…නමුත් මට ඕනි Student කෙනෙක්ගේ object එකක් හදන්න…Student class එක abstract එකක් නිසා මට Student කෙනෙක්ගෙ object එකක් හදන්න compiler එක ඉඩ දෙන්නේ නෑ…එහෙනම් කොහොමද මං Student කෙනෙක්ගේ object එකක් හදන්නේ…Student class එකේ තියන abstract කෑල්ල අයන් කරානම් හරි නේද …එහෙම කරන්නම් abstract methods class එකෙන් අයින් කරන්න ඕනි…Student Class එකේ තියන jump method එකනේ abstract method එකකට තියෙන්නේ…අන්න ඒ jump method එකේ abstract බව අයින් කලානම් හරි නේද…ඒ කියන්නේ jump method එක Student class එක ඇතුලෙදී override කලා නම් හරි නේද…override කලාම jump method එකට body එකක් තියන නිසා ඒ method එකේ abstract බව auto නැතිවෙලා යනවා ….code එක ලිව්වොත් මෙන්න මේ වගේ

abstract class Person{

         abstract void jump();

         void run(){

         system.out.println(" i can run fast !");

         }

}

class Student extends Person{

       void jump(){   

       system.out.println("i can jump !");        // overriding the abstract class

       }

       void study(){

       system.out.println("i am studding !");

       }

}

හරි දැන් මට අව්ලක් නැතිව Student object එක හදන්න පුලුවන් නේද……
abstract class වල තියන තව විශේෂත්වයක් තමයි , abstract class reference variable එකකට පුලුවන් sub class objects store කර ගන්න..(upcasting)..අපේ උදාහරණයේ විදියටනම් මෙන්න මේ දේ…

Person person1= new Student();

හරි ඔන්න ඔය ටික තමයි abstract class ගැන කියන්න තියෙන්නේ… interface වලදී abstract class හොදටම පාවිච්චි වෙනවා…එතකොට ඔයාලට තවත් හොදට තේරෙයි…

හරි අපි abstract class ගැන කතා කලානේ…දැන් මං කතා කරන්න හදන්නේ java වල තියෙන වැදගත් key word දෙකක් ගැන..කලින් අපි super keyword එක ගැනයි this keyword එක ගැනයි කතා කලනේ..අද කතා කරන්න යන්නේ final keyword එක ගැනයි static keyword එක ගැනයි…

final keyword :

ඇත්තටම කියනවනම් final keyword එකෙන් කරන්නේ variable එකකට නිශ්චිත constant value එකක් assign කරන එක…උදාහරණයක් විදියට ගත්තොත් වෘත්තයක ව.ඵ හොයද්දි අපට ඕනි වෙන £ =3.14 කියන අගය…අපිට ඒක final keyword එක දාලා මේ විදියට define කෙරුව හැකි.

final float £ = 3.14 ; 

ඔන්න ඕක තමයි final keyword එකෙන් කරන්නේ…

static keyword:

static keyword එකනම් ටිකක් වැදගත් keyword එකක්…අපිට static keyword එක දාලා attributes define කරන්නත් පුලුවන් methods define කරන්නත් පුලුවන්…attributes එකක් static කලොත් ඒ attribute එකේ value එක program එක අවසන් වුනත් නොවෙනස්ව පවත්වා ගන්න පුලුවන්..හරියට නිකන් මෙන්න මේ වගේ…

class Cat{

     int age;

     static int numOfSibligs=0;

     void run(){

          System.out.print("it can be run fast !");

     }

}

Class Demo{

      public static void main(String a[]){

              Cat cat1= new Cat(); // creating a cat object

              numOfSibligs ++;

              System.out.println("cat1 has "+ cat1.numOfSibligs +" sibligs");

              Cat cat2= new Cat(); //creating another object

              numOfSibligs ++ ;

              System.out.println("cat2 has "+ cat2.numOfSibligs +" sibligs");

      }

}

සාමාන්‍ය variable එකක නම් object එක එක පාරක් හැදුවහම එහි අගය lost වෙලා යනවා. නමුත් static keyword එක පාවිච්චි කලොත් එහෙම වෙන්නෙ නැහැ . out put එකකවත් පොඩ්ඩක් බලන්නකෝ.

Out put :

ඔන්න ඕකයි attribute එකක් static කලාම වෙන්නේ…දැන් අපි බලමු method එකක් static කලාම මොකද වෙන්නේ කියලා…ඇත්තටම method එකක් static කලාම , ඒ method එකට call කරන්න පුලුවන් object එකක් හදන්නේ නැතිව.ඒ කිව්වේ මෙන්න මේකයි.

class Cat{

     int age;

     static int numOfSibligs=0;

     static void run(){

          System.out.print("it can be run fast !");

     }

}

class Demo{

      public static void main(String a[]){

              Cat.run();

              

      }

}

output :

ඔන්න ඕක තමයි static keyword එකෙන් වෙන්නේ…

හරි අදට පාඩම හමාරි..😃😃…හැමෝටම තේරුනා කියලා හිතනවා…මොකක් හරි අව්ලක් තිබුනොත් පහලින් comment එකක් දාන්න…oop වල අවසාන පාඩමත් සමගින් හමුවෙමූ. සුභ දවසක් !

The post Abstract Class appeared first on The SIGMA.