ආයුබෝවන් යාලුවවෝ හැමෝටම…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 එකක් දාන්න…අපි සූදානම් ඔයාලට උදව් කරන්න..හරි එහෙනන් මට යන්න අවසරයි 😃😃😃…තවත් අලුත් පාඩම් මාලාවක් සමගින් ඉක්මනටම හමුවෙමු…ස්තූතියි !