பாலிமார்பிசம் (polymorphism) கோட்பாடு நிரலாக்க மொழிகளில் எவ்வாறு நடைமுறைப்படுத்தப் படுகின்றது?

பொருள் நோக்கு நிரலாக்க மொழிகளின் அடிப்படை கோட்பாடுகளாக நான்கு கருத்துக்கள் உள்ளன

அவையாவன:

1.   Encapsulation(உறைபொதியாக்கம்)

2.   Abstraction(கருத்துப்பொருள்)

3.   Inheritance(மரபுரிமம்)

4.   polymorphism(ப்ல்லுருவாக்கம்)

இந்த கட்டுரையில் முக்கியமாக பல்லுருவாக்கம் என்றால் என்ன என்றும்

அவை முன்னனி மொழிகளான C++,JAVA, C SHARP ஆகியவற்றில் எவ்வாறு நடைமுறைப்படுத்தப்படுகின்றது என்றும் பார்ப்போம்.

பல்லுருவாக்கம்(POLYMORPHISM) என்றால் என்ன?

பல்லுருவாக்கம் எனப்படுவது ஒரே பொருள் வெவ்வேறு சூழ்நிலைகளில் வெவ்வேறு வடிவங்கள் எடுப்பதை குறிக்கப் பயன்படுகின்றது. poly என்கின்ற வார்த்தைக்கு many என்றும் morphs என்கின்ற வார்த்தைக்கு forms என்றும் கிரேக்க மொழியில் அறியப்படுகின்றது. ஆங்கிலத்தில் polymorphism  என்றால் many forms என்று அறியப்படுகின்றது. polymorphism என்பது இருவேறு முறைகளில் அமுல்படுத்தப்படுகின்றது.

1.   compile time polymorphism (நிரல் பெயர்க்கும் பொழுது நடைபெறுவது)

2.   Run time polymorphism. (இயக்க நேரத்தில் நடைபெறுவது)

compile time polymorphism (நிரல் பெயர்க்கும் பொழுது நடைபெறுவது)

நிரல் பெயர்க்கும் போது நடைபெறும் பாலிமார்பிசம் ஆனது static binding எனப்படுகின்றது. இதன் இரண்டு வடிவங்களானது

1.   method overloading

2.   operator overloading

Method overloading

ஒரே கிளாசிற்குள் ஒன்றுக்கும் மேற்பட்ட வழிமுறைகளானது(methods) ஒரே பெயரில் இருக்கும். ஆனால் அதற்கு அனுப்பபடும் பராமீட்டர்களானது கீழ்கண்ட ஏதாவது முறையில் வேறுபட்டிருக்கும்.

1.   வெவேறு டேட்டா டைப்புகள்

2.   எண்ணிக்கை

3.   வரிசை

வெவ்வறு டேட்டா டைப்புகள் என்பதற்கு உதாரனமாக ஒரு மெத்தடிற்கு int டேட்டாவும் அதே பெயரில் உள்ள மற்றொரு மெத்தடிற்கு float டேட்டாவும் அனுப்பப்படலாம். எண்ணிக்கை என்பதை கூறும் போது உதாரணமாக ஒன்றுக்கு இரண்டு int டேட்டாவும் மற்றொன்றிற்கு மூன்று int டேட்டாவும் அனுப்பப்படலாம். வரிசை என்றால் ஒன்றிற்கு int, float என்கின்ற வரிசையிலும் மற்றொன்றிற்கு float,int என்கின்ற வரிசையிலும் பராமீட்டர் ஆனது அனுப்பப்பட்டிருகலாம். ஆதலால் மேற்கண்ட ஏதோ ஒரு முறையில் பராமீட்டரானது வேறுபட்டிருக்கும். எந்த மெத்தட் ஆனது அழைக்கப்பட வேண்டும் என்பது நாம் அனுப்பும் பராமீட்டரை பொருத்தே அமைகின்றது. இதுவே மெத்தட் ஓவர்லோடிங் எனப்படுகின்றது.

c++,java,c sharp ஆகிய மூன்று மொழிகளுமே மெத்தட் ஒவர் லோடிங்கை ஆதரிக்கின்றது.

உதாரண நிரல்கள்:

c++:

#include <iostream>

using namespace std;

class printData

{

   public:

      void print(int i) {

        cout << "Printing int: " << i << endl;

      }

      void print(double  f) {

        cout << "Printing float: " << f << endl;

      }

      void print(char* c) {

        cout << "Printing character: " << c << endl;

      }

};

int main(void)

{

   printData pd;

   // Call print to print integer

   pd.print(5);

   // Call print to print float

   pd.print(500.263);

   // Call print to print character

   pd.print("Hello C++");

   return 0;

}

மேலே உள்ள நிரலில்   printData என்கின்ற கிளாசிற்குள் print என்னும் பெயரிலேயே மூன்று மெத்தட்கள்(வழிமுறைகள்) உள்ளன. ஒவ்வொன்றும் வெவ்வேறு டைப்பான டேட்டக்களை ஏற்கின்றது.

வெளியீடு:

Printing int: 5

Printing float: 500.263

Printing character: Hello C++

ஜாவா:

class Calculation{  

  void sum(int a,int b)

{

System.out.println(a+b);

}  

  void sum(int a,int b,int c)

{

System.out.println(a+b+c);

}  

  

  public static void main(String args[])

{  

  Calculation obj=new Calculation();  

  obj.sum(10,10,10);  

  obj.sum(20,20);  

  

  }  

}  

மேலே உள்ள ஜாவா நிரலில் Calculation என்கின்ற கிளாசிற்குள் sum என்கின்ற பெயரிலேலேயே இரண்டு மெத்தட்கள் உள்ளன.ஒன்று இரண்டு int இன டேட்டாவையும் மற்றொன்று மூன்று int டைப் டேட்டவையும்  ஏற்கின்றது. ஆதலால் எந்த மெத்தட் ஆனது அழைக்கப்பட வேண்டும் என்பதை பராமீட்டர்களின் எண்ணிக்கை தீர்மானிக்கின்றது.

வெளியீடு:

30

40

சி ஷார்ப்:

using System;

class Test
{
    static void Foo(int  x)
    {
        Console.WriteLine("Foo(int x)");
    }
   
    static void Foo(string  y)
    {
        Console.WriteLine("Foo(string y)");
    }
   
    static void Main()
    {
        Foo("text");
    }
}

வெளியெடு:

Foo(string y)

ஆபரேட்டர் ஓவர்லோடிங்:

பொதுவாக ஆபரேட்டர்களை (+, - போன்ற ) வேரியபிள்களில் மட்டும் தான் உபயோகிப்போம். ஆனால் அதே ஆபரேட்டர்களை ஆப்ஜெக்ட்களிலும் உபயோகப்படுத்தலாம். அப்படி உபயோகப்படுத்தப்பட வேண்டுமெனில் தனியாக மெத்தட்களை எழுத வேண்டியிருக்கும். முதலில் operator என்கின்ற கீவேர்டும் பிறகு ஆபரேட்டரும் கொண்டு (உதாரணத்திற்கு operator  +) மெத்தட் எழுத வேண்டும்.

c++,c# மொழிகளில் ஆபரேட்டர் ஒவர்லோடிங் உண்டு. ஜாவாவில் ஆபரேட்டர் ஓவர்லோடிங் கிடையாது.

c++:

உதாரண நிரல்:

#include <iostream>

using namespace std;

class Box

{

   public:

      double getVolume(void)

      {

         return length * breadth * height;

      }

      void setLength( double len )

      {

          length = len;

      }

      void setBreadth( double bre )

      {

          breadth = bre;

      }

      void setHeight( double hei )

      {

          height = hei;

      }

      // Overload + operator to add two Box objects.

      Box operator+(const Box& b)

      {

         Box box;

         box.length = this->length + b.length;

         box.breadth = this->breadth + b.breadth;

         box.height = this->height + b.height;

         return box;

      }

   private:

      double length;      // Length of a box

      double breadth;     // Breadth of a box

      double height;      // Height of a box

};

// Main function for the program

int main( )

{

   Box Box1;                // Declare Box1 of type Box

   Box Box2;                // Declare Box2 of type Box

   Box Box3;                // Declare Box3 of type Box

   double volume = 0.0;     // Store the volume of a box here

   // box 1 specification

   Box1.setLength(6.0); 

   Box1.setBreadth(7.0); 

   Box1.setHeight(5.0);

   // box 2 specification

   Box2.setLength(12.0); 

   Box2.setBreadth(13.0); 

   Box2.setHeight(10.0);

   // volume of box 1

   volume = Box1.getVolume();

   cout << "Volume of Box1 : " << volume <<endl;

   // volume of box 2

   volume = Box2.getVolume();

   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:

   Box3 = Box1 + Box2;

   // volume of box 3

   volume = Box3.getVolume();

   cout << "Volume of Box3 : " << volume <<endl;

   return 0;

}

மேலே உள்ள நிரலில் Box3 = Box1 + Box2; என்கின்ற வரியானது 

Box3= Box1.operator+(Box Box2/ 

என்கின்ற அர்த்தமாக கம்பைலர் எடுத்துக் கொள்ளும்.

வெளியீடு:

Volume of Box1 : 210

Volume of Box2 : 1560

Volume of Box3 : 5400

c# :உதாரண நிரல்

using System;

class Widget

{

    public int _value;

    public static Widget operator +(Widget a, Widget b)

    {

        // Add two Widgets together.

        // ... Add the two int values and return a new Widget.

        Widget widget = new Widget();

        widget._value = a._value + b._value;

        return widget;

    }

    public static Widget operator ++(Widget w)

    {

        // Increment this widget.

        w._value++;

        return w;

    }

}

class Program

{

    static void Main()

    {

        // Increment widget twice.

        Widget w = new Widget();

        w++;

        Console.WriteLine(w._value);

        w++;

        Console.WriteLine(w._value);

        // Create another widget.

        Widget g = new Widget();

        g++;

        Console.WriteLine(g._value);

        // Add two widgets.

        Widget t = w + g;

        Console.WriteLine(t._value);

    }

}

Output

1

2

1

3

இயக்க நேர பல்லுருவாக்கம்:(Run time polymorphism)

இயக்க நேர பல்லுருவாக்கம் என்பது Late binding என்றும் Dynamic polymorphism மற்றும் மெத்தட் ஓவர்ரைடிங் என்றும் அறியப்படுகின்றது.

மெத்தட் ஓவர்ரைடிங் என்பது பேஸ் கிளாசிலும் டெரிவ்டு கிளாசிலும் ஒரே பெயரில் மெத்தட் இருக்கும் பராமீட்டரும் ஒரே மாதிரி இருக்கும். அழைக்கப்படும் பொழுது எந்த கிளாசிற்கு ஆப்ஜெக்ட் அந்த மெத்தடை அழைக்கின்றதோ அதற்கேற்றார்போல் மெத்தட் அழைக்கப்படும். c++ மொழியில் பேஸ் கிளாசில் virtual என்கின்ற கீவேர்டு மெத்தட் தலைப்பில் இருக்கும். ஜாவாவில் அந்த மாதிரியான கீவேர்டு எதுவும் கிடையாது. சி ஷார்ப்பில் பேஸ் கிளாசில் உள்ள மெத்தடில் virtual என்கின்ற கீவேர்டும் டெரிவ்டு கிளாசில் உள்ள் மெத்தடில் override என்கின்ற கீவேர்டும் சேர்க்கப்பட்டிருக்கும்.

உதாரண நிரல்கள்

சி++:

#include <iostream> 

using namespace std;

class Shape {

   protected:

      int width, height;

   public:

      Shape( int a=0, int b=0)

      {

         width = a;

         height = b;

      }

      virtual int area()

      {

         cout << "Parent class area :" <<endl;

         return 0;

      }

};

class Rectangle: public Shape{

   public:

      Rectangle( int a=0, int b=0):Shape(a, b) { }

      int area ()

      { 

         cout << "Rectangle class area :" <<endl;

         return (width * height); 

      }

};

class Triangle: public Shape{

   public:

      Triangle( int a=0, int b=0):Shape(a, b) { }

      int area ()

      { 

         cout << "Triangle class area :" <<endl;

         return (width * height / 2); 

      }

};

// Main function for the program

int main( )

{

   Shape *shape;

   Rectangle rec(10,7);

   Triangle  tri(10,5);

   // store the address of Rectangle

   shape = &rec;

   // call rectangle area.

   shape->area();

   // store the address of Triangle

   shape = &tri;

   // call triangle area.

   shape->area();

   return 0;

}

வெளியீடு:

Rectangle class area

Triangle class area

ஜாவா:

class Vehicle{  

void run(){System.out.println("Vehicle is running");}  

}  

class Bike2 extends Vehicle{  

void run(){System.out.println("Bike is running safely");}  

  

public static void main(String args[]){  

Bike2 obj = new Bike2();  

obj.run();  

}  

வெளியீடு:

Bike is running safely

சி ஷார்ப்:

 

//Base Class

public class Bclass

{

public virtual void Sample1()

{

Console.WriteLine("Base Class");

}

}

// Derived Class

public class DClass : Bclass

{

public override void Sample1()

{

Console.WriteLine("Derived Class");

}

}

// Using base and derived class

class Program

{

static void Main(string[] args)

{

// calling the overriden method

DClass objDc = new DClass();

objDc.Sample1();

// calling the base class method

Bclass objBc = new DClass();

objBc.Sample1();

}

}

வெளியீடு:

Derived Class

Derived Class

பின் குறிப்பு:

மெத்தட் ஒவர்லோடிங்கில் ரிட்டர்ன் டைப்பை அடிப்படையாக கொண்டு மெத்தடை ஒவர்லோட் செய்ய இயலாது.

                                                                                     -              முத்துகார்த்திகேயன், மதுரை

 contact:919629329142