Sobrecarga, anulación y ocultación?

Question

¿alguien puede explicar qué es Sobrecargar, Anular y Ocultar en .Net?

Gracias

Answer 1

La sobrecarga es cuando se crea múltiples métodos, con diferentes parámetros. Por ejemplo:

 
public class Car 
{ 
    public Car() 
    { 
    // Do stuff 
    } 

    public Car(int numberOfCylinders) 
    { 
    // Do stuff 
    } 
} 

Puede ver que el constructor tiene el mismo nombre pero diferentes parámetros. Verás métodos y constructores sobrecargados en Visual Studio en Intellisense, con pequeñas flechas que suben y bajan para que puedas navegar por las firmas.

Anulación es cuando proporciona una nueva implementación a un método de una clase base. Ejemplo:

 
    public class Square 
    { 
     public double x; 

     // Constructor: 
     public Square(double x) 
     { 
     this.x = x; 
     } 

     public virtual double Area() 
     { 
     return x*x; 
     } 
    } 

    class Cube: Square 
    { 
     // Constructor: 
     public Cube(double x): base(x) 
     { 
     } 

     // Calling the Area base method: 
     public override double Area() 
     { 
     return (6*(base.Area())); 
     } 
    } 

Tenga en cuenta que en C#, no se puede override un método no virtual o estática.

Answer 2

La sobrecarga está proporcionando varios métodos con el mismo nombre y diferentes firmas:

void Foo() {...} 
void Foo(int i) {...} 

Anulación se utiliza en herencia a cambiar la aplicación por subclase:

class SomeBase { 
    public virtual void Foo() {} 
} 
class SomeOther : SomeBase { 
    public override void Foo() { 
     // different implementation, possibly calling base.Foo(); 
    } 
} 

Con lo anterior, incluso si do:

SomeBase obj = new SomeOther(); 
obj.Foo(); 

llamará al SomeOther.Foo implementación. El método llamado depende del tipo de instancia tipo, no de la variable.

Ocultación del método es todo lo contrario; que reemplaza la firma del método, pero sólo se aplica si se llama al método del tipo derivado:

class SomeBase { 
    public void Foo() {} 
} 
class SomeOther : SomeBase { 
    public new void Foo() { 
     // different implementation, possibly calling base.Foo(); 
    } 
} 

Ahora:

SomeOther obj = new SomeOther(); 
SomeBase baseObj = obj; 
obj.Foo(); // calls SomeOther.Foo 
baseObj.Foo(); // calls SomeBase.Foo 

es decir, las llamadas a métodos depende de la variable , no el ejemplo.

Answer 3

Sobrecarga es la definición de múltiples "firmas" posibles de un solo método u operador. Cada firma toma diferentes argumentos, y es esencialmente una función distinta, no diferente de si las funciones múltiples tenían diferentes nombres. Esto se usa a menudo para agrupar operaciones conceptualmente similares, como sobrecargar + para trabajar con BigInteger y con String: ambas operaciones parecen sensatas para usar + para (a menos que piense que todas las sobrecargas de + deberían definir Abelian groups - la sobrecarga String no)

Overriding es la definición de múltiples posibles implementaciones de la misma firma del método, de tal manera que la aplicación se determina por el tipo de tiempo de ejecución del argumento de orden cero (generalmente identificado por el nombre this en C#).

Ocultación es la definición de un método en un tipo derivado con una firma idéntica a la que en una de sus tipos base sin primordial.

La diferencia práctica entre anulando y ocultamiento es el siguiente:

• Si un método es anulados, la puesta en práctica de llamar se basa en el tipo de tiempo de ejecución del argumento this.
• Si un método es simplemente ocultos, la puesta en práctica de llamar se basa en la en tiempo de compilación tipo del argumento this.

Answer 4

En términos simples:

La sobrecarga es cuando se tiene mismo nombre de método con diferentes firmas. Esto puede estar en la misma clase. Por ejemplo:

int Add (int a, int b) 
{ 
    return a + b; // returns int 
} 
float Add (float a, float b) 
{ 
return a + b; // returns float 
} 

primordial es cuando se tiene el mismo nombre de método y firma en la clase derivada como en la clase base. En este escenario, decimos que la clase derivada anula el método de la clase base. El método que se ejecuta depende de qué instancia llame al método

, por ejemplo.

public class Shape 
    { 
     public virtual void Draw() { } 

    } 

    public class Square : Shape 
    { 
     public override void Draw() 
     { 
      // Code to draw square 
     } 
    } 

    public class Circle : Shape 
    { 
     public override void Draw() 
     { 
      // Code to draw circle 
     } 
    } 

ocultar o encapsulación es cuando se declara variables y métodos de una clase privada miembros, de modo que no se puede acceder por cualquier otra clase, ni siquiera las clases derivadas

por ejemplo,

private int onlyICanAccess; 

private void OnlyICanExecute() 
{ 
    // ... 
} 

Answer 5

sobrecarga es un ejemplo de morphsm poli, puede se ha pasado la sobr número, tipo de datos y la secuencia de parámetro entre dos métodos ..

primordial (diferent de virtual) significa que algunas características definidas son allí, , pero se puede dar idea más clara en el momento de

medios de ocultación inheritind ocultar las características internas y representan características esenciales, una de las características del concepto de programación orientada a objetos

Google para obtener información detaied

Answer 6

Suponiendo que usted entiende las explicaciones dadas por otros carteles, una forma de recordar la diferencia entre sobrecarga y primordial es que, cuando se utiliza más de carga ing, hay potencialmente 'cargas' de funciones con el mismo nombre .

tonto, lo sé, pero me sirve.