Visão geral sobre sobrecarga em c #
Em Sobrecarga em C #, o polimorfismo é um conceito de programação orientada a objetos que define a capacidade de um objeto, uma variável ou um método de assumir várias formas durante o tempo de compilação / execução. Os fatores em tempo real, como dados, parâmetros, retornam um objeto, etc. determinam de que forma o objeto / método / variável assumirá. Isso permite que o programador codifique mais genérico do que específico. Por exemplo, você come frutas. Como você come frutas depende da fruta fornecida em tempo real. Você come uma maçã imediatamente enquanto descasca uma banana antes de comer. Simples.
O que é Sobrecarga de método em C #?
A Sobrecarga de método é a implementação em tempo de compilação do conceito de polimorfismo. Os desenvolvedores podem definir métodos semelhantes com o mesmo nome, diferindo no número de argumentos, na ordem dos argumentos ou no tipo de argumento. No exemplo de frutas, você não precisa definir métodos separados para cada fruta (coma Apple, coma banana, etc.). Você pode usar o mesmo nome para comer frutas e passar parâmetros diferentes para ela. O compilador chamaria automaticamente o método apropriado.
Vamos dar a perspectiva do C # agora. Nos termos mais simples, a Sobrecarga de método em C # ocorre quando você tem dois ou mais métodos com o mesmo nome, mas com assinaturas diferentes. Isso pode ser alcançado de várias maneiras:
- O número diferente de parâmetros.
- Diferentes tipos de parâmetros.
- Ordem diferente de parâmetros.
- Parâmetros opcionais.
- Argumentos nomeados.
Como a Sobrecarga de método funciona em C #?
Então, como é chamado o método apropriado com base nos argumentos / parâmetros? Bem, o compilador verifica cada definição de método durante a compilação e vincula as chamadas de método às respectivas definições. Caso existam dois métodos com o mesmo nome, o compilador verifica a assinatura dos métodos e vincula a definição apropriada à chamada. Mesmo se as assinaturas não puderem resolver a ambiguidade, o compilador procurará a conversão implícita de argumentos para corresponder às assinaturas. Se uma conversão implícita resultar em uma correspondência de assinatura, a ligação será feita. Caso contrário, o compilador gera um erro.
Examinaremos vários exemplos neste artigo para entender o funcionamento do compilador em vários tipos de Sobrecarga de método.
Tipos de método que sobrecarregam em c #
Aqui discutimos os vários tipos de sobrecarga de método em C #:
1. Número diferente de parâmetros
A primeira e a categoria mais simples de sobrecarga de método ocorre quando os métodos têm um número diferente de parâmetros em suas assinaturas.
Código
O exemplo abaixo é bem direto e não é óbvio.
using System;
public class Program
(
public static void Main()
(
Func(10);)
public static void Func(int a)
(
Console.WriteLine("Single Parameter");
)public static void Func(int a, int b)
(
Console.WriteLine("Multiple Parameters");
)
)
Resultado:
2. Diferentes tipos de parâmetros
Quando as assinaturas do método possuem parâmetros que diferem nos tipos. O número de parâmetros pode ou não ser o mesmo.
Exemplo 1
No exemplo abaixo, ambos os métodos esperam um único argumento. Portanto, com base no tipo de argumento passado durante a chamada do método, o compilador vincula a definição de método apropriada.
Código
using System;
public class Program
(
public static void Main()
(
Func("Hello World");
)
public static void Func(int a)
(
Console.WriteLine("Integer Parameter");
)
public static void Func(string b)
(Console.WriteLine("String Parameter");
)
)
Resultado:
Exemplo 2
Agora, vamos dar ao compilador algo para pensar. Sobrecarregaríamos um método do tipo double e float. Sabemos que um número inteiro sempre pode ser implicitamente convertido em um tipo float e também em um tipo duplo.
Quando passamos um argumento inteiro, o compilador verifica a conversão implícita e descobre que a melhor conversão possível é um número inteiro para flutuar. Portanto, o método float é chamado.
Código
using System;
public class Program
(
public static void Main()
(
Func(10);
)
public static void Func(double a)
(
Console.WriteLine("Double Parameter");
)
public static void Func(float b)
(
Console.WriteLine("Floating Point Parameter");
)
)
Resultado:
3. Ordem Diferente de Parâmetros
Quando o número e o tipo de argumentos são iguais, mas a ordem pela qual eles são passados difere.
Exemplo 1
O exemplo abaixo é bastante direto.
Código
using System;
public class Program
(
public static void Main()
(
Func(10, 0.1);
)
public static void Func(int a, double b)
(
Console.WriteLine("Int-Double Parameters");
)
public static void Func(double a, int b)
(
Console.WriteLine("Double-Int Parameter");
)
)
Resultado:
Exemplo 2
O que aconteceria quando passássemos dois argumentos inteiros no exemplo acima? Vamos descobrir.
Código
Func(10, 1);
Resultado:
4. Parâmetros Opcionais
Quando definimos um parâmetro opcional na assinatura do método, o compilador o trata como sobrecarga de método.
Nota: isso tem precedência sobre a conversão implícita.
Vamos entender isso com um exemplo.
Exemplo
No exemplo abaixo, damos ao compilador duas opções. Ou pode implicitamente converter o argumento para corresponder à assinatura do método. Ou pode passar o valor padrão do argumento opcional. O compilador prefere a última abordagem.
Código
using System;
public class Program
(
public static void Main()
(
Func(10);
)
public static void Func(int a, int b = 1)
(
Console.WriteLine("Int-Int Parameters");
)
public static void Func(double a)
(
Console.WriteLine("Double Parameter");
)
)
Resultado:
5. Argumentos nomeados
C # tem outro recurso de passar o nome dos argumentos enquanto chama o método. Isso também ajuda na sobrecarga de método. Os desenvolvedores podem optar por chamar um método específico, mesmo que o argumento passado, por padrão, chame outro método. Embora, os métodos sobrecarregados devam diferir na assinatura.
Exemplo
No exemplo abaixo, instruímos o compilador a chamar um método específico, passando o nome do parâmetro. O compilador suspende sua lógica de determinar o método mais adequado.
Código
using System;
public class Program
(
public static void Main()
(
Func(b: 10);
)
public static void Func(int a)
(
Console.WriteLine("Int-Int Parameters");
)
public static void Func(double b)
(
Console.WriteLine("Double Parameter");
)
)
Resultado:
Regras de Sobrecarga de Método em C #
As regras a seguir devem ser lembradas ao sobrecarregar os métodos no aplicativo C #.
- A assinatura do método deve ser diferente. O número de argumentos, o tipo de argumentos ou a ordem dos argumentos deve ser diferente.
- O tipo de retorno dos métodos não desempenha nenhum papel na sobrecarga de métodos.
- Parâmetros opcionais têm precedência sobre a conversão implícita de tipo ao decidir qual definição de método vincular.
- A conversão implícita de tipo tem precedência sobre o método da classe pai.
Exercício - Para entender isso, aqui está um pequeno exercício para você. Crie uma classe pai com um método que espera um número inteiro Herdar uma classe filho. Sobrecarregar o método da classe pai na classe filho, de modo que o método da classe filho espere um argumento de tipo duplo. Crie um objeto da classe filho e chame o método sobrecarregado passando um número inteiro. Veja o que acontece.
Conclusão
A sobrecarga de método é um conceito bastante poderoso. É muito útil para escrever código elegante. No entanto, pode chegar a um ponto em que dezenas de métodos estão sobrecarregados, e o desenvolvedor precisa consultar as definições de método enquanto depura as chamadas erradas. Para evitar isso, geralmente é sugerido nomear seus métodos de maneira diferente quando a sobrecarga tende a aumentar para um nível mais alto.
Artigos recomendados
Este é um guia para sobrecarregar em c #. Aqui discutimos seu método, como funciona, tipos com exemplo e regras. Você também pode consultar nossos outros artigos sugeridos para saber mais -
- C # While Loop
- C # if Instrução
- Funções C #
- Usos de c #
- Guia de sobrecarga em C ++
- Sobrecarga em Java
- Sobrecarga de Python
- Sobrecarregando e substituindo em c #
- Conversão de tipo em Java com tipos e exemplos