Sovraccarico e override

Qual è la differenza tra overload e overriding.

Sovraccarico

Il sovraccarico si verifica quando si hanno più metodi nello stesso ambito, con lo stesso nome ma firme diverse.

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

Override

L'override è un principio che consente di modificare la funzionalità di un metodo in una classe figlia.

//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
        }
}

Definizioni semplici per sovraccarico e sovrascrittura

Overloading (Compile Time Polymorphism) :: Funzioni con lo stesso nome e parametri differenti

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) :: Funzioni nella classe estesa con lo stesso nome e gli stessi parametri della classe base, ma con comportamenti diversi.

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");
    }
}

Voglio condividere un esempio che aveva molto senso per me quando stavo imparando:

Questo è solo un esempio che non include il metodo virtuale o la classe base. Solo per dare un suggerimento riguardo all'idea principale.

Diciamo che c'è una lavatrice per veicoli e ha una funzione chiamata "Wash" e accetta come tipo Auto.

Ottiene l'input Auto e lava l'auto.

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

Eseguiamo l'overload della funzione Wash ()

Sovraccarico:

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

La funzione di lavaggio prima lavava solo un'auto, ma ora è sovraccarica anche per lavare un camion.

• Se l'oggetto di input fornito è un'auto, eseguirà Wash (Car anyCar)
• Se l'oggetto di input fornito è un Truck, eseguirà Wash (Truck anyTruck)

Eseguiamo l'override della funzione Wash ()

Override:

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 funzione di lavaggio ora ha una condizione per verificare se l'auto è già pulita e non ha bisogno di essere lavata di nuovo.

• Se l'auto è pulita, cerala.

• Se non è pulita, lava prima l'auto, poi asciugala e poi cerala

.

Quindi la funzionalità è stata sovrascritta aggiungendo una nuova funzionalità o facendo qualcosa di completamente diverso.

• Sovraccarico = più firme di metodo, stesso nome di metodo
• Overriding = Stessa firma del metodo (dichiarata virtuale), implementata in sottoclassi

Un intervistatore astuto avrebbe seguito:

Qual è la differenza tra override e shadowing?

Come ha detto Michael:

• Sovraccarico = più firme di metodo, stesso nome di metodo
• Overriding = Stessa firma del metodo (dichiarata virtuale), implementata in sottoclassi

e

• Shadowing = Se trattato come DerivedClass utilizza il metodo derivato, se come BaseClass utilizza il metodo base.

Avere più di un metodo / costruttore con lo stesso nome ma parametri differenti è detto sovraccarico. Questo è un evento in fase di compilazione.

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));
   }
}

Operazione:

3
6

L'override è un evento di runtime, il che significa che in base al codice l'output cambia in fase di esecuzione.

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);
    }
}

Notare che esiste un metodo comune in entrambe le classi topSpeed ​​(). Da quando abbiamo istanziato una Ferrari, otteniamo un risultato diverso.

Operazione:

Top speed for this car is: 400

in C # non c'è Java come override nascosto , senza override di parole chiave sul metodo di override! vedere queste implementazioni C #:

variante 1 senza override : il risultato è 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 con override parola chiave: il risultato è 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();
    }

la parola chiave virtual su Car class è opposta a final su Java, significa non finale , puoi sovrascrivere o implementare se Car fosse astratta

shadowing = mantiene due definizioni nella classe derivata e per proiettare la definizione della classe base nasconde (nasconde) la definizione della classe derivata e viceversa.

Un altro punto da aggiungere.

Sovraccarico più metodi con lo stesso nome. Tipo di restituzione uguale o diverso. Diverso numero di parametri o diverso tipo di parametri. Nella stessa classe o classe derivata.

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)

Può essere possibile nella stessa classe o classe derivata. Preferisce generalmente nella stessa classe. Ad esempio, Console.WriteLine () ha 19 metodi sovraccaricati.

Può sovraccaricare costruttori di classi, metodi.

Può essere considerato un polimorfismo del tempo di compilazione (statico / associazione anticipata).

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

Non è possibile eseguire l' override nella stessa classe. Può eseguire l'override di metodi di classe, proprietà, indicizzatori ed eventi.

Presenta alcune limitazioni come il metodo di base sottoposto a override deve essere virtuale, astratto o override. Non è possibile utilizzare i modificatori new, static o virtual per modificare un metodo di sostituzione.

Può essere considerato come polimorfismo del tempo di esecuzione (legame dinamico / tardivo).

Aiuta nel controllo delle versioni http://msdn.microsoft.com/en-us/library/6fawty39.aspx

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

Collegamenti utili

http://msdn.microsoft.com/en-us/library/ms173152.aspx Polimorfismo in fase di compilazione e polimorfismo in fase di esecuzione

Il sovraccarico fa parte del polimorfismo statico e viene utilizzato per implementare metodi diversi con lo stesso nome ma firme diverse. L'override viene utilizzato per completare il metodo incompleto. Secondo me non c'è paragone tra questi due concetti, l'unica cosa che è simile è che entrambi arrivano con lo stesso vocabolario che è finito.

Il sovraccarico del metodo e l'override del metodo sono 2 concetti diversi completamente diversi. Il sovraccarico del metodo ha lo stesso nome di metodo ma con firme diverse. L'override del metodo sta modificando l'implementazione predefinita del metodo della classe di base nella classe derivata. Di seguito puoi trovare 2 eccellenti video tutorial che spiegano questi concetti.

Metodo che ignora Vs hiding

Sovraccarico del metodo

Il sovraccarico è il concetto in cui si hanno le stesse firme o metodi con lo stesso nome ma parametri diversi e l'override, abbiamo metodi con lo stesso nome con parametri diversi che hanno anche l'ereditarietà è noto come override.