Introdução à sobrecarga e substituição em C #
Polimorfismo é um dos conceitos importantes em C #. Existem dois tipos de polimorfismo, tempo de compilação e tempo de execução. Os conceitos Sobrecarga e Substituição são usados para conseguir isso, respectivamente. Na substituição, uma classe filho pode implementar o método da classe pai de uma maneira diferente, mas o método da classe filho tem o mesmo nome e a mesma assinatura do pai, enquanto na sobrecarga há vários métodos em uma classe com o mesmo nome e parâmetros diferentes.
Como substituir e sobrecarregar funciona em c #?
O trabalho de substituir e sobrecarregar em C # é explicado abaixo com exemplos:
Substituindo
Existem algumas palavras-chave que usamos na substituição como virtual, override e base.
Sintaxe:
class Parent
(
public virtual void Example() // base class
(
Console.WriteLine(“ parent class”);
)
)
class Child: Parent
(
public override void Example() // derived class
(
base.Example();
Console.WriteLine(“Child class”);
)
)
Neste, palavras-chave virtuais e de substituição são usadas, o que significa que a classe base é virtual e a classe filho pode implementar essa classe e substituir significa que essa classe filho tem o mesmo nome e a mesma assinatura de método da classe pai.
Exemplo 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Subject s = new Mathematics();
s.study();
Console.ReadLine();
)
)
)
No exemplo acima, o nome dos métodos é o mesmo, mas sua implementação é diferente. A classe base tem virtual e, devido a essa classe filho, pode implementar o método da classe pai à sua maneira. O método da classe filho tem substituição de palavra-chave, o que mostra que esse método é um método de substituição.
Resultado:
Exemplo 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
base.study();
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Mathematics m = new Mathematics();
m.study();
Console.ReadLine();
)
)
)
Resultado:
Neste exemplo, a classe derivada possui uma palavra-chave base que é usada para chamar o método da classe base. Portanto, nesse caso, o método derivado é chamado após o método da classe base.
Pontos para lembrar:
- No conceito de substituição, o nome do método e a assinatura do método e o modificador de acesso são sempre os mesmos da classe pai e filho.
- O método da classe pai não pode ser estático.
Sobrecarga
Na sobrecarga, existem vários métodos com assinatura de método diferente. Abaixo estão alguns exemplos que mostram como podemos obter sobrecarga variando o número de parâmetros, a ordem dos parâmetros e os tipos de dados dos parâmetros.
Exemplo 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y)
(
int value = x + y;
return value;
)
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
int sum2 = d.Sum(10, 20, 30);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)
No exemplo acima, existem dois métodos com o mesmo nome, mas com um número diferente de parâmetros. O primeiro método consiste em dois parâmetros, enquanto o segundo possui três parâmetros. Isso é chamado de sobrecarga de método.
Resultado:
Exemplo 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public double Sum(double x, double y, double z)
(
double value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28, 7);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
double sum2 = d.Sum(10.0, 20.0, 30.0);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)
No exemplo acima, existem dois métodos com o mesmo nome, mas seus tipos de dados são diferentes. O primeiro método possui um tipo de dados inteiro, enquanto o segundo possui um tipo de dados duplo. Portanto, neste caso, os parâmetros estão variando devido aos diferentes tipos de dados.
Resultado:
Exemplo 3
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public void Details(String name, int id)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id); ;
)
public void Details(int id, string name)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id);
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
d.Details("John", 10);
d.Details("Joe", 20);
Console.ReadLine();
)
)
)
No exemplo acima, o nome dos métodos é o mesmo, mas a ordem dos parâmetros é diferente. O primeiro método possui um nome e id resp. enquanto o segundo tem id e nome, respectivamente.
Resultado:
Pontos para lembrar:
- Em um conceito de sobrecarga, não é possível definir mais de um método com os mesmos parâmetros em caso de ordem, tipo e número.
- Não é possível sobrecarregar um método com base nos diferentes tipos de retorno.
Vantagens de sobrecarregar e substituir em c #
- A sobrecarga é uma das maneiras de obter estática e a substituição é uma das maneiras pelas quais o C # alcança o polimorfismo dinâmico.
- Ele fornece flexibilidade ao usuário e limpeza do código.
Conclusão
Sobrecarregar e substituir desempenham um papel importante na obtenção do polimorfismo. A substituição permite que a classe derivada seja implementada à sua maneira e, por outro lado, a sobrecarga é sobre métodos com o mesmo nome e vários tipos de implementações de parâmetros.
Artigos recomendados
Este é um guia para Sobrecarregar e substituir em C #. Aqui discutimos o trabalho, sintaxe, vantagens de sobrecarregar e substituir em C # com exemplos e implementação de código. Você também pode consultar os seguintes artigos para saber mais -
- Objetos em c #
- Matrizes 2D em C #
- Substituindo em C #
- Trocando em C #
- Polimorfismo em Java
- Gráficos 2D em Java
- 3 tipos diferentes de matrizes em PHP (exemplos)