Latest web development tutorials

C # Inheritance

L'héritage est une programmation orientée objet est l'un des concepts les plus importants. L'héritage permet de définir une classe basée sur une autre classe pour définir une classe, ce qui permet de créer et de maintenir des applications beaucoup plus facile. Mais aussi propice à la réutilisation du code et de réduire le temps de développement.

Lorsque vous créez une classe, les programmeurs ne doivent pas complètement ré-écrire de nouveaux membres de données et les fonctions membres, il vous suffit de concevoir une nouvelle classe qui hérite des membres existants de la classe peuvent être. Laclasse de base existante est appelée une classe, la nouvelle classe est appelée la classe dérivée.

Réalisation de l'idée de l' héritageappartenant (IS-A) relation.Par exemple, un mammifèreappartient (IS-A) animaux, les chiens appartenant à (IS-A)des mammifères, et doncappartenir auchien(IS-A)animaux.

Base et classes dérivées

Une classe peut être dérivé de plus d'une classe ou interface, ce qui signifie qu'il peut hériter de plusieurs classes de base ou d'interfaces de données et de fonctions.

Créer une classe dérivée dans la syntaxe C # est la suivante: 

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

Supposons, il y a une forme de classe de base, qui est le Rectangle de classe dérivée: 

using System;
namespace InheritanceApplication
{
   Forme de classe 
   {
      setLargeur public void (int w)
      {
         width = w;
      }
      setHeight public void (int h)
      {
         height = h;
      }
      largeur de protection int;
      protégé int hauteur;
   }

   // Classe de classe dérivée Rectangle: Forme
   {
      public int getArea ()
      { 
         retour (largeur * hauteur); 
      }
   }
   
   classe RectangleTester
   {
      static void Main (string [] args)
      {
         Rectangle Rect = new Rectangle ();

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

         // Zone d'impression de l'Console.WriteLine d'objet ( "Surface totale: {0}", Rect.getArea ());
         Console.ReadKey ();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants: 

Superficie totale: 35

Initialisation de la classe de base

classe dérivée hérite des variables membres et des méthodes de membres de la classe de base. Par conséquent, l'objet parent doit être créé avant un objet sous-classe a été créée. Vous pouvez initialiser la classe parent dans la liste membre d'initialisation.

Le programme suivant illustre ce point: 

using System;
namespace RectangleApplication
{
   classe Rectangle
   {
      // Les variables membres protégées longueur double;
      protégée à double largeur;
      Rectangle publique (double l, double w)
      {
         longueur = l;
         width = w;
      }
      à double getArea publique ()
      {
         retour longueur * largeur;
      }
      Affichage public void ()
      {
         Console.WriteLine ( "Longueur: {0}", longueur);
         Console.WriteLine ( "width: {0}", largeur);
         Console.WriteLine ( "Taille: {0}", getArea ());
      }
   } // Fin Rectangle de classe  
   classe Tabletop: Rectangle
   {
      coût à double privé;
      Tabletop publique (double l, double w): base (l, p)
      {}
      à double GetCost publique ()
      {
         coût double,
         coût = getArea () * 70;
         retour coûts;
      }
      Affichage public void ()
      {
         base.Display ();
         Console.WriteLine ( "Coût: {0}", GetCost ());
      }
   }
   classe ExecuteRectangle
   {
      static void Main (string [] args)
      {
         Tabletop t = new Tabletop (4.5, 7.5);
         t.Display ();
         Console.ReadLine ();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants: 

Longueur: 4.5
Largeur: 7.5
Superficie: 33,75
Coût: 2362,5

C # héritage multiple

C # ne prend pasenchargel'héritage multiple.Cependant, vous pouvez utiliser l'interface pour obtenir l'héritage multiple. Le programme suivant illustre ce point: 

using System;
namespace InheritanceApplication
{
   Forme de classe 
   {
      setLargeur public void (int w)
      {
         width = w;
      }
      setHeight public void (int h)
      {
         height = h;
      }
      largeur de protection int;
      protégé int hauteur;
   }

   // PaintCOST de classe de base
   interface publique PaintCOST 
   {
      int getCost (zone int);

   }
   // Classe de classe dérivée Rectangle: Forme, PaintCOST
   {
      public int getArea ()
      {
         retour (largeur * hauteur);
      }
      public int getCost (int zone)
      {
         zone de retour * 70;
      }
   }
   classe RectangleTester
   {
      static void Main (string [] args)
      {
         Rectangle Rect = new Rectangle ();
         zone int;
         Rect.setWidth (5);
         Rect.setHeight (7);
         zone = Rect.getArea ();
         // Zone d'impression de l'Console.WriteLine d'objet ( "Surface totale: {0}", Rect.getArea ());
         Console.WriteLine ( "Peinture coût total: $ {0}", Rect.getCost (région));
         Console.ReadKey ();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants: 

Superficie totale: 35
Peinture Coût total: $ 2450