Design Pattern වර්ගීකරණය

Design Pattern ඒවායේ සංකීර්ණතාවය, විස්තර වල මට්ටම හා යොදුම් පරාසය(ආදේශ කළ හැකි අවස්ථාවන් ප්‍රමාණය) අනුව වෙනස් වේ. එය හරියට මාර්ග ඉදිකීරීමේ ව්‍යුහය වගේ. මාර්ගයේ මගී හා රථවාහන අරාක්ෂාව  සදහා කඩ ඉරි සමග Traffic light පද්ධතියක් ස්ථාපිත කිරීම හෝ මගී ගුවන් පාලම්(හෝ භූගත උමං) සෑදීම යන දෙකෙන්  එකක් යොදා ගත හැක. ඒ දෙකම එකම ගැටලුවට විසදුම් ලබා දුන්නත් විසදුම් දෙක එකිනෙකට වෙනස් ය.

ගොඩක්ම මූලික හා පහල මට්ටමේ Pattern  හදුන්වන්නේ idioms(ඉංගිසියේදී රූඩි, වාග සම්පදාය හා පිරුඑ යන අර්ථය ලබා දේ) කියාය. මේවා තනි ක්‍රමලේඛ භාශාවකට පමණක්ම යෙදේ.

ගොඩක්ම universal(සර්වත්‍ර) හා ඉහළ මට්ටමේ Pattern  එක architectural patterns වේ. මේවා තනි ක්‍රමලේඛ භාශාවකට පමණක්ම යෙදේ. Developers ලට මෙම patterns  තාත්විකව ඕනෑම භාෂාවකින් ගොඩනැංවිය හැක. අනෙක් Pattern මෙන් නොව මේවා සම්පූර්ණ application එකේ architecture  එක design කිරීමට යොදා ගැනේ.

මීට අමතරව patterns, ඒවායේ අරමුණු හා බලාපොරොත්තු(intent එක) අනුව බෙදේ. ඒ අනුව මූලික කොටස් 3කී.
ඒවා

• Creational patterns
• Structural patterns
• Behavioral patterns

Creational patterns

මෙම pattern වර්ගය class එකකින් object නිර්මාණය වීම පිළිබදව වේ. මේවා තවදුරටත්  කොටස් දෙකකට බෙදේ. ඒවා class-creation patterns හා object-creational patterns වේ. class-creation patterns වලදී instantiation ක්‍රියා වලියේදී inheritance එක එලදායිව යොදාගැනීම ගැන සලකා බැලෙන අතර object-creational patterns වලදී කාර්ය අවසන් කර ගැනීමට එලදායි ලෙස delegation (පැවරීම් ) සිදුකිරීම සලකා බැලේ.

Structural patterns

මෙම pattern වර්ගය class එකේ හා object එකේ සංයුතිය පිළිබදව වේ. මෙය ද ඉහත  patterns එක මෙන් කොටස් දෙකකට බෙදේ. එවා Structural class-creation patterns එක හා Structural object-patterns. අතුරුමුණත් තනා ගැනීමට  inheritance භාවීතා කිරීම Structural class-creation patterns වලින් සිදුකරන අතර අලුත් functionality ලබා ගැනීමට objects තනා ගන්නා විදිහ Structural object-patterns වලදී සලකා බැලේ.

Behavioral patterns

මෙම pattern වර්ගය class එකේ  object වල සන්නීවේදනය පිළිබදව වේ. ඒ කියන්නේ object අතර එලදායි ලෙස සන්නීවේදනය  කරන ආකාරය හා ඒවා අතර වගකීම් පැවරීම් ආදීය ගැන සලකා බැලේ.

Design Pattern හි වැදගත්කම

ඇත්ත නම් ඔබට Design Pattern එකක් වත් නොදැන වසර ගණනාවක් ක්‍රමලේඛකරුවකු ලෙස වැඩ කළමනාකරණ කරනවා විය හැක. දැනටත් බොහෝමයක් මිනිසුන් එසේමයි. එවැනී අවස්ථා වලදී ඔබ කෙසේ හෝ Design Pattern ගැන නොදැන වුවත් සමහර Pattern ගොඩනගා ගන්නවා.ඉතින් ඇයි ඔවුන්(ක්‍රමලේඛකරුවන්) වේලාවන් වැයකරමින් මේවා හදාරන්නේ?

පළමු වැන්න නම්, Design Pattern කියනනේ අත්හදා බලා පරික්ෂාවට ලක් කෙරූ ක්‍රමලේඛ Design කරන විට එන ගැටලු විසදන මෙවලම් කට්ටලයකි. එවැනී ගැටලු මුණනොගැසුනත් එය දැන සිටීම ප්‍රයෝජනවත් මන්ද එය උගන්වනවා අපට object-oriented design හි මූලධර්ම යොදා ගනිමින් සියලූම ගැටලු විසදන ආකාරය.

