Sobrecarga y anulación

¿Cuál es la diferencia entre sobrecargar y anular?

Sobrecarga

La sobrecarga es cuando tiene varios métodos en el mismo alcance, con el mismo nombre pero con diferentes firmas.

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

Primordial

La invalidación es un principio que le permite cambiar la funcionalidad de un método en una clase secundaria.

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

Definiciones simples para sobrecargar y anular

Sobrecarga (polimorfismo de tiempo de compilación) :: Funciones con el mismo nombre y diferentes parámetros

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) :: Funciones en la clase extendida con el mismo nombre y los mismos parámetros que en la clase base, pero con diferentes comportamientos.

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

Quiero compartir un ejemplo que tuvo mucho sentido para mí cuando estaba aprendiendo:

Este es solo un ejemplo que no incluye el método virtual ni la clase base. Solo para dar una pista sobre la idea principal.

Digamos que hay una lavadora de vehículos y tiene una función llamada "Lavar" y acepta Coche como un tipo.

Obtiene la entrada del coche y lava el coche.

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

Sobrecarguemos la función Wash ()

Sobrecarga:

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

La función de lavado solo lavaba un automóvil antes, pero ahora también está sobrecargada para lavar un camión.

• Si el objeto de entrada proporcionado es un automóvil, ejecutará Wash (Car anyCar)
• Si el objeto de entrada proporcionado es un camión, ejecutará Wash (Truck anyTruck)

Anulemos la función 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 función de lavado ahora tiene una condición para verificar si el automóvil ya está limpio y no es necesario lavarlo nuevamente.

• Si el automóvil está limpio, simplemente encerelo.

• Si no está limpio, primero lave el automóvil, luego séquelo y luego encerelo

.

Entonces, la funcionalidad se ha anulado al agregar una nueva funcionalidad o hacer algo totalmente diferente.

• Sobrecarga = múltiples firmas de métodos, mismo nombre de método
• Anulación = Firma del mismo método (declarado virtual), implementado en subclases

Un entrevistador astuto habría seguido con:

¿Cuál es la diferencia entre anular y sombrear?

Como dijo Michael:

• Sobrecarga = múltiples firmas de métodos, mismo nombre de método
• Anulación = Firma del mismo método (declarado virtual), implementado en subclases

y

• Sombreado = Si se trata como DerivedClass, usó el método derivado, si como BaseClass usa el método base.

Tener más de un método / constructor con el mismo nombre pero diferentes parámetros se llama sobrecarga. Este es un evento de tiempo de compilación.

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

La anulación es un evento en tiempo de ejecución, lo que significa que, según su código, la salida cambia en tiempo de ejecución.

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

Observe que hay un método común en ambas clases topSpeed ​​(). Desde que creamos una instancia de Ferrari, obtenemos un resultado diferente.

O / p:

Top speed for this car is: 400

en C # no hay Java como anulación oculta , sin anulación de palabras clave en el método de anulación. vea estas implementaciones de C #:

variante 1 sin anulación : el resultado es 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 palabra clave de anulación : el resultado es 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 palabra clave virtual en la clase Car es opuesta a final en Java, significa que no es final , puede anular o implementar si Car era abstracto

shadowing = mantiene dos definiciones en la clase derivada y, para proyectar la definición de la clase base, sombrea (oculta) la definición de la clase derivada y viceversa.

Otro punto para agregar.

Sobrecarga de más de un método con el mismo nombre. Mismo tipo de devolución o diferente. Diferente número de parámetros o Diferente tipo de parámetros. En la misma clase o clase derivada.

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

Puede ser posible en la misma clase o clase derivada. Generalmente prefiere en la misma clase. Por ejemplo, Console.WriteLine () tiene 19 métodos sobrecargados.

Puede sobrecargar constructores de clases, métodos.

Se puede considerar como polimorfismo en tiempo de compilación (estático / enlace temprano).

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

No es posible anular en la misma clase. Puede anular métodos de clase, propiedades, indexadores, eventos.

Tiene algunas limitaciones, como El método base anulado debe ser virtual, abstracto o anulado. No puede utilizar los modificadores nuevos, estáticos o virtuales para modificar un método de anulación.

Se puede considerar como polimorfismo en tiempo de ejecución (enlace dinámico / tardío).

Ayuda en el control de versiones http://msdn.microsoft.com/en-us/library/6fawty39.aspx

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

Enlaces Útiles

http://msdn.microsoft.com/en-us/library/ms173152.aspx Polimorfismo en tiempo de compilación frente a polimorfismo en tiempo de ejecución

La sobrecarga es parte del polimorfismo estático y se usa para implementar diferentes métodos con el mismo nombre pero con diferentes firmas. La anulación se utiliza para completar el método incompleto. En mi opinión no hay comparación entre estos dos conceptos, lo único que es similar es que ambos vienen con el mismo vocabulario que se acabó.

La sobrecarga de métodos y la anulación de métodos son dos conceptos diferentes completamente diferentes. La sobrecarga de métodos tiene el mismo nombre de método pero con diferentes firmas. La invalidación del método es cambiar la implementación predeterminada del método de la clase base en la clase derivada. A continuación puede encontrar 2 excelentes tutoriales en video que explican estos conceptos.

Método que anula Vs ocultar

Sobrecarga de métodos

La sobrecarga es el concepto en el que tiene las mismas firmas o métodos con el mismo nombre pero diferentes parámetros y anulación, tenemos métodos con el mismo nombre con diferentes parámetros y también tenemos herencia que se conoce como anulación.