Surcharge et dépassement

Quelle est la différence entre une surcharge et un dépassement.

Surcharge

La surcharge se produit lorsque vous avez plusieurs méthodes dans la même portée, avec le même nom mais des signatures différentes.

//Overloading
public class test
{
    public void getStuff(int id)
    {}
    public void getStuff(string name)
    {}
}

Primordial

Le remplacement est un principe qui vous permet de modifier la fonctionnalité d'une méthode dans une classe enfant.

//Overriding
public class test
{
        public virtual void getStuff(int id)
        {
            //Get stuff default location
        }
}

public class test2 : test
{
        public override void getStuff(int id)
        {
            //base.getStuff(id);
            //or - Get stuff new location
        }
}

Définitions simples pour la surcharge et le remplacement

Overloading (Compile Time Polymorphism) :: Fonctions avec le même nom et des paramètres différents

public class A
{
    public void print(int x, int y)
    {
        Console.WriteLine("Parent Method");
    }
}

public class B : A
{
    public void child()
    {
        Console.WriteLine("Child Method");
    }

    public void print(float x, float y)
    {
        Console.WriteLine("Overload child method");
    }
}

Overriding (Run Time Polymorphism) :: Fonctions dans la classe étendue avec le même nom et les mêmes paramètres que dans la classe de base, mais avec des comportements différents.

public class A
{
    public virtual void print()
    {
        Console.WriteLine("Parent Method");
    }
}

public class B : A
{
    public void child()
    {
        Console.WriteLine("Child Method");
    }

    public override void print()
    {
        Console.WriteLine("Overriding child method");
    }
}

Je veux partager un exemple qui a eu beaucoup de sens pour moi lorsque j'apprenais:

Ceci est juste un exemple qui n'inclut pas la méthode virtuelle ou la classe de base. Juste pour donner une idée de l'idée principale.

Disons qu'il y a une machine à laver de véhicule et qu'elle a une fonction appelée «lavage» et accepte la voiture comme type.

Obtient l'entrée de la voiture et lave la voiture.

public void Wash(Car anyCar){
       //wash the car
}

Surchargeons la fonction Wash ()

Surcharge:

public void Wash(Truck anyTruck){
   //wash the Truck  
}

La fonction de lavage ne lavait qu'une voiture auparavant, mais elle est maintenant surchargée pour laver un camion également.

• Si l'objet d'entrée fourni est une voiture, il exécutera Wash (Car anyCar)
• Si l'objet d'entrée fourni est un camion, il exécutera Wash (Truck anyTruck)

Remplaçons la fonction Wash ()

Primordial:

public override void Wash(Car anyCar){
   //check if the car has already cleaned
   if(anyCar.Clean){ 
       //wax the car
   }
   else{
       //wash the car
       //dry the car
       //wax the car
   }     
}

La fonction de lavage a maintenant une condition pour vérifier si la voiture est déjà propre et n'a pas besoin d'être lavée à nouveau.

• Si la voiture est propre, cirez-la simplement.

• Si ce n'est pas propre, lavez d'abord la voiture, puis séchez-la puis cirez-la

.

Ainsi, la fonctionnalité a été remplacée en ajoutant une nouvelle fonctionnalité ou en faisant quelque chose de totalement différent.

• Surcharge = plusieurs signatures de méthode, même nom de méthode
• Overriding = Même signature de méthode (déclarée virtuelle), implémentée dans les sous-classes

Un intervieweur astucieux aurait suivi avec:

Quelle est la différence entre le remplacement et l'observation?

Comme Michael l'a dit:

• Surcharge = plusieurs signatures de méthode, même nom de méthode
• Overriding = Même signature de méthode (déclarée virtuelle), implémentée dans les sous-classes

et

• Shadowing = Si traité comme DerivedClass, il utilise une méthode dérivée, si comme BaseClass, il utilise la méthode de base.

Avoir plus d'une méthode / constructeur avec le même nom mais des paramètres différents est appelé surcharge. Il s'agit d'un événement de compilation.

Class Addition 
{
   int add(int a, int b) 
   {
     return a+b;
   }
   int add(int a, int b, int c)
   {
     return a+b+c;
   }

   public static main (String[] args) 
   {
     Addition addNum = new Addition();
     System.out.println(addNum.add(1,2));
     System.out.println(addNum.add(1,2,3));
   }
}

O / p:

3
6

