Sunday, April 11, 2021

Java Programming sinhala tutorial - Polymorphism - Part 29

Polymorphism

     Polymorphism යනු OOP concept වල පවතින වැදගත් ලක්ෂණයක්. එය අපිට ඉඩ දෙනවා යම් ක්‍රියාවක් වෙනස් ආකාරයන්ගෙන් සිදු කිරීමට. වෙනත් විදියකට කිව්වොත්, අපිට පුළුවන් එක interface එකක් define කරලා වෙනස් implementation සිදු කිරීමට. "poly" වචනයේ තේරුම විවිධ වන අතර "morphs" යනු ආකාරයන් වේ. ඒ නිසා එහි තේරුම විවිධ ආකාරයන් වේ.

    යම් පුද්ගලයෙක් එක විට පියෙක්, පුතෙක්, සේවකයෙක් වීම සාමාන්‍ය ජිවිතයේ මෙම concept එකට උදාහරණයක් විදියට කියන්න පුළුවන්.

    Polymorphism ආකාර 2 කට බෙදන්න පුළුවන්.
  1. Compile Time Polymorphism 
  2. Run Time Polymorphism  

Compile Time Polymorphism

    Static polymorphism ලෙසද මෙය හදුන්වනවා. Compile time polymorphism අපිට method overloading හා operator overloading මගින් සිදු කරන්න පුළුවන්. නමුත් operator overloading සදහා Java support නොකරන නිසා method overloading පමණක් භාවිතා කරයි.

    මෙහිදී එකම නමින් methods  නිර්මාණය කරන අතර ඒවායේ parameter list එක වෙනස් වේ.


Method Overloading 
  • Method overloading හිදී එකම නමින් methods  නිර්මාණය කරන අතර ඒවායේ parameter list එක වෙනස් කරනු ලබයි.
  • මෙහිදී return type එක මගින් පමණක් method overload කල නොහැකි අතර parameter list එක වෙනස් කරන අතර return type එක වෙනස් කරන්න පුළුවන්.
public int mA(int x) { return 100; }
public char mA(int x, int y) { return 'x'; }
  • අපිට static method ද  overload කල හැක. මෙහිදී ද static keyword එක මගින් පමණක් method overload කල නොහැකි අතර parameter list එක වෙනස් කල යුතු වේ.
public static int mA(int x) { return 100; }
public static char mA(int x, int y) { return 'x'; }

 

Run Time Polymorphism  

    Dynamic Method Dispatch ලෙසද මෙය හදුන්වන්න පුළුවන්. මෙහිදී overriding method එකට run time එකේදී call කරයි. Method overriding මගින් run time polymorphism ලබා ගනි. 

    මෙහිදී parent/ base  class එකෙහි  method, child/ derived class එහෙහිදී එම method name එකම, එම parameter list එකම සහිතව හා එහි access කල ආකාරයටම නිර්මාණය කිරීම method overriding වේ. මෙහිදී parent/ base  class එකෙහි  method එක hide වී child/ derived class එහෙහි method එක run වේ.


Method Overriding
  • Method overriding යනු parent/ base  class එකෙහි  method, child/ derived class එහෙහිදී එම method name එකම හා එම parameter list එකම සහිතව නිර්මාණය කිරීමය. 
  • මෙහිදී parent/ base  class එකෙහි  method එක hide වී child/ derived class එහෙහි method එක run වේ.
  • Overriding method එකෙහි access modifier, base class එකෙහි method එකෙහි access modifier එකට සමාන හෝ ඊට වඩා වැඩි විය යුතුය.
class Parent {
    protected void mA() {
        System.out.println("parent");
    }
}

class Child extends Parent {
    @Override
    public void mA() {
        System.out.println("child");
    }
}
  • private, final හා static method override කල නොහැක.
  • Overriding method එකෙහි return type එක සමාන හෝ derived type එක විය යුතුයි.
class Parent {
    Parent p;
    
    Parent mA() {
        return p;
    }
    
    int mB() {
        return 5;
    }
}

class Child extends Parent {
    Child c;
    
    @Override
    Child mA() {
        return c;
    }
    
    @Override
    int mB() {
        return 10;
    }
}
  • super keyword එක මගින් base class method එක call කල හැක.
class Parent {  
    void mB() {        
        System.out.println("Parent");
    }
}

class Child extends Parent {
    void mB() { 
        super.mB();
        System.out.println("Child");
    }
}
  • Super-class overridden method එක exception එකක් throw කර නොමැති නම් subclass overriding method එකෙහිදී uncheck exception පමණක් throw කල හැක.
class Parent {  
    void mB() {        
        System.out.println("Parent");
    }
}

class Child extends Parent {
    void mB() throws ArithmeticException{ 
        System.out.println("Child");
    }
}
  • Super-class overridden method එක exception එකක් throw කර ඇත්නම් subclass overriding method එකෙහිදී එම exception එක හෝ එහි sub exception එකක්  throw කල හැක. ඒ වගේම subclass overriding method එකෙහිදී කිසිම exception එකක් throw නොකිරීමද කල හැක.
class Parent {  
    void mB() throws RuntimeException{        
        System.out.println("Parent");
    }
}

class Child1 extends Parent {
    void mB() throws RuntimeException{ 
        System.out.println("Child1");
    }
}

class Child2 extends Parent {
    void mB() throws ArithmeticException{ 
        System.out.println("Child2");
    }
}

class Child3 extends Parent {
    void mB() { 
        System.out.println("Child3");
    }
}

අපි ඊලග ලිපියෙන් Java ගැන තවත් විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Subscribe to: Posts (Atom)