surcharge
La surcharge survient lorsque vous avez plusieurs méthodes dans la même étendue, avec le même nom mais des signatures différentes.
//Overloading
public class test
{
public void getStuff(int id)
{}
public void getStuff(string name)
{}
}
annulation
Le remplacement est un principe qui vous permet de modifier les fonctionnalités 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 dépassement
Surcharge (Compile Time Polymorphism) :: Fonctions de même nom et de 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");
}
}
Substitution (Polymorphisme à l'exécution) :: Fonctions de 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 me paraissait logique lorsque j'apprenais:
Ceci est juste un exemple qui n'inclut pas la méthode virtuelle ou la classe de base. Juste pour donner un indice concernant l’idée principale.
Supposons qu'il existe une machine à laver le véhicule dotée d'une fonction appelée "Laver" et acceptant la voiture en tant que type.
Obtient l'entrée de la voiture et lave la voiture.
public void Wash(Car anyCar){
//wash the car
}
Surcharge la fonction Wash ()
Surcharge:
public void Wash(Truck anyTruck){
//wash the Truck
}
La fonction de lavage ne faisait que laver 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 un lavage (camion quelconque).
Remplaçons la fonction Wash ()
Substitution:
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, commencez par laver la voiture, puis séchez-la puis cirez-la
.
Donc, la fonctionnalité a été remplacée par l’ajout d’une nouvelle fonctionnalité ou par une action totalement différente.
- Surcharge = Plusieurs signatures de méthode, même nom de méthode
- Overriding = Signature de la même méthode (déclarée virtuelle), implémentée dans des sous-classes
Un interviewer astucieux aurait suivi avec:
Quelle est la différence entre le contournement et l'observation?
Comme Michael a dit:
- Surcharge = Plusieurs signatures de méthode, même nom de méthode
- Overriding = Signature de la même méthode (déclarée virtuelle), implémentée dans des sous-classes
et
- Shadowing = Si traité en tant que DerivedClass, il a utilisé une méthode dérivée, si en tant que BaseClass, il utilise une méthode de base.
Avoir plusieurs méthodes/constructeurs avec le même nom mais des paramètres différents est appelé surcharge. Ceci est 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, c’est-à-dire que, selon 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 Java comme masqué , remplacement sans le mot clé remplacement sur la méthode de remplacement ! voyez ces implémentations C #:
variante 1 sans substitution : 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 écrasement mot-clé: résultat: 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();
}
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 = conserve deux définitions au niveau de la classe dérivée et, pour projeter la définition de la classe de base, ombrage (cache) la définition de la classe dérivée et inversement.
Surcharge fait partie du polymorphisme statique et permet d'implémenter différentes méthodes portant le même nom mais des signatures différentes. Remplacement est utilisé pour compléter la méthode incomplète. À mon avis, il n'y a pas de comparaison possible entre ces deux concepts, la seule chose qui soit similaire, c'est que tous les deux ont le même vocabulaire terminé.
Un autre point à ajouter.
Surcharge Plus d'une méthode avec le même nom. Type de retour identique ou différent. Différent nombre de paramètres ou type différent de paramètres. Dans la même classe ou dans la classe dérivée.
int Ajouter (int num1, int num2) int Ajouter (int num1, int num2, int num3) double Ajouter (int num1, int num2) double Ajouter (double num1, double num2)
Peut être possible dans la même classe ou dans la 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 classe, les méthodes.
Peut être considéré comme un polymorphisme Compile Time (statique/Early Binding).
=============================================== =============================================== =
La substitution ne peut pas être possible dans la même classe. Peut remplacer les méthodes de classe, les propriétés, les indexeurs, les événements.
A certaines limitations, comme La méthode de base substituée doit être virtuelle, abstraite ou substituée. Vous ne pouvez pas utiliser les nouveaux modificateurs, statiques ou virtuels pour modifier une méthode de remplacement.
Peut être considéré comme un polymorphisme d'exécution (liaison dynamique/tardive).
Aide dans la gestion des versions http://msdn.Microsoft.com/en-us/library/6fawty39.aspx
=============================================== =============================================== =
Liens utiles
http://msdn.Microsoft.com/en-us/library/ms173152.aspxpolymorphisme du temps de compilation par rapport au polymorphisme du temps d'exécution
La surcharge est le concept dans lequel vous avez les mêmes signatures ou méthodes avec le même nom mais avec des paramètres et des substitutions différents, nous avons des méthodes du même nom avec des paramètres différents et dont l'héritage est appelé substitution.
La surcharge de méthode et le remplacement de méthode sont deux concepts différents. La surcharge de méthode consiste à avoir le même nom de méthode mais avec des signatures différentes. Le remplacement de la méthode consiste à changer l'implémentation par défaut de la méthode de la classe de base dans la classe dérivée. Vous trouverez ci-dessous deux excellents tutoriels vidéo expliquant ces concepts.