c# - multiple - Sobrecarga y anulación

inherits c# asp net

Question

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

Answer 1

¡en C # no hay Java como la anulación oculta , sin anulación de palabra clave en el método de anulación! ver 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 override : 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 del automóvil es opuesta para el final en Java, significa que no es definitiva , puede anular o implementar si el automóvil era abstracto

Answer 2

Anulando cuando heredamos la clase base y hacemos una clase derivada, entonces si en la clase derivada hay un método que tiene el mismo nombre que el método (mismo nombre, mismo argumento, mismo tipo de retorno) define en la clase base, entonces se llama Anulación.

class Vehicle{  
  void run()
      {
       System.out.println("Vehicle is running");
      }  
           }
class Bike2 extends Vehicle{  
   void run()
       {
        System.out.println("Bike is running safely");
       }  

public static void main(String args[]){  
Bike2 obj = new Bike2();  
obj.run();  
 }  

Salida: la bicicleta funciona con seguridad ........ Para entender la anulación con mayor claridad, visite: http://javabyroopam.blogspot.in/

Sobrecarga Simplemente dos métodos que tienen el mismo nombre pero tienen una lista de argumentos diferente se llama sobrecarga.

class Calculation{  
  void sum(int a,int b){System.out.println(a+b);}  
  void sum(int a,int b,int c){System.out.println(a+b+c);}  

  public static void main(String args[]){  
  Calculation obj=new Calculation();  
  obj.sum(10,10,10);  
   obj.sum(20,20);  

   }  
}  

salida 30,20

Answer 3

Como dijo Michael:

• Sobrecarga = Múltiples firmas de método, mismo nombre de método
• Overriding = La misma firma de método (declarada virtual), implementada en sub clases

y

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

Answer 4

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

Anulación (Polimorfismo de tiempo de ejecución) :: Funciones en la clase extendida con el mismo nombre y los mismos parámetros que en la clase base, pero con comportamientos diferentes.

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

Answer 5

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

Método que reemplaza a Vs ocultando

Sobrecarga de método

Answer 6

Otro punto para agregar

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

int Añadir (int num1, int num2) int Añadir (int num1, int num2, int num3) doble Añadir (int num1, int num2) doble Añadir (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 clase, métodos.

Puede considerarse como polimorfismo de tiempo de compilación (estático / unión temprana).

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

Anulación no puede ser posible en la misma clase. Puede anular métodos de clase, propiedades, indizadores, eventos.

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

Se puede considerar como polimorfismo de 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 de tiempo de compilación frente a polimorfismo de tiempo de ejecución

Answer 7

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

Este es solo un ejemplo que no incluye el método virtual o 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 "Wash" (Lavado) y acepta Car como un tipo.

Obtiene la entrada del auto y lava el auto.

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

Vamos a sobrecargar la función Wash ()

Sobrecarga:

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

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

• Si el objeto de entrada provisto es un automóvil, se ejecutará la operación de lavado (carro cualquiera)
• Si el objeto de entrada provisto es un Camión, entonces ejecutará Lavado (Camión AnyTruck)

Vamos a anular 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 necesita ser lavado nuevamente.

• Si el auto está limpio, solo encerenlo.

• Si no está limpio, primero lavar el automóvil, luego secarlo y luego encerarlo

.

Entonces la funcionalidad ha sido anulada al agregar una nueva funcionalidad o hacer algo totalmente diferente.

Answer 8

Tener más de un método / constructor con el mismo nombre pero diferentes parámetros se denomina 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

Anulación es un evento de tiempo de ejecución, lo que significa que, en función de 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 instanciamos un Ferrari, obtenemos un resultado diferente.

O / p:

Top speed for this car is: 400

Answer 9

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

Answer 10

sobrecarga es el concepto en el cual usted tiene las mismas firmas o métodos con el mismo nombre pero con diferentes parámetros y anulación, tenemos los mismos métodos de nombre con diferentes parámetros, también se conoce que la herencia tiene precedencia.

Answer 11

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

Answer 12

Sobrecarga

La sobrecarga es cuando tiene múltiples métodos en el mismo ámbito, con el mismo nombre pero firmas diferentes.

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

Primordial

Anulación es un principio que le permite cambiar la funcionalidad de un método en una clase infantil.

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

Answer 13

• Sobrecarga = Múltiples firmas de método, mismo nombre de método
• Overriding = La misma firma de método (declarada virtual), implementada en sub clases

Un entrevistador astuto habría seguido con:

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