Surcharger, dérouter et cacher?

Question

quelqu'un peut-il expliquer ce qui surcharge, se surpasser et se cacher dans .Net?

Merci

Answer 1

est Surcharge lorsque vous créez plusieurs méthodes, avec des paramètres différents. Par exemple:

 
public class Car 
{ 
    public Car() 
    { 
    // Do stuff 
    } 

    public Car(int numberOfCylinders) 
    { 
    // Do stuff 
    } 
} 

Vous pouvez voir le constructeur a le même nom, mais différents paramètres. Vous verrez des méthodes et des constructeurs surchargés dans Visual Studio dans Intellisense, avec de petites flèches montantes et descendantes pour que vous puissiez parcourir les signatures.

La substitution survient lorsque vous fournissez une nouvelle implémentation à une méthode à partir d'une classe de base. Exemple:

 
    public class Square 
    { 
     public double x; 

     // Constructor: 
     public Square(double x) 
     { 
     this.x = x; 
     } 

     public virtual double Area() 
     { 
     return x*x; 
     } 
    } 

    class Cube: Square 
    { 
     // Constructor: 
     public Cube(double x): base(x) 
     { 
     } 

     // Calling the Area base method: 
     public override double Area() 
     { 
     return (6*(base.Area())); 
     } 
    } 

Notez que dans C#, vous ne pouvez pas override une méthode non virtuelle ou statique.

Answer 2

Surcharge fournit des méthodes multiples avec le même nom et signatures différentes:

void Foo() {...} 
void Foo(int i) {...} 

Redéfinition est utilisé dans l'héritage de changer la mise en œuvre par la sous-classe:

class SomeBase { 
    public virtual void Foo() {} 
} 
class SomeOther : SomeBase { 
    public override void Foo() { 
     // different implementation, possibly calling base.Foo(); 
    } 
} 

Avec ce qui précède, même si je faire:

SomeBase obj = new SomeOther(); 
obj.Foo(); 

il appellera le SomeOther.Foo mise en œuvre. La méthode appelée dépend du type , pas de la variable.

Le masquage de méthode est le contraire; il remplace la signature de méthode, mais applique uniquement si vous appelez la méthode du type dérivé:

class SomeBase { 
    public void Foo() {} 
} 
class SomeOther : SomeBase { 
    public new void Foo() { 
     // different implementation, possibly calling base.Foo(); 
    } 
} 

maintenant:

SomeOther obj = new SomeOther(); 
SomeBase baseObj = obj; 
obj.Foo(); // calls SomeOther.Foo 
baseObj.Foo(); // calls SomeBase.Foo 

-à-dire les appels de méthode dépend de la variable , pas exemple.

Answer 3

La surcharge est la définition de plusieurs "signatures" possibles d'un seul procédé ou opérateur. Chaque signature prend des arguments différents, et est essentiellement une fonction distincte, pas différente que si les multiples fonctions avaient des noms différents. Ceci est souvent utilisé pour regrouper des opérations conceptuellement similaires, telles que la surcharge + pour fonctionner avec BigInteger et avec String: les deux opérations semblent judicieuses d'utiliser + pour (sauf si vous pensez que toutes les surcharges de + doivent définir Abelian groups - la surcharge String ne).

Redéfinition est la définition de plusieurs possibles implémentations de la même signature de méthode, telle que la mise en œuvre est déterminée par le type d'exécution de l'argument zeroth (généralement identifié par le nom this en C#).

Masquage est la définition d'un procédé dans un type dérivé d'une signature identique à celle de l'un de ses types de base sans dominante.

La différence pratique entre majeur et dissimulation est la suivante:

• Si une méthode est surchargée , la mise en œuvre d'appel est basé sur le type d'exécution de l'argument this.
• Si une méthode est tout simplement caché, la mise en œuvre d'appeler est basé sur la compilation type de l'argument this.

Answer 4

En termes simples:

est quand vous Surcharge avez même nom de méthode avec des signatures différentes. Cela peut être dans la même classe. Par exemple:

int Add (int a, int b) 
{ 
    return a + b; // returns int 
} 
float Add (float a, float b) 
{ 
return a + b; // returns float 
} 

La substitution est lorsque vous avez le même nom de méthode et la même signature dans la classe dérivée que dans la classe de base. Dans ce scénario, nous disons que la classe dérivée remplace la méthode de la classe de base. La méthode qui fonctionne dépend de l'instance qui appelle la méthode

par ex.

public class Shape 
    { 
     public virtual void Draw() { } 

    } 

    public class Square : Shape 
    { 
     public override void Draw() 
     { 
      // Code to draw square 
     } 
    } 

    public class Circle : Shape 
    { 
     public override void Draw() 
     { 
      // Code to draw circle 
     } 
    } 

Masquage ou encapsulation est lorsque vous déclarez les variables membres et méthodes d'une classe privée afin qu'ils ne peuvent pas être accessibles par toute autre classe, pas même les classes dérivées

PAR EXEMPLE

private int onlyICanAccess; 

private void OnlyICanExecute() 
{ 
    // ... 
} 

Answer 5

Surcharge est un exemple de poly morphsm, vous pouvez overloa nombre, le type de données et la séquence des paramètres a été passé entre deux méthodes ..

dominante (diferent du virtuel) signifie certaines fonctionnalités définies sont là, , mais vous pouvez donner idée plus claire au moment de inheritind

moyens Hiding cacher les caractéristiques internes et représentent les caractéristiques essentielles, l'une des caractéristiques du concept de POO

GooGle pour obtenir des informations detaied

Answer 6

En supposant que vous comprenez les explications données par d'autres affiches, une façon de se rappeler la différence entre la surcharge et dominante est que, lors de l'utilisation sur charge ment, il y a potentiellement « charges » des fonctions avec le même nom .

Silly, je sais, mais ça marche pour moi.