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 එකෙන්