Mostenirea este unul din principiile fundamentale ale programarii. Cum functioneaza? Definim o clasa generala, clasa de baza, ce are caracteristici comune pentru o multime de elemente asemanatoare. Apoi, clasa de baza va fi mostenita de alte clase, clase derivate, care isi vor adauga pe langa caracteristicile mostenite, numai caracteristici care le identifica in mod unic. O clasa derivata este o versiune specializata a unei clase de baza. O clasa derivata va mosteni toate variabilele, metodele, proprietatile si indexarile definite in clasa de baza, la care va adauga elemente proprii, unice.

    Este nevoie de conceptul de mostenire pentru a evita repetitia definirii unor clase care au in comun mai multe caracteristici. In programare, mostenirea se refera la clasificare, la o relatie intre clase.

    In C#, o clasa derivata poate mosteni de la o singura clasa de baza ( mostenire simpla ).

    O clasa de baza poate fi derivata in mai multe clase derivate. O clasa derivata poate fi clasa de baza pentru alta clasa derivata.

    O clasa de baza impreuna cu toate clasele derivate, direct sau indirect, formeaza o ierarhie de clase. Reamintim, toate clasele din C# mostenesc clasa Object.

Exemplu de mostenire :

    //clasa de baza
    class Forma
    {
        public double inaltime;
        public double latime;
        public void AfiseazaDimensiune()
        { 
            Console.WriteLine("inaltime: {0}, latime: {1}",inaltime,latime);
        }
    }

    //clasa Dreptunghi mosteneste
    //clasa Forma
    class Dreptunghi : Forma
    {
        public double Aria()
        {
            //clasa Dreptunghi poate
            //referi membrii clasei Forma
            //ca membri proprii
            return inaltime * latime;
        }
    }

In metoda Main :

    Dreptunghi d1 = new Dreptunghi();
    d1.inaltime = 32;
    d1.latime = 2;
    Console.WriteLine("Aria: {0}", d1.Aria());

    In ceea ce priveste sintaxa la mostenire, se observa ca numele clasei de baza urmeaza dupa numele clasei derivate, separate de “:”.

    Clasa de baza Forma poate fi utilizata independent, chiar daca din ea deriva alte clase.

    Forma forma = new Forma();
    forma.AfiseazaDimensiune();

    Despre accesul la membri : in cazul in care in clasa de baza, declaram membri de tip private, ( private double inaltime; private double latime; ), clasa Dreptunghi  nu i-ar mai fi putut accesa. Membrii privati sunt accesibili doar pentru codul din interiorul clasei lor, deci, mostenirea NU va anula restrictiile impuse.

    Pentru a putea depasi aceasta problema si a nu fi nevoie sa declaram membri public ( vor fi accesibili in tot restul codului ), una din solutii ar fi declararea membrilor ca protected. Acest modificator de acces face ca membri protejati sa fie public in cadrul unei ierarhii de clase, dar privati in afara ei.

    O intrebare interesanta cand se discuta despre mostenire, apare cand clasele de baza si clasele derivate dispun de constructori proprii : Ce constructor se utilizeaza pentru a construi un obiect apartinand unei clase derivate? Raspuns : constructorul clasei de baza construieste portiunea obiectului care apartine de clasa de baza, constructorul clasei de baza construieste portiunea care apare de clasa derivata.

    //clasa de baza
    class Forma
    {
        //membri variabila
        protected double _inaltime;
        protected double _latime;
        //constructor pentru clasa Forma
        public Forma(double inaltime, double latime)
        {
            _inaltime = inaltime;
            _latime = latime;
        }
    }

    //clasa Dreptunghi mosteneste
    //clasa Forma
    class Dreptunghi : Forma
    {
        //membru variabila privat
        string stil;

        //utilizam base pentru
        //a executa constructorul 
        //clasei de vaza
        public Dreptunghi(string s, double inaltime, double latime)
        : base(inaltime, latime)
        {
            stil = s;
        }
    }

Constructorul clasei Dreptunghi initializeaza si membrii mosteniti de la clasa Forma impreuna cu campul propriu stil.

    O alta situatie legata de mostenire este atunci cand intr-o clasa derivata definim un membru al carui nume coincide cu numele unui membru din clasa de baza.

    class A
    {
        public int a;

    }

    class B : A
    {
        int a;

    }

In acest caz, la compilare va aparea mesajul :

‘Inheritance.B.a’ hides inherited member ‘Inheritance.A.a’. Use the new keyword if hiding was intended.   Daca se doreste ca  membrul clasei de baza sa nu fie vizibil in clasa derivata, se foloseste new.

    //aceasta declarare a lui a
    //il ascunde pe a din clasa A
    new int a;

    Chiar daca variabila membru i din B ascunde i din A, folosind base se permite accesul la variabila definita in clasa de baza. Este valabil si pentru metode.

    //descopera a
    //din clasa A
    base.a;

Modificatorul abstract

    In unele cazuri, este necesar crearea unei clase de baza care stabileste un sablon general comun pentru toate clasele derivate, fiecare completand detaliile caracteristice. O clasa care este definita cu abstract,  nu poate fi instantiata, poate contine metode abstract, iar o clasa derivata dintr-o clasa abstract trebuie sa o implementeze in totalitate.

    Modificatorul abstract poate fi aplicat si asupra metodelor, proprietatilor.

    //aceasta clasa
    //nu va putea fi mostenita
    abstract class M
    {
        public abstract void Metoda();
    }

Modificatorul sealed

Se foloseste in situatiile in care se doreste impiedicarea mostenirii.

    //aceasta clasa
    //nu va putea fi mostenita
    sealed class M
    { 

    }

Modificatorii sealed si abstract nu pot fi folositi impreuna pentru o clasa.
Pentru ca .Net nu permite derivarea multipla, o clasa nu poate deriva din doua clase; in loc de folosirea claselor abstracte se pot folosi interfete, care se aseamana cu clasele abstract – definesc un obiect fara a specifica implementarea concreta. O clasa pote implementa mai mult de o interfata.

    Mostenirea este un concept cheie in programarea orientata pe obiect. Alaturi de polimorfism si incapsulare.

Vezi si articolul despre interfete