Polimorfism

Polimorfismul obiectual se manifestă în lucrul cu obiecte din clase aparținând unei ierarhii de clase, unde. prin redefinirea unor date sau metode, se obțin membri diferiți având însă același nume.

Pentru a permite acest mecanism, metodele care necesită o decizie contextuală (în momentul apelului), se declară ca metode virtuale (cu modificatorul virtual). În mod curent, C# modificatorului virtual al funcției din clasa de bază, îi corespunde un specificator override al funcției din clasa derivată ce redefinește funcția din clasa de bază.

O metodă ne-virtuală nu este polimorfică și, indiferent de clasa căreia îi aparține obiectul, va fi invocată metoda din clasa de bază.

Limbajul C# admite trei tipuri de polimorfism:

• polimorfism parametric
• polimorfism ad-hoc
• polimorfism de moștenire

Polimorfismul parametric

Această formă de polimorfism este preluată de la limbajele neobiectuale: Pascal, C. Prin această formă de polimorfism, o funcție va prelucra orice număr de parametri. Pentru aceasta se va folosi un parametru de tip params.

Să considerăm o funcție F cu un parametru formal, de tip vector, declarat folosind modificatorul params. Acest lucru va permite folosirea mai multor parametri actuali, la apelul funcșiei, prin intermediul acelui singur parametru formal.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Exemplu
{
    class Program
    {
        static void F(params int[] arg)
        {
            Console.WriteLine("Apelul functiei F cu {0} parametri:",
            arg.Length);
            for (int i = 0; i < arg.Length; i++)
            {
                Console.WriteLine("arg[{0}] = {1}", i, arg[i]);
            }
            Console.WriteLine("");
        }
        static void Main(string[] args)
        {
            F();
            F(2);
            F(4, 6);
            F(new int[] { 1, 2, 3 });
        }
    }
}

 

Polimorfismul ad-hoc

Acest tip de polimorfism se mai numește și supraîncărcarea metodelor. Prin acest mecanism se pot defini în cadrul unei clase mai multe metode, toate având același nume, dar cu tipul și numărul de parametri diferiți. La compilare, în funcție de parametri folosiți la apel, se va apela o funcție sau alta.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PolimorfismAdHoc
{
    class Program
    {
        static void F()
        {
            Console.WriteLine("Functia F fara parametri\n");
        }
        static void F(int a, int b)
        {
            Console.WriteLine("Functia F cu doi parametri: int si respectiv int\n");
        }
        static void F(int a, double b)
        {
            Console.WriteLine("Functia F cu doi parametri: int si respectiv float\n");
        }
        static void Main(string[] args)
        {
            F();
            F(2, 3);
            F(4, 6.3);
        }
    }
}

Polimorfismul de moștenire

În cazul acestui tip de moștenire vom discuta într-o ierarhie de clase. În acest caz ne punem problema apelării metodelor, având aceeași listă de parametri formali, metode ce fac parte din clase diferite.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Exemplu
{
    class Baza
    {
        public void Afis()
        {
            Console.WriteLine("Apelul functiei Afis din clasa de baza\n");
        }
    }
    class Derivata : Baza
    {
        public void Afis()
        {
            Console.WriteLine("Apelul functiei Afis din clasa derivata\n");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Derivata obiect2 = new Derivata();
            Baza obiect1 = obiect2;
            obiect1.Afis(); //(1)
            obiect2.Afis(); //(2)
        }
    }
}

Să discutăm despre prima linie afișată (cea de-a doua este evidentă). Apelul lui Afis() se rezolvă în momentul compilării pe baza tipului declarat al obiectului. Deci linia (1) din program va duce la apelul lui Afis() din clasa Baza, chiar dacă obiect1 a fost instanțiat pe baza unui obiect din clasa Derivata.