Sobrecarregando e substituindo

Qual é a diferença entre sobrecarregar e substituir.

Sobrecarregando

Sobrecarga é quando você tem vários métodos no mesmo escopo, com o mesmo nome, mas assinaturas diferentes.

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

Substituindo

Substituir é um princípio que permite alterar a funcionalidade de um método em uma classe filha.

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

Definições simples para sobrecarregar e substituir

Sobrecarga (polimorfismo do tempo de compilação) :: Funções com o mesmo nome e parâmetros diferentes

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) :: Funções na classe estendida com o mesmo nome e os mesmos parâmetros da classe base, mas com comportamentos 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");
    }
}

Quero compartilhar um exemplo que fez muito sentido para mim quando estava aprendendo:

Este é apenas um exemplo que não inclui o método virtual ou a classe base. Só para dar uma dica sobre a ideia principal.

Digamos que exista uma máquina de lavar Veículo com uma função chamada "Lavar" e aceita Carro como tipo.

Recebe a entrada do carro e lava o carro.

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

Vamos sobrecarregar a função Wash ()

Sobrecarregando:

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

A função de lavagem era apenas lavar um carro antes, mas agora está sobrecarregada para lavar um caminhão também.

• Se o objeto de entrada fornecido for um carro, ele executará Wash (Car anyCar)
• Se o objeto de entrada fornecido for um Caminhão, ele executará Lavar (Caminhão AnyTruck)

Vamos substituir a função Wash ()

Substituindo:

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

A função de lavagem agora tem uma condição para verificar se o Carro já está limpo e não precisa ser lavado novamente.

• Se o carro estiver limpo, basta encerá-lo.

• Se não estiver limpo, primeiro lave o carro, seque-o e encere-o

.

Portanto, a funcionalidade foi substituída pela adição de uma nova funcionalidade ou por algo totalmente diferente.

• Sobrecarga = várias assinaturas de método, mesmo nome de método
• Substituindo = Assinatura do mesmo método (declarado virtual), implementado em subclasses

Um entrevistador astuto teria seguido com:

Qual é a diferença entre substituir e sombreamento?

Como Michael disse:

• Sobrecarga = várias assinaturas de método, mesmo nome de método
• Substituindo = Assinatura do mesmo método (declarado virtual), implementado em subclasses

e

• Shadowing = Se tratado como DerivedClass, usa o método derivado, se como BaseClass usa o método base.

Ter mais de um método / construtor com o mesmo nome, mas parâmetros diferentes, é chamado de sobrecarga. Este é um evento em tempo de compilação.

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

A substituição é um evento de tempo de execução, o que significa que, com base em seu código, a saída muda em tempo de execução.

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 há um método comum em ambas as classes topSpeed ​​(). Como instanciamos uma Ferrari, obtemos um resultado diferente.

O / p:

Top speed for this car is: 400

em C # não há Java como substituição oculta , sem substituição de palavra-chave no método de substituição! veja estas implementações C #:

variante 1 sem substituição : o resultado é 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 com palavra-chave de substituição : o resultado é 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();
    }

a palavra-chave virtual na classe Car é oposta a final no Java, significa não final , você pode substituir ou implementar se Car fosse abstrato

shadowing = mantém duas definições na classe derivada e, para projetar a definição da classe base, ela obscurece (oculta) a definição da classe derivada e vice-versa.

Outro ponto a acrescentar.

Sobrecarregando mais de um método com o mesmo nome. Tipo de retorno igual ou diferente. Número diferente de parâmetros ou Tipo diferente de parâmetros. Na mesma classe ou classe derivada.

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)

Pode ser possível na mesma classe ou classe derivada. Geralmente prefere na mesma classe. Por exemplo, Console.WriteLine () tem 19 métodos sobrecarregados.

Pode sobrecarregar construtores de classe, métodos.

Pode ser considerado como polimorfismo de tempo de compilação (vinculação estática / precoce).

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

A substituição não pode ser possível na mesma classe. Pode substituir métodos de classe, propriedades, indexadores, eventos.

Tem algumas limitações, como O método de base substituído deve ser virtual, abstrato ou substituir. Você não pode usar os modificadores novos, estáticos ou virtuais para modificar um método de substituição.

Pode ser considerado como polimorfismo de tempo de execução (ligação dinâmica / tardia).

Ajuda no controle de versão http://msdn.microsoft.com/en-us/library/6fawty39.aspx

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

Links úteis

http://msdn.microsoft.com/en-us/library/ms173152.aspx Polimorfismo de tempo de compilação vs. polimorfismo de tempo de execução

A sobrecarga é uma parte do polimorfismo estático e é usada para implementar métodos diferentes com o mesmo nome, mas assinaturas diferentes. A substituição é usada para completar o método incompleto. Na minha opinião não existe comparação entre esses dois conceitos, a única coisa semelhante é que ambos vêm com o mesmo vocabulário que acabou.

A sobrecarga de método e a substituição de método são 2 conceitos diferentes, completamente diferentes. A sobrecarga de método é ter o mesmo nome de método, mas com assinaturas diferentes. A substituição de método está mudando a implementação padrão do método da classe base na classe derivada. Abaixo você pode encontrar 2 excelentes tutoriais em vídeo explicando esses conceitos.

Método substituindo Vs ocultando

Sobrecarga de método

Sobrecarga é o conceito em que você tem as mesmas assinaturas ou métodos com o mesmo nome, mas com parâmetros e sobrescritos diferentes, temos o mesmo nome, métodos com parâmetros diferentes também têm herança, é conhecido como sobrescrever.