Le remplacement est un événement d'exécution, ce qui signifie qu'en fonction de votre code, la sortie change au moment de l'exécution.

class Car
{
    public int topSpeed() 
    {
        return 200;
    }
}
class Ferrari extends Car
{
    public int topSpeed()
    {
        return 400;
    }
    public static void main(String args[])
    {
        Car car = new Ferrari();
        int num= car.topSpeed();
        System.out.println("Top speed for this car is: "+num);
    }
}

Notez qu'il existe une méthode commune dans les deux classes topSpeed ​​(). Depuis que nous avons instancié une Ferrari, nous obtenons un résultat différent.

O / p:

Top speed for this car is: 400

en C #, il n'y a pas de remplacement caché comme Java , sans remplacement de mot clé sur la méthode de remplacement ! voir ces implémentations C #:

variante 1 sans remplacement : le résultat est 200

    class Car {
        public int topSpeed() {
            return 200;
        }
    }

    class Ferrari : Car {
        public int topSpeed(){
                return 400;
        }
    }

    static void Main(string[] args){
        Car car = new Ferrari();
        int num= car.topSpeed();
        Console.WriteLine("Top speed for this car is: "+num);
        Console.ReadLine();
    }

variante 2 avec mot-clé override : le résultat est 400

    class Car {
        public virtual int topSpeed() {
            return 200;
        }
    }

    class Ferrari : Car {
        public override int topSpeed(){
                return 400;
        }
    }

    static void Main(string[] args){
        Car car = new Ferrari();
        int num= car.topSpeed();
        Console.WriteLine("Top speed for this car is: "+num);
        Console.ReadLine();
    }

Le mot-clé virtuel sur la classe de voiture est opposé pour final sur Java, signifie non final , vous pouvez remplacer ou implémenter si Car était abstrait

shadowing = maintient deux définitions au niveau de la classe dérivée et afin de projeter la définition de la classe de base, il occulte (masque) la définition de la classe dérivée et vice versa.

Un autre point à ajouter.

Surcharge plus d'une méthode avec le même nom. Type de retour identique ou différent. Différents pas de paramètres ou différents types de paramètres. Dans la même classe ou classe dérivée.

int Add (int num1, int num2) int Add (int num1, int num2, int num3) double Add (int num1, int num2) double Add (double num1, double num2)

Peut être possible dans la même classe ou classe dérivée. Préfère généralement dans la même classe. Par exemple, Console.WriteLine () a 19 méthodes surchargées.

Peut surcharger les constructeurs de classes, les méthodes.

Peut être considéré comme un polymorphisme au moment de la compilation (statique / liaison précoce).

=================================================== =================================================== =

Primordial ne peut pas être possible dans la même classe. Peut remplacer les méthodes de classe, les propriétés, les indexeurs et les événements.

Possède des limitations telles que La méthode de base remplacée doit être virtuelle, abstraite ou remplacée. Vous ne pouvez pas utiliser les modificateurs new, static ou virtual pour modifier une méthode de remplacement.

Peut être considéré comme un polymorphisme d'exécution (liaison dynamique / tardive).

Aide à la gestion des versions http://msdn.microsoft.com/en-us/library/6fawty39.aspx

=================================================== =================================================== =

Liens utiles

http://msdn.microsoft.com/en-us/library/ms173152.aspx Polymorphisme à la compilation vs polymorphisme à l'exécution

La surcharge fait partie du polymorphisme statique et est utilisée pour implémenter différentes méthodes avec le même nom mais des signatures différentes. Le remplacement est utilisé pour terminer la méthode incomplète. À mon avis, il n'y a pas de comparaison entre ces deux concepts, la seule chose est similaire, c'est que les deux viennent avec le même vocabulaire qui est fini.

La surcharge de méthode et le remplacement de méthode sont deux concepts complètement différents. La surcharge de méthode porte le même nom de méthode mais avec des signatures différentes. Le remplacement de méthode modifie l'implémentation par défaut de la méthode de classe de base dans la classe dérivée. Vous trouverez ci-dessous 2 excellents didacticiels vidéo expliquant ces concepts.

Méthode remplaçant Vs masquage

Surcharge de méthode

La surcharge est le concept dans lequel vous avez les mêmes signatures ou méthodes avec le même nom mais des paramètres différents et la substitution, nous avons le même nom, les méthodes avec des paramètres différents ont également l'héritage est connu comme le remplacement.