දෙවැනි කාරණය නම්, Design patterns එක ඔබට හා ඔබේ කණ්ඩායමේ සමාජිකයන් අතර වඩා කර්යක්ෂමව සන්නිවේදනය කිරීමේ භාෂාවක් ලෙස භාවිතා කළ හැකි වීම. ඒ කියන්නේ solution(විසදුම) එක ගැන විස්තර කර කර දෙනවට වඩා patterns නම විතරක් කිවීමෙන් පමණක්  ප්‍රමණවත් වීම. 

උදාහරණයක් ලෙස ඔබ කියන්නේ "මෙයට singleton pattern එක දැම්මානම් හොදයි" කියාය. මෙය මීට වඩා විස්තර කරන්න අවශ්‍ය නැහැ. එවිට අනෙක් සමාජිකයන් ඔබේ යෝජනාව පිළිබදව අදහස ඉන් ලැබෙනවා.

ක්‍රමලේඛණයේ කැලිකසල බැහැර කිරීම හෙවත් Garbage Collection හදුනා ගනිමු

මෙම ලිපිය බොහෝ විට ජාවා ක්‍රමලේඛය ඇති  Garbage Collection එක ගැන තමා වැඩි පුර කතා කරන්නේ. C/C++ වැනි ක්‍රමලේඛයක් සැලකුවොත් එහිදි Object එක create එක ගැන හා  Object එක විනාශ වන එක ගැන වගබලා ගැනීම ක්‍රමලේඛකයාගේ වගකීමකි. බොහෝ විට ක්‍රමලේඛකරුවන් Object එක විනාශ කීරීමේ කාර්යය අතපසු කරනවා.   මෙම වගකීම පැහැර හැරියොත් යම් තැනකිදී අලුත් Object  හදන විට, ප්‍රමාණවත් මතකය(memory එක) නොලැබීම නිසා OutOfMemoryErrors ලැබිමෙන් මුලු program එකම අසාමන්‍ය ලෙස අවසන් වී යා හැක.

Java වැනි ක්‍රමලේඛවලදී මෙවැනී දිගු කාලයක් භාවිතා නොවන Object ගැන ක්‍රමලේඛකයා වද විය යුතු නැහැ. මෙවැනි Object, Garbage collector විසින් විනාශකරනු ලබයි. මෙම Garbage collector එක Daemon thread සදහා උදාහරණ වේ. Daemon thread කියන්නේ Low priority එකක් තියෙන  නිතරම ක්‍රියාකාරී තත්වයේ පවතින thread විශේෂයකි.

ක්‍රමලේඛයේ පවතින variable data, Object ආදිය ගබඩා වෙන්නේ heap memory එකකය. Garbage collector එකක ප්‍රධාන කාර්යය වන්නේ Unreachable object විනාශ කරමින්  heap memory එක free කර දීමයි.
 Reference variable එකකින් හදපු object තවත් අවස්ථාවක වෙනත් object  හෝ දත්ත පැවරීම නිසා තවදුරටත් එම කලින් හදපු object එක  භවිතා නොකොට වෙන්වෙලා හුදෙකලා මෙවැනි object එකක් Unreachable object ලෙස හදුන්වයි.

උදාහරණය

1. Integer i=new Integer(10);
2. i=null;

line 1දී object  එකක් create වී තියෙනවා. එය i කියන variable එකකට ආදේශ කර ඇත. පසුව i ට null වටිනාකම ලබා දී තිබේ. දැන් line 1දී create වුන ඒ object එක අයේ භාවිතයක් ඇති නොවන ලෙස Unreachable object වෙලා තියෙනවා.

 ක්‍රමලේඛයේ Garbage collection එක programmer සිදුනොකළත්, programmer විසින් object එක Garbage collection වලට අවශ්‍ය වන පරදී සකසා ගත යුතුයි.
එසේ සකසන ආකාර 4ක් තිබේ.

1.  reference variable එක null අකාරයට හැරවීම (Nullifying)
2. reference variable එකට යළි පැවරීම් සිදු කිරීම
3. method තුළ නිර්මිත Object 
4. Island of Isolation 

මෙහි Island of Isolation කියන්නේ Object එකක් හෝ කිහිපයක් වෙනත් Object සමග සම්බන්ධ නොවී එකිනෙකා අතර බැදී තනි group එකක් විදීහට පැවතීම Island of Isolation ලෙස හදුන්වයි. මෙය නමුත් එය program එකේ කිසිම active වූ object එකකට refer නොකරයි.

JVM තුළ ධාවනය වන Garbage collector එක Garbage collection සිදුකරයි. ක්ෂණිකව සිදුවන Garbage collection දෙයක් නොවන නමුත් කිසියම් කාලයකදී සිදුකරයි. මෙම කාලය කුමන කාලයක දැයි තීරණය කළ නොහැක. නමුත් අපට අවැසී තැනකට හෝ වේලාවකට මෙම  Garbage collector එක ඉල්ලිය හැක. 

එසේ ඉල්ලිය හැකි ආකාර දෙකකි.

1. System.gc() method එක භාවිතයෙන්
2. Runtime.getRuntime().gc() method එක භාවිතයෙන්

Object Oriented Methodology - Overloading හා Overriding හදුනා ගනිමු.

Overloading

එකම method name යොදාගනිමින්  විවිඩ ආකර වලට  method  signature  යොදමින් method  කිහිපයක් නිර්මාණය කිරීම method  Overloading යැයි කියනු ලැබේ. මෙය compile time (or static) polymorphism වලට අයත් වේ.

1. public int sum(int a, int b){
2.    return a+b;
3. }
4. public double sum(double a, double b){
5.    return a+b;
6. }
7. public long sum(long a, long b){
8.    return a+b;
9. }
10. public float sum(float a, float b){
11.    return a+b;
12. }
13. public int sum(int a, int b, int c){
14.    return a+b+c;
15. }
16. public static void main(String args[]){
17.    System.out.println("Sum of 1 and 2 is "+sum(1,2));
18.    System.out.println("Sum of 2147483649L and 4147400049L is "+sum(2147483649L,4147400049L));
19.    System.out.println("Sum of 6.9 and 2.8 is "+sum(6.9,2.8));
20.    System.out.println("Sum of 1 and 2 is "+sum(1,2,3));

}

Call කරන method එකේ parameter වල ගැලපීම අනුව  අදාළ method  එක run කරයි. 

line 17 දී run කරන්නේ line 1 දී අර්ථ ගැන්වූ sum method එකයි මන්ද parameter ගණනයි එහි data type එකයි එක සමානයි. ඒ අනුව ඒ ඒ අදාළ method call අදාළ method එක parameter වල ස්වභාවය අනුව තීරණය කරයි.

මෙහි ඇති ප්‍රධාන වාසිය නම් method name මතක තබා ගැනීමේ පහසුවයි. මන්ද එකම කාර්යක් කරන method කිහිපයකට method name වෙනස් නම් ලබා දීලා මතක තබා ගන්නවට වඩා එක method name එකක් මතක තබා ගැනීම ලේසි බැවිනී.

Overriding

සරලව කිව්වොත්  Overriding යනු super(base or parent) class එකක method එකක්  sub(derived or child) class එකක් තුළ අර්ථ දක්වා ගැනීම ගැනීමයි. super class එකේ ඇති එවැනි method එකක්, overridden method ලෙස හදුන්වයි. sub class එකක අර්ථ ගැන්වු  එම method එක Overriding method  ලෙස හදුන්වයි. එහි overriding method එකේ method signature එක overridden method එකට සමාන විය යුතුයි.

නමුත් super(base or parent) class එකක method එකක්  sub(derived or child) class එකක් තුළ අර්ථ නොදක්වනවා නම් එවැනි method එකක්, inherited method ලෙස හදුන්වයි.

Overriding වල නීති

1. මේවා inheritance වල පමණක් ම  තිබෙන නිසා Access modifier එක protected හා public තිබිය හැක. එකම package එක තුළ නම් default වුනත් යෙදිය හැක. නමුත් private යෙදුවත් වරදක් නැති නමුත් Overriding එකක් සිදුනොවේ. ඒවා ඒ ඒ class එකට අදාළ method බවට පත්වේ.
2. Final methods ආදිය Overriding  කළ නොහැක. මෙහි අදහස නම් Final කියන keyword එක overridden method වලට නොදැමිය යුතු බවයි. එසේ කළහොත් දෝෂ ඇතිවිය හැක.
3. Static keyword එකක් methods වලට යෙදීමෙන් Overriding  වීමක් සිදු නොවේ. එහිදී සිදුවන්නේ private keyword වලදි මෙන් methods එක සැගවීමක් පමණක් සිදුවේ. Overriding  එකක් වන්න නම් දෙකම non static method විය යුතුයි. overridden method හෝ overriding method දෙකෙන් එකක් non static වෙලා අනෙක static වෙන්න බැහැ. static method එකක් static  යොදමින් overloading කළ හැක.
4. overriding method වලට overridden method එකට සමාන return type එකක් තිබිය යුතුයි. මෙම return type එක Covariant return types එක ලෙස හදුන්වයි.
5. overriding method  එක තුළම හිද overridden method එක call කළ හැක. මෙහිදි  super keyword භාවිතයෙන් base class(parent or super) එකේ overridden method එකට call කරනු ලබයි.
6. Exception Handling වලදී නීති දෙකක් පවති. පළමු නීතීය වන්නේ parent class එකේ overridden method එකේ throws Exception නැතිනම් overriding method එකේ  throws Exception දැක්විය නොහැකියි. එසේ දැමිය හැක්කේ Exception වල ඇති sub Exception (RuntimeException , ArithmaticException , ..) වලට පමණි. අනෙක් නීතීය නම් parent class එකේ overridden method එකේ යම් Exception එකක් ඇති නම් overriding method එකෙන්  throws  කළ හැක්කේ parent class එකේ Exception එකට සමාන හෝ sub Exception වන Exception එකක් පමණී. overriding method එකේ super Exception තිබිය නොහැක.
7. abstract method අඩංගු abstract class එකක් derived concrete class  එකකින් override කරගත යුතුයි.
8. synchronized/strictfp ඇති method වලට overriding නීතිවල බලපෑමක් නැත.

Object Oriented Methodology - Abstraction හදුනාගනිමු

Abstraction කියන්නේ අදාළ තොරතුරු පමණක් නිරූපණය කරන ගුණයයි. මෙහිදී අනවශ්‍ය කොටස්  ඒකක user පෙන්වන්නේ නැහැ. උදාහරණයක් ගතහොත් කාර් එකක් සලකමු. කාර් එක දර්ශනය වන්නේ  කාර් එක විදිහට මිසක් තනි සංරචකයන් විදිහට නොවේ.

රෝද 4 ක් ඇති, බොඩි එකයි, ෂීට් ටිකයි, හා එන්ජින් අඩංගු හා තව කොටස් අඩංගු  වාහනයක් කියලා හදුන්වන්න පුලුවන්. නමුත් ඒවා driver වැදගත් වේ. නමුත් කර් එකේ passengers ලට ඒවා දැනගැනීම වැදගත් නොවේ.

තව උදාහරණයක් ගතහොත් Coffee හදන wending machine එකක් ගතහොත් ඒකෙන් Coffee එකක් හදලා දෙනවා. ඒක රහට සීනි ගානට එන විදිහට තියෙනවා. නමුත් wending machine එකේ Coffee හදන්න ඇතුලේ වන දේවල් අපට දකින්න බැහැ.මෙහිදි wending machine එකකින් Coffee සාදා ගැනීම  එකකි.

Programming වලදීත් මේ වගේ තමා. ඇතුලේ ඇති ඇති අර්ථ දැක්වීම් නොපෙන්වමින් අදාළ දේ පමණක් පෙන්වමින් Abstraction සිදුකරයි. Java වලදි Abstraction ලබා ගන්නේ Interface හා Abstraction  වලිනි. ඉන් 100% ක් ම   නිරූපනය කරන්නනේ Interface තුළ ය.

Abstraction ඇති classes හදුන්වන්නේ Abstract class කියාය. එම Abstract class නිර්මාණය කිරීමට Abstract කියන keyword එක යොදා ගැනේ. Abstraction ඇති classes හදුන්වන්නේ concrete class කියාය.

උදාහරණය

abstract class Abstract_Animal{
   //method or class
}

Method එකේ විස්තර කරලා නම් (implement කරලා නම්) ඒ Method  එක concrete method  එකක් වේ. Abstract class එකක method ඔක්කොම,  concrete method වෙන්ත් පුලුවන් ඔක්කොම Abstract method වෙන්නත් පුලුවන්. ඒකියන්නේ අඩුම තරමින් එක Abstract method එකක් ඕනෑ Abstract class එකක් සෑදීමට. Abstract method නිරූපනය කරන්නේ method signature එකත් එකක් Abstract කියන keyword එක යොදා ගෙනය . මේකේ body එකක් නැහැ. අවසන් කිරීමට සගල වරහන් යුගල වෙනුවට({) තිත් කොමා(;) යොදා ගැනේ.

උදාහරණය
abstract double area(double height, double width);

හැබැයි යම් class එකක් Abstract method එකක් හෝ කිහිපයක් තියෙනවා නම්  ඒක අනිවාර්යෙන්ම Abstract class එකක් කරන්න ඕනෑ. Abstract class එකක් refer කරලා Abstract class එකක් හදන්න(instantiate) කරන්න බැහැ.

Encapsulation එකේදී data එක සගවනවා වගේම  Abstraction  වලදි implement details සගවයි.

Abstraction වල වාසි

• ක්‍රම ලේඛනයේ පැටලිලි බව හා සංකීර්ණ බව අඩු කරයි.
• කේත වල duplicate සෑදීම වලකයි.
• නැවත භාවිතය(re-usability) වැඩිකරයි.
• කේත වල ආරක්ෂව වැඩිකිරීමට උපකාරීවේ.

Object Oriented Methodology- Polymorphism සවිස්තරාත්මකව

Polymorphism  කියන්නේ OOP වල ඇති වැදගත්ම සංකල්පයයි. මෙය හොදින්ම තේරුම් ගැනීම වැදගත් නිසා  මෙය වෙනම සම්පූර්ණ ලිපියකින් දක්වන්න සිතුවා. Polymorphism  හැදෙන්නේ ග්‍රික බාසාවේ Poly(සිංහල බාසාවේ බහු යන පදය හැදින් වීමට භාවිතා වන ග්‍රික වචනයයි) හා morph(සිංහල බාසාවේ ආකාරය යන පදය හැදින් වීමට භාවිතා වන ග්‍රික වචනයයි) යන වචන දෙක එක් වෙමිනි.

මෙහිදි Polymorphism  මගින් කියැවෙන්නේ Object එකකට විවිධ අකාර ගැනීමේ ඇති හැකියාවයි. එමෙන්ම එය ක්‍රමලේඛකරුවන්ට(Programmers) පහසුවෙන් වටහා ගත හැකි  නැවත නැවත භාවිතා කළ හැකි(reuse) මෘදුකාංග නිර්මාණය කිරීමට උපකාරී වේ.

Polymorphism ක්‍රමලේඛකරුවා හට requirement  මත depend වන විවිධ operations සහිත තනි method අඩංගු ක්‍රමලේඛ ලිවිමට නම්‍යශීලී භාවය ලබාදේ.

Java තුළදි තනි interface(ක්‍රමලේඛනයක public methods ටික body එක නැතුව නමයි return type එකයි parametersටිකයි දාලා හදන class වගේ code එකක්) මගින් අනෙක් concrete class( abstract method අඩංගු නොවන class) නිරූපනය කළ හැක. එලෙස ඒ interface එක refer කරලා හදන Object එකහි method එකක් ගත්තොත් inputs අනුව method  වල හැසිරිම වෙනස් වේ.

උදාහරණයක් ලෙස ATM account එකක් සලකමු. එහිදි Credit card, Debit card හා Other cards තියෙනවා. නමුත් card වර්ගය මුලදීම හරියට දන්නේ  නැති නිසා ඉහත card වලට Object කලින් හදලා තියාගන්නත් බහැ. මන්ද Credit card අර්ථ දක්වලා, Debit card දුන්නොත් එතැන card, match වෙනනේ  නැති ප්‍රශ්නේ එනවනේ. තවද මෙම card  තුනම මුදල් ආපසු ගැනීම(withdraw), මුදල් තැන්පක් කිරීම (deposit), ශේෂය පරික්ෂා (checkBalance) කිරීම ආදී ය පොදු සිදු කරන method වේ.

ඒ කියන්නේ CreditCard c1=new DebitCard(); කියලා දෙනවා වගේ තමා. මේක තනිකරම වැරදියි. මේකට විසදුමක් විදිහට තමයි Polymorphism ආවේ. ඒ කියන්නේ Credit card, Debit card හා Other cards වලට පොදු super class හදන්න ඕනෑ. එය මං Card කියලා දානවා. දැන් අපට පුලුවන් Card එකට variable එකක් හදලා  ATM එකට එන Card වර්ගය අනුව Object  හදලා  ඉහත සදහන් කළ method call කිරීම සිදු කරයි. ඒ කියන්නේ Card වර්ගය  අනුව define කළ method එක වෙනස් වේ.

උදාහරණය

1. class Card{
2.    public void deposit(){
3.       //do some thing, you can use this as abstract method
4.    }
5.    public void withdraw(){
6.       //do some thing, you can use this as abstract method
7.    }
8.    public void balance(){
9.       //do some thing, you can use this as abstract method
10.    }
11. }
12. class CreditCard  extends Card {
13.    public void deposit(){
14.       //Credit card, deposit money operations
15.    }
16.    public void withdraw(){
17.       //Credit card, withdraw money operations
18.    }
19.    public void balance(){
20.       //Credit card, check balance operations
21.    }
22. }
23. class DebitCard extends Card {
24.    public void deposit(){
25.       //Debit card, deposit money operations
26.    }
27.    public void withdraw(){
28.       //Debit card, withdraw money operations
29.    }
30.    public void balance(){
31.       //Debit card, check balance operations
32.    }
33. }
34. class Demo{
35.    Card card;
36.    
37. 
    
38.    public static void main(String[] args){
39.       System.out.println("Please enter your card!");
40.       String card_type=scan.next();
41.       card=selectCard(card_type); //මෙතැන input අනුව Object එක වෙනස් වේ.
42.       card.balance();
43.       //this is not a correct logic. this is an only example
44.    }
45. 
    
46.    private Card selectCard(String cardType){
47.       if(cardType.equals("credit"))
48.          return new CreditCard();
49.       else if(){
50.          return new DebitCard();
51.       }
52.    }
53. }

Polymorphism වර්ග 

Java වලදි Polymorphism වර්ග දෙකක් ගැන කියැවේ.

• Run-time Polymorphism(dynamic polymorphism)
• Compile-time Polymorphism(static polymorphism)

Compile-time polymorphism

Program එක compile වෙනකොට සිදුවෙන කොට සිදු වේ නම් ඒවා Compile time polymorphism ලෙස හදුන්වයි. මෙහිදි call කරන method එක Compiler එක තීරණය කරයි. මෙයට හොදම උදාහරණය වන්නේ Method overloading වීමයි. මෙය Static binding, Early binding හා overloading යන නම් තුනෙන්ම හදුන්වනවා.
සෑම දෙයක්ම Compile time එකේදී ක්‍රියත්මක වන නිසා මේකේ flexibility එක අඩුයි.

Method overloading කියන්නේ එකම method name එකකින් වෙනස් ආකාර වලට  method අර්ථ දැක්වීමයි. විවිධ parameters වර්ග යොදා, වෙනස් වෙනස් return type යොදා එකම නමින් ඇති method බොහාමයක් සාදා ගත හැක.

1. public int add(int a, int b){
2.    return a+b;
3. }
4. public int add(int a, int b, int c){
5.    return a+b+c;
6. }
7. 
   
8. public static void main(String args[]){
9.    System.out.println("Total of 3+4 is "+add(3, 4));
10.    System.out.println("Total of 3+4+5 is "+add(3, 4, 5));
11. }

Runtime polymorphism

Program එක run වෙනකොට සිදුවෙන කොට සිදු වේ නම් ඒවා Runtime polymorphism ලෙස හදුන්වයි. මෙහිදි call කරන method එක Compiler එක තීරණය නොකරයි. මෙය inheritance වලදි  super class එකේ method එක sub class එකේ method වලින් overriding අවස්ථා වලදී දැක ගත හැක. මෙය Dynamic binding(Dynamic binding dispatch), Late binding හා overriding  යන නම් තුනෙන්ම හදුන්වනවා.

සෑම දෙයක්ම Run time එකේදී ක්‍රියත්මක වන නිසා මේකේ flexibility එක වැඩියි.
මෙහිදි Compile time polymorphism එක Runtime polymorphism එකට වඩා වේගවත් වේ.

උදාහරණය

1. class Bike{  
2.   void run(){System.out.println("running");}  
3. }  
4. class Splendor extends Bike{  
5.   void run(){System.out.println("running safely with 60km");}  
6.   
7.   public static void main(String args[]){  
8.     Bike b = new Splendor();//upcasting  
9.     b.run();  
10.   }  
11. }  

Machine Learning(ML) හදුනා ගනිමු(1 කොටස)

Machine Learning(ML) කියන්නේ Expert System වලට වැටෙන Artificial Intelligent වල ඇති එක් කොටසකි.මෙමගින් පද්ධති වලට ස්වයංකීය ඉගෙනීමේ හැකියවක් හා අත්දැකීම් ගොඩනගා ගැනීමේ හැකියාවක් යන්ත්‍රයකට ලබා දේ. මෙය දත්ත වලට ප්‍රවේශ කළ හැකි මෘදුකාංග සංවර්ධනය ඉලක්ක කරගෙන ඒ දත්ත භාවිතයෙන් තමාම ස්වයංක්‍රීයව ඉගෙන්වීම සිදුවේ. ඒ කියන්නේ යන්ත්‍රයට තනියම ඉගෙන ගැනීමේ හැකියාව ලබා දීමයි.  

Artificial Intelligent කියන්නේ කෘතිම බුද්ධිය නම් Machine Learning(ML) නම් එයට ඇති ඉගෙනගැනී‍මේ හැකියාවයි. දත්තයි මොළයයි තිබුණට මදී  ඉගෙනුමයි ඒවායින් වඩාත් නිවැරදි තීරණ ගැනිම ඉතා වැදගත්

ඉගෙනුම ක්‍රියාවලිය දත්ත හා නිිරික්ෂණයන්, අත්දැකීම් අධීක්ෂණයෙන්‍, pattern වලට අනුව අනාගතයට වඩාත් සුදුසුම තීරණයන් ගොඩනගනු ලබයි. මෙහි ප්‍රධාන අරමුණ වන්නේ පරිගණකයකට මිනිස් මැදිහත් වීමකින් හෝ ක්‍රියාවලි අධාරයෙන් සැකසීම්  නොකොට පරිගණකයන්ට ස්වයංකීයව ඉගෙනීමට ඉඩ ලබා දීමයි.

Machine Learning ප්‍රඩාන වශයෙන් කොටස් 3කට කැඩෙනවා. ඒවාට  Learning methods කියලා කියනවා.

• Supervised Learning
• Unsupervised Learning
• Reinforcement learning

Supervised Learning

මෙහිදී label කරන ලද නිදර්ශනයක් භාවීතයෙන් පරණ දත්ත වල සිට අලුත් දත්ත දක්වා ඉගැන්වීම් වලින් අනාගතය අවස්ථාවන් ගැන අනාවැකි ලබා ගැනීම සිදුකරයි.  ආරම්භයේ්දී training data set(input කරන data) විශ්ලේශණය කරමින් අනාවැකි Output කරන්න සූත්‍රයක්(function) හදාගන්නවා. ඉදිරියට එන දත්ත ලබා ගන්නවා වගේම අලුත් train කරන data එකක් compare කරලා දෝෂ නිර්ණය කිරීම ද මෙහි භාවිතා වන algorithm වලින් සිදුකරයි. එම ලබාගත් දෝෂයන් ට  අදාලව model යන් modify(වෙනස්) වේ.

මේකෙදී input data හා output data දෙකම වැදගත් සංරචක දෙකකි.

උදාහරණ

• ඉදිරි කාළගුණ වර්තාව
• ඉදිරි මාස 6ක කොටස් වෙළද පලේ කොටසක මිළ ගණන ය කිරීම.

ඉහත ලේබල් කරනවා කියන එකෙන් අදහස් කරන්නේ දත්ත කුමන වර්ගයේ දත්තයක්ද කියා හදුනා ගැනීමයි. උදාහරණයක්  ලෙස සැබෑ ජීවිතයේදී බල්ලන් ගත්විට, බල්ලකු හදුනා ගැනීමට බල්ලා ලෙස නම් කරගත් දත්ත උපකාරීවේ. එහි පූසා හදුනාගැනීමට පුසා කියා නම්කර ගත් දත්ත, කුරුල්ලා හදුනාගැනීමට කුරුල්ලා කියා නම්කර ගත් දත්ත අඩංගු වේ. මෙය ලේබල් කිරීම කියා හදුන්වයි.

Unsupervised Learning

මෙහිදී label කරන ලද නිදර්ශනයන් හා වර්ගීකණය දත්ත සලකා නොබැලේ.  රැස් කරගත් දත්ත වලින් Pattern එකක් හදුනා ගැනීමට මෙහි ඇති algorithm භාවිතා කරයි.

මේකෙදී input data පමණක් වැදගත් සංරචකයක් වේ.

උදාහරණ

• සමාජ ජාල අඩවියක එකට බැදුණු කණ්ඩායම් සෙවීම.
• e-commerce website එකක recommendation system

Reinforcement Learning

මෙහිදි agent කෙනෙකු යොදාගැනීම සිදුවේ. agent විසින් actions ගොඩනගමින් සිදුවන errors හා ලබාගන්නා reward සලකා බලමින් environment  එකත් එක්ක සම්බන්ධ වේ. Trial(පරික්ෂාවන්) and error search(දෝෂ සෙවීම) and delayed reward(ප්‍රමාදිති ප්‍රතිඑල) මෙයට සුවිශේෂි ලක්ෂණ වේ.

උදාහරණ

• ස්වයංක්‍රිය ධාවනය වන මෝටර් රථ
• Chess, Car, Pacman වැනි Game සදහා

මෙම පාඩම් මාලාව ඉදිරියට ගෙනයාම ඉල්ලුම මත තීරණය කෙරේ.

Access Modifiers හදුනාගනිමු

දී ඇති class කට යම් class එකක්, constructorඑකක්, attributeඑකක් හෝ method එකක් ප්‍රවේෂ කළ හැකිදැයි බලන්නේ මෙම Access Modifiers වලිනි.

Public

ඕනෑම code එකකට මෙමගින් අර්ථ දක්වන Members(attributes and methods) ලට ප්‍රවේශ විමට ඉඩ ලබා දේ. එහිදි  code එක තියෙන් තැනවත් package එක වත් අදාළ වෙන්නේ නැහැ. ඒ කියන්නේ වෙන වෙන class වලට හා වෙන වෙත් package වලට public වලින් අර්ථ දක්වන Members ලට ප්‍රවේශ කරන්න පුලුවන් බවයි.

1. public class Clock {
2.     public long time = 0;
3. }
4. 
   
5. 
   
6. public class ClockReader {
7.     Clock clock = new Clock();
8. 
   
9.     public long readClock{
10.         return clock.time;
11.     }
12. }

ඉහත උදහරණය සලකමු. line 2 දී time කියලා variable එක අර්ථ දක්වලා තියෙනවා. line 7 දී Clock කියන class  එක refer කරලා clock නමින් Clock object එකක් හදලා තියෙනවා. line 9 දී  readClock method එක තුළින් Clock එකේ time එකේ data කෙළින්ම ලබාගන්නවා.

Private

මෙමගින් අර්ථ දක්වන Members(attributes and methods) ලට ප්‍රවේශ විමට  හැකිවන්නේ එම Members ලා අයත් වන class එකේම අනෙක් Members ලටම පමණි.

උදා:

public class Person {

    private long age= 0;

}

මෙහි time කියන variable එකට Access කළ හැක්කේ Clock කියනclass එකේ members ලටම පමණී. නමුත්  accessor methods හරහා මෙම variable එකට ප්‍රවේශ විය හැක. එය Encapsulation කතා කරන ලදී. 

Constructor එකක් private වුනොත් එකකෙන් කියන්නේ ඒ Constructor එක  පිටත ඇති වෙන class එකක define කරන්න බැරි බවයි. එය ගතහැකි වන්නේ ඒ class එකේම ඇති වෙනත් Constructor එකකින් හෝ වෙනත් static method එකකිනි.

1.  public class Man {
2.     private int age= 0;
3. 
   
4.     private Man(intage) {
5.         this.age= age;
6.     }
7. 
   
8.     public Man(int age, int timeOffset) {
9.         this(age);
10.         this.age+= timeOffset;
11.     }
12. 
    
13.     public static Man newAge() {
14.         return new Clock(System.currentTimeMillis());
15.     }
16. 
    
17. }

ඉහත උදාහරණය සලකන්න. line 4 දී Constructor, private  වෙලා තියෙනවා. එයින් කියැවෙන්නේ ඒ  Constructor වෙනත් Class එකක define කරන්න බැරි බවයි. line 8 දී ඊළග Constructor එක define එක තියෙනවා, ඒක publicවෙලායි තියෙන්නේ. එකේ අදහස ඒ  Constructor වෙනත් ඕනෑම Class එකක define කරන්න පුලුවන් බවයි.  line 9 දී  line 4 හි ඇති Constructor එක "this" keyword එකෙන් අරගෙන තියෙනවා. line 13 දී private වුන Constructor එක static method එකකින් අරගෙන තියෙනවා.

මෙය වෙනත් class එකක පහත ආකර දෙකනේ කැමති විදිහකට define කරන්න පුලුවන්.
පළමු ආකාරය - public constructor යොදාගෙන.
Man m1=new Man(27, 3);
දෙවන ආකාරය - static method යොදාගෙන.
Man m2=Man.newAge();

Protected

මේක ටිකක් වෙනස්ම access modifier එකක් වෙනවා. මේ තරමක් default එකට ටිකක් සමාන වුනත් Inheritance වලදී ටිකක් වෙනස්. protected වලින් define කරන member කෙනෙක් ට access  කරන්න හැකි වෙන්නේ ඒ package එකේ ඇති ඕනෑම Class  එකකට හා වෙනත් package  එකක ඇති sub class(child class) එකකටම පමණී. 

උදා1.

1. public class Clock {
2.     protected long time = 0;    // time in milliseconds
3. }
4. 
   
5. public class SmartClock() extends Clock{
6.     public long getTimeInSeconds() {
7.         return this.time / 1000;
8.     }
9. }

ඉහත උදාහරණයේ දැක්වෙන්නේ එකම package එකේ දී sub class එකක් super class එකේ protected වූ time කියන variable එකට access කරන ආකාරයයි. 

උදා2.

1. package p1; 
2. public class Clock {
3.     protected long time = 0;    // time in milliseconds
4. }

1. package p2; 
2. import p1.*; 
3. public class SmartClock() extends Clock{
4.     public long getTimeInSeconds() {
5.         return this.time / 1000;
6.     }
7. }

ඉහත උදාහරණයේ දැක්වෙන්නේ  වෙනස්ම package දෙකකදී sub class එකක් super class එකේ protected වූ time කියන variable එකට access කරන ආකාරයයි. 

උදා3.

1. public class Clock {
2.     protected long time = 0;    // time in milliseconds
3. }
4. 
   
5. public class SmartClock(){
6.     Clock  clock=new Clock  ();
7.     public long getTimeInSeconds() {
8.         return clock.time / 1000;
9.     }
10. }

ඉහත උදාහරණයේ දැක්වෙන්නේ එකම package එකේ දී sub class එකක් නොවන විට එක class එකක protected වූ time කියන variable එකට අනෙක්  class එක access කරන ආකාරයයි. 

default 

මෙය package modifier කියලත් හදුන්වනවා. මෙයට වෙනම keyword එකක් නැහැ. හිස් අවකාශයකින් දකවනවා. සෑම විටම එකම package එකේ classes අතර data වලට access කිරීමේ හැකියාව ලබා දේ. නමුත් වෙනත් package වල  data වලට access  කිරීමට  කුමන අයුරිකින් වත් නොහැක.

එය protected මෙන් sub class එකකට එකකින් ලැබෙන්නාක් මෙන් ලබා ගතනොහැක.

public class Clock {

    long time = 0;

}

public class ClockReader {

    Clock clock = new Clock();

    public long readClock{

        return clock.time;

    }

}

ඉහත උදාහරණයේ දැක්වෙන්නේ එකම package එකේ දී sub class එකක් super class එකේ default වූ time කියන variable එකට access කරන ආකාරයයි. 

Class Access Modifiers

class එකේ membersලා define කරන්න ඉහත සියලුම Modifiers භාවිතා කළත් 

class හදද්දි ඒ Modifiers සියල්ලම භාවිතා කරන්න බැහැ. Private හා Protected යන Modifiers දෙකම class එකක් හදන්න යොදාගන්නේ නැහැ. ඒවා යෙදීමෙන් code වලංගු භාවය නැතිවේ.

බොහෝ විට class එකක් හදන්න යොදාගන්නේ public හා default modifiers ය. යම් modifier එකක් class  එකකට යෙදෙන විට class  එකේ membersලට modifier  දී තිබුණත් මුලින්ම class  එකේ ඇති modifier එක සලකා බැලේ පසුව තමා class  එකේ members ලගේ modifier සලකා බලන්නේ.

class එක default නම් එකේ members ලා public වුනත් නැතත් වෙනත් package වල class වලට ඒ members ලගේ data වලට access කරන්න බැහැ. එමෙන්ම class එක public වුනොත් class එකේ members ලගේ access modifiers සලකා බැලිය යුතුවේ.

සාරංශය

geeksforgeeks site එකෙන්