Latest web development tutorials

C # Inheritance

L'ereditarietà è una programmazione orientata agli oggetti è uno dei concetti più importanti. Inheritance ci permette di definire una classe basata su un'altra classe per definire una classe, che rende la creazione e la gestione di applicazioni molto più facile. Ma anche favorevole alla riutilizzare il codice e ridurre i tempi di sviluppo.

Quando si crea una classe, i programmatori non hanno bisogno di completamente ri-scrivere nuovi dati membro e funzioni membro, avete solo bisogno di progettare una nuova classe che eredita i membri esistenti della classe può essere. Laclasse di baseesistente viene chiamata una classe, la nuova classe si chiamaclasse derivata.

Realizzazione dell'idea di ereditàappartenenza (IS-A) relazione.Ad esempio, un mammiferoappartiene (IS-a) gli animali, i cani appartenenti a (IS-A)dei mammiferi, e quindiappartengono alcane(is-a)gli animali.

Base e classi derivate

Una classe può essere derivata da più di una classe o interfaccia, il che significa che può ereditare classi base multiple o interfacce di dati e funzioni.

Creare una classe derivata in C # sintassi è la seguente: 

<Acess-specifier> class <BASE_CLASS>
{
 ...
}
classe <Derived_Class>: <BASE_CLASS>
{
 ...
}

Supponiamo, vi è una forma di classe di base, che è il rettangolo classe derivata: 

using System;
namespace InheritanceApplication
{
   Forma di classe 
   {
      setWidth public void (int w)
      {
         width = w;
      }
      setHeight public void (int h)
      {
         height = h;
      }
      protetta width int;
      Altezza protetta int;
   }

   // Classe derivata classe Rectangle: Forma
   {
      public int getArea ()
      { 
         tornare (larghezza * altezza); 
      }
   }
   
   classe RectangleTester
   {
      static void Main (string [] args)
      {
         Rettangolo Rect = new Rectangle ();

         Rect.setWidth (5);
         Rect.setHeight (7);

         // Area di stampa della Console.WriteLine oggetto ( "Superficie totale: {0}", Rect.getArea ());
         Console.ReadKey ();
      }
   }
}

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

Superficie totale: 35

Inizializzare la classe di base

classe derivata eredita variabili e metodi membro della classe di base. Pertanto, l'oggetto padre deve essere creato prima un oggetto sottoclasse è stato creato. È possibile inizializzare la classe padre nella lista di inizializzazione membro.

Il seguente programma illustra questo punto: 

using System;
namespace RectangleApplication
{
   classe Rectangle
   {
      // Variabili membro protetto lunghezza doppia;
      protetta larghezza doppia;
      Rettangolo pubblico (doppia L, doppia w)
      {
         lunghezza = l;
         width = w;
      }
      doppia getArea pubblico ()
      {
         tornare lunghezza larghezza *;
      }
      Mostra public void ()
      {
         Console.WriteLine ( "Lunghezza: {0}", di lunghezza);
         Console.WriteLine ( "width: {0}", di larghezza);
         Console.WriteLine ( "Formato: {0}", getArea ());
      }
   } // Classe Rectangle End  
   Classe tavolo: Rectangle
   {
      doppio costo privato;
      Tavolo pubblico (doppia L, doppia w): base (l, w)
      {}
      doppia GetCost pubblico ()
      {
         doppio costo;
         costo = getArea () * 70;
         tornare costo;
      }
      Mostra public void ()
      {
         base.Display ();
         Console.WriteLine ( "Costo: {0}", GetCost ());
      }
   }
   classe ExecuteRectangle
   {
      static void Main (string [] args)
      {
         Tavolo t = new tavolo (4.5, 7.5);
         t.Display ();
         Console.ReadLine ();
      }
   }
}

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

Lunghezza: 4,5
Larghezza: 7.5
Area: 33.75
Costo: 2362,5

C # ereditarietà multipla

C # non supporta l'ereditarietà multipla.Tuttavia, è possibile utilizzare l'interfaccia per ottenere l'ereditarietà multipla. Il seguente programma illustra questo punto: 

using System;
namespace InheritanceApplication
{
   Forma di classe 
   {
      setWidth public void (int w)
      {
         width = w;
      }
      setHeight public void (int h)
      {
         height = h;
      }
      protetta width int;
      Altezza protetta int;
   }

   // Classe Base PaintCOST
   interfaccia pubblica PaintCOST 
   {
      int getCost (area int);

   }
   // Classe derivata classe Rectangle: Forma, PaintCOST
   {
      public int getArea ()
      {
         tornare (larghezza * altezza);
      }
      public int getCost (int zona)
      {
         zona di ritorno * 70;
      }
   }
   classe RectangleTester
   {
      static void Main (string [] args)
      {
         Rettangolo Rect = new Rectangle ();
         int zona;
         Rect.setWidth (5);
         Rect.setHeight (7);
         Area = Rect.getArea ();
         // Area di stampa della Console.WriteLine oggetto ( "Superficie totale: {0}", Rect.getArea ());
         Console.WriteLine ( "Paint costo totale: $ {0}", Rect.getCost (area));
         Console.ReadKey ();
      }
   }
}

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

Superficie totale: 35
Vernice Costo totale: $ 2450