C # polimorfismo

polimorfismo statico

Al momento della compilazione, le funzioni meccanismo di connessione e gli oggetti si chiama l'associazione anticipata, noto anche come binding statico. C # offre due tecniche per implementare il polimorfismo statico. Essi sono:

• sovraccarico funzione
• L'overloading degli operatori

Overloading degli operatori discuterà nella prossima sezione, si discuterà la funzione seguente sovraccarico.

sovraccarico funzione

Si può essere nello stesso intervallo per lo stesso nome di funzione ha molteplici definizioni. funzioni definite devono essere diversi tra loro può essere un elenco di parametri tipi di parametri, può essere anche un certo numero di diversi parametri. Non si può essere sovraccaricato solo dal tipo di ritorno della dichiarazione di funzione.

L'esempio seguente mostra diversi della stessa funzionedi stampa (), per la stampa di diversi tipi di dati:

using System;
namespace PolymorphismApplication
{
   classe printData
   {
      void print (int i)
      {
         Console.WriteLine ( "Stampa int: {0}", i);
      }

      void print (double f)
      {
         Console.WriteLine ( "Stampa float: {0}", f);
      }

      void print (string s)
      {
         Console.WriteLine ( "stringa di stampa: {0}", s);
      }
      static void Main (string [] args)
      {
         p = new printData printData ();
         // Richiamare stampa per stampare un p.print intero (5);
         // Richiamare stampa per stampare galleggiante p.print (500,263);
         // Richiamare stampare su p.print stringa di stampa ( "Ciao C ++");
         Console.ReadKey ();
      }
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

Stampa int: 5
galleggiante di stampa: 500,263
stringa di stampa: Ciao C ++

polimorfismo dinamico

C # consente di utilizzare la parola chiaveastratta per creare una classe astratta, implementazione di interfaccia prevede una parte della classe.Quando una classe derivata eredita dalla classe astratta di raggiungere la completa.Estratto classe contiene metodi astratti, metodi astratti possono essere implementati come una classe derivata.Le classi derivate hanno funzioni più specializzate.

Si prega di notare che i seguenti sono alcune regole per le classi astratte:

• Non è possibile creare un'istanza di una classe astratta.
• Non è possibile dichiarare un metodo astratto fuori una classe astratta.
• Inserendo davanti le parole chiave di definizione delle classisigillate, la classe può essere dichiarata come classi sigillate.Quando una classe è dichiaratachiusa, non può essere ereditata.Una classe astratta non può essere dichiarato come sigillato.

Il seguente programma mostra una classe astratta:

using System;
namespace PolymorphismApplication
{
   Forma classe astratta
   {
      pubblico zona int astratto ();
   }
   classe Rectangle: Forma
   {
      int length privato;
      width int privato;
      Rettangolo pubblico (int a = 0, int b = 0)
      {
         lunghezza = a;
         width = B;
      }
      zona int public override ()
      { 
         Console.WriteLine ( "area di classe Rectangle:");
         ritorno (larghezza * lunghezza); 
      }
   }

   classe RectangleTester
   {
      static void Main (string [] args)
      {
         Rectangle r = new Rectangle (10, 7);
         doppia a = r.area ();
         Console.WriteLine ( "Formato: {0}", a);
         Console.ReadKey ();
      }
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

Rettangolo per classe:
Area: 70

Quando una funzione è definita nei bisogni di classe da attuare in una classe derivata, è possibile utilizzaremetodi virtuali.metodo virtuale è dichiarata usando la parola chiavevirtuale.metodi virtuali possono essere attuate in modo diverso in diverse classi ereditate. Le chiamate a metodi virtuali si verifica in fase di esecuzione.

polimorfismo dinamico è realizzato attraversole classi astratte e metodi virtuali.

Il seguente programma illustra questo punto:

using System;
namespace PolymorphismApplication
{
   Forma di classe 
   {
      width int protetta, altezza;
      Forma pubblico (int a = 0, int b = 0)
      {
         width = a;
         height = B;
      }
      pubblico zona int virtuale ()
      {
         Console.WriteLine ( "zona di genitore:");
         return 0;
      }
   }
   classe Rectangle: Forma
   {
      Rettangolo pubblico (int a = 0, int b = 0): base (a, b)
      {

      }
      zona int public override ()
      {
         Console.WriteLine ( "area di classe Rectangle:");
         tornare (larghezza * altezza); 
      }
   }
   Classe Triangolo: Forma
   {
      pubblico Triangle (int a = 0, int b = 0): base (a, b)
      {
      
      }
      zona int public override ()
      {
         Console.WriteLine ( "Triangolo quartiere della classe:");
         tornare (larghezza * altezza / 2); 
      }
   }
   classe chiamante
   {
      CallArea public void (sh Forma)
      {
         int a;
         a = sh.area ();
         Console.WriteLine ( "Formato: {0}", a);
      }
   }  
   classe Tester
   {
      
      static void Main (string [] args)
      {
         Caller c = new chiamante ();
         Rectangle r = new Rectangle (10, 7);
         Triangolo t = new Triangle (10, 5);
         c.CallArea (r);
         c.CallArea (t);
         Console.ReadKey ();
      }
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

Rettangolo per classe:
Area: 70
zona Classe Triangolo:
Area: 25