Polimorfismo ed Ereditarietà nelle Classi in C#

Facciamo brevemente un riassunto su quello che abbiamo visto finora sulle classi in C#.

• Possono avere un costruttore ed un distruttore.
• Possono ereditare proprietà e metodi nelle sottoclassi.
• Le proprietà ed i metodi possono essere public se visibili anche all’esterno della classe e delle sue derivate, protected se visibili solo all’interno delle classi derivate e private invisibili al di fuori della classe stessa.

Nella lezione precedente avevamo fatto un esempio sulla classe CPersona e la sua derivata CStudente che è una persona specializzata con la proprietà matricola in più. Avevamo anche visto che quando richiamavamo il metodo Stampa veniva richiamato quello della classe base in assenza di un metodo nella classe chiamante. Il polimorfismo è la capacità di avere molte forme e lo studente è una persona particolare, quindi la classe persona è polimorfica. Per interpretare meglio il polimorfismo una classe base deve implementare il metodo come virtual in modo tale che se una classe derivata lo vuole implementare personalizzandolo lo segni come override. Per comprendere meglio questo aspetto vediamo questo esempio; un quadrato con la classe derivata cubo che ha il suo elemento base nel quadrato appunto e quindi la posso ereditare da questo.

using System;
public class CQuadrato
{
   protected int m_iLato;
   public CQuadrato() // costruttore base
   {
        m_iLato = 0;
   }

   public CQuadrato(int iLato) // costruttore con il lato
   {
        m_iLato = iLato;
   }

   public CQuadrato(CQuadrato qI) // costruttore di copia
   {
       qI.GetLato();
   }

   public int GetLato()
   {
      return m_iLato;
   }

   public void SetLato(int iLato)
   {
       m_iLato = iLato;
   }

   public virtual int GetPerimetro()
   {
        return m_iLato * 4;
   }

   public virtual int GetArea()
   {
       return m_iLato * m_iLato;
   }
}

public class CCubo : CQuadrato
{
   public CCubo()
   {
        m_iLato = 0;
   }

   public CCubo(int iLato)
   {
        m_iLato = iLato;
    }

    public CCubo(CQuadrato qI)
    {
        m_iLato = qI.GetLato();
    }

    public CCubo(CCubo cI)
   {
        m_iLato = cI.GetLato();
   }

   public override int GetArea()
   {
         return base.GetArea() * 6;
   }

   public virtual int GetVolume()
   {
       return m_iLato * m_iLato * m_iLato;
   }
}

public class Corso
{
     static void Main(string[] args)
     {
          CQuadrato qI = new CQuadrato(12);
          Console.WriteLine("Il lato del quadrato è:"
               + qI.GetLato());
          Console.WriteLine("Il perimetro del quadrato è:"
               + qI.GetPerimetro());
          Console.WriteLine("L'area del quadrato è:"
               + qI.GetArea());
          CCubo cI = new CCubo(qI);
          Console.WriteLine("L'area del cubo è: "
               + cI.GetArea());

      Console.WriteLine("Il volume del cubo è: "
               + cI.GetVolume());

      Console.ReadKey();
    }
}

Da notare la serie di costruttori e soprattutto il costruttore di copia, che da un oggetto ne prende i dati e si costruisce come copia. Le funzioni GetArea e GetPerimetro sono implementate come virtual perché se una classe derivata vuole implementarle deve definirle come override, cosa che succede con GetArea della classe Cubo. Ultima cosa da notare la parola base che serve per accedere alle proprietà ed hai metodi della classe base ( ovviamente metodi e proprietà public o protected ), mentre this serve per accedere ai propri membri e metodi. Come sempre vi ricordo che sono a disposizione per eventuali domande.

<< Lezione Precedente – Inizio Corso – Indice Lezioni – Lezione Successiva >>