Introdução à substituição em OOPs
Ao implementar o conceito de herança em ops, todas as funções na classe pai são usadas por todas as suas classes derivadas. Porém, se uma classe derivada desejar a implementação específica da função que foi declarada na classe pai, mas usando o mesmo nome, a mesma assinatura e o mesmo tipo de retorno, o recurso de substituição será usado. A substituição permite que a classe filha redefina a função que já foi definida em sua classe ou superclasse pai. Dessa maneira, pode-se usar a definição especificando o objeto da classe enquanto chama o método. Por exemplo, deixe que exista uma função soma na classe pai e filho e, ao chamar a função, usamos o objeto da classe filho, em seguida, o método presente na classe filho será chamado e, em vez disso, se você usar o objeto da classe pai, o método presente na classe pai será chamado. Diz-se que esse método na classe filho substitui o método presente em suas superclasses.
Necessidade de substituição de método
A seguir estão os métodos de Substituição:
- A substituição do método polimorfismo em tempo de execução ajuda a obter polimorfismo em tempo de execução em linguagens de programação orientadas a objetos como c ++, java, c #, etc.
- Polimorfismo significa ter muitas formas, isto é, uma assinatura e várias definições. em linguagens orientadas a objetos, quando a classe derivada e a pai têm o mesmo nome e assinatura de uma função, o compilador resolve a definição que precisa chamar. Polimorfismo de tempo de execução significa que a ligação de uma definição de método a um método chamado está ocorrendo no tempo de execução de um programa. Ele permite implementar o aspecto de “uma definição múltipla de assinatura” do polimorfismo. Esse recurso usa o envio dinâmico de métodos, que possui um conceito poderoso de design orientado a objetos para trazer reutilização e robustez de código. A substituição de um método permite uma chamada de método para qualquer uma de suas classes derivadas sem conhecer o tipo de objeto da classe derivada.
- Usando esse recurso, é possível implementar uma definição especializada para a função genérica que foi herdada de sua superclasse.
Como a substituição funciona nos OOPs?
A explicação abaixo diz que a substituição funciona:
- OOPs, ajudam-nos a implementar o polimorfismo de tempo de execução enquanto herdamos os recursos de uma classe para outro. Vamos dar uma olhada no trabalho de substituição em OOPs. Mais tarde, suponha que tenhamos um nome de superclasse animal que tenha duas funções falar e comer. Existem duas subclasses gato e cachorro que estendem o nome animal da superclasse.
- Essas duas subclasses usam as mesmas funções speak and eat, mas alteram a implementação, mas mantêm a assinatura dos métodos da mesma forma. Agora, em nosso método principal, se você chamar essas funções, escolhendo a variável de referência, somente no tempo de execução, será decidido qual função ele precisará chamar. Por exemplo, se o objeto mantiver a diferença de classe filho que é gato ou cachorro, a função de uma classe respectiva será chamada. Caso contrário, se o objeto mantiver a referência da classe pai, a função de uma classe animal será chamada.
- Aqui devemos ver que a função é chamada não depende do tipo de variável de referência. Isso é decidido pelo compilador no tempo de execução, apenas ajuda a implementar o polimorfismo do tempo de execução. Também ajuda a implementar a definição especializada do método da definição genérica de método na classe pai.
Código:
class Animal(
//Overridden method
public void eat()
(
System.out.println("Animal is eating");
)
public void speak()
(
System.out.println("Animal is speaking");
)
)
class Cat extends Animal(
//Overriding method
public void eat()
(
System.out.println("Cat is eating");
)
public void speak()
(
System.out.println("Cat is meowing");
)
)
class Dog extends Animal(
//Overriding method
public void eat()
(
System.out.println("Dog is Barking");
)
public void speak()
(
System.out.println("Dog is speaking");
)
)
public class Test(
public static void main(String() args)(
Animal an=new Dog();
Animal an1 = new Cat();
Animal an2 = new Animal();
an.speak();
an.eat();
an1.speak();
an1.eat();
an2.eat();
)
)
Resultado:
Nota: Uma variável de referência do tipo filho não pode ser usada para manter uma referência ao tipo pai.
Regras para substituir um método
A seguir estão as regras de substituição:
Regra 1
Uma lista dos parâmetros declarados na função da classe pai deve corresponder à lista dos parâmetros mencionados na definição de método de substituição na classe filho.
Por exemplo:
O método na classe pai
public int test1(int a);
Um método na classe filho - public string test1 (); // a substituição do método não será suportada aqui, pois o tipo de retorno e os argumentos são diferentes, mas nenhum erro em tempo de compilação ocorrerá. Este método será considerado como um novo método de uma classe filho.
Regra nº 2
O tipo de retorno do método presente na classe filho deve ser o mesmo ou um subtipo do tipo de retorno do método que está sendo substituído.
Por exemplo:
O método em uma classe pai
public Object test1(int a);
O método na classe filho
public String test1();
Incorreta
O método na classe pai
public String test1(int a);
O método na classe filho
public Object test1();
Regra nº 3
O especificador de acesso presente no método da classe pai deve ser igualmente restritivo ou mais restritivo do que o método que o substitui na classe filho.
Incorreta
O método na classe pai
public int test1(int a);
Método na classe filho
private int test1() ; // more restrictive than public one
Regra nº 4
Somente o método da instância com o especificador de acesso como protegido público ou padrão pode ser substituído. Isso ocorre porque apenas esse método de instância pode ser herdado por sua subclasse e, portanto, considerado sobrescrito. Caso o método de instância especificado na classe pai seja um método público de exemplo mais restritivo, ele não será herdado em sua subclasse e o fará se alguém estiver definindo o mesmo método em uma subclasse em que o cenário não será usado como um método de substituição, pois os métodos públicos não podem ser herdado, isso não pode ser substituído.
Por exemplo:
O método na classe pai
public int test1(int a); //can be inherited and overridden
O método na classe filho
private int test1();
Incorreta
O método na classe pai
private int test1(int a); //can not be inherited and overridden
O método na classe filho
private int test1();//not overriding method of the parent class
É considerado como um novo método privado da classe filho
Regra nº 5
A super palavra-chave pode ser usada para chamar a função da classe pai que foi substituída por sua subclasse.
class Animal(
//Overridden method
public void eat()
(
System.out.println("Animal is eating");
)
public void speak()
(
System.out.println("Animal is speaking");
)
)
class Dog extends Animal(
//Overriding method
public void eat()
(
System.out.println("Dog is Barking");
)
public void speak()
(
super.speak(); // Here super keyword is used to call the speak function of the super class.ieAnimal
)
)
public class Test(
public static void main(String() args)(
Animal an=new Dog();
Animal an2 = new Animal();
an.speak();
an.eat();
an2.eat();
)
)
Resultado:
Regra nº 6
O construtor de uma classe não pode ser substituído por suas subclasses, pois um construtor de duas classes não pode ser o mesmo.
Regra nº 7
Tratamento de exceções em substituição.
- Como o método Incase na classe pai não lança nenhuma exceção, o método de substituição presente na subclasse tem permissão para lançar uma única exceção não verificada. Caso o método de substituição mostre a exceção verificada, o compilador mostrará um erro.
- Se o método na classe pai que está sendo substituído lança um método de substituição conjunto de exceção presente na subclasse, deve-se, por meio de uma exceção do mesmo nível ou seu subtipo na hierarquia de exceções, ou nenhuma exceção.
Regra nº 8
A substituição de método na herança multinível também é possível.
Código:
class Creature (
//Overriding method
public void eat()
(
System.out.println("Creature is eating");
)
public void speak()
(
System.out.println("Creature is speaking");
)
)
class Animal extends Creature(
//Overridden method
public void eat()
(
System.out.println("Animal is eating");
)
public void speak()
(
System.out.println("Animal is speaking");
)
)
class Dog extends Animal(
//Overriding method
public void eat()
(
System.out.println("Dog is Barking");
)
public void speak()
(
System.out.println("Dog is speaking");
)
)
public class Test(public static void main(String() args)(
Creature an=new Dog();
Animal an1 = new Animal();
Animal an2 = new Dog();
an.speak();
an.eat();
an1.speak();
an1.eat();
an2.eat();
)
)
Resultado:
Regra nº 9
Substituindo regras de método em Java
- Um método sincronizado pode ser facilmente substituído por um método não sincronizado e vice-versa.
- O método abstrato presente em classes ou interfaces abstratas deve ser substituído para fornecer implementação específica aos métodos declarados, caso contrário, ele mostrará um erro em tempo de compilação.
- Definir um método estático com o mesmo nome que um método estático presente na classe pai é conhecido como método oculto, não substituição de método, pois não implementa o polimorfismo de tempo de execução.
- Os métodos finais não podem ser substituídos.
Regra nº 10
Substituição de método em C ++
A substituição do método em c plus é obtida declarando um método como virtual. Uma palavra-chave virtual é usada para obter polimorfismo de tempo de execução em c ++. Enquanto em Java todas as funções são, por padrão, consideradas virtuais.
Regra # 11
A substituição de método é diferente da sobrecarga de método, pois é um processo de polimorfismo em tempo de execução, enquanto a sobrecarga e o método são um exemplo de polimorfismo em tempo de compilação. Na substituição do método, é obrigatório manter a assinatura do método igual. quando fazemos alguma alteração no tipo de retorno do método ou na lista de parâmetros, o compilador o trata como uma sobrecarga de método.
| Substituição de método | Sobrecarga de método |
class A( | class A( |
Resultado:
 |  |
Quando usar a Substituição de método?
A seguir estão os métodos de uso de Substituição:
- OOPs fornece um recurso maravilhoso de herança para formar uma grande hierarquia entre superclasse e subclasse, de menor especialização a maior especialização.
- Podemos usar a superclasse para fornecer uma estrutura que pode ser herdada em todas as suas subclasses e nas subclasses podemos definir o funcionamento diferente desses métodos. Isso é conseguido sobrescrevendo o recurso em que o funcionamento especializado pode ser fornecido às subclasses init dos métodos herdados.
- Também ajuda a fornecer uma estrutura para várias classes, fornecendo uma coleção de variáveis e o método que precisa ser implementado em todas as suas subclasses.
Conclusão
OOPs, conceitos tornam o código robusto e fácil de reutilizar quando são usados de maneira eficaz. O recurso de substituição aprimora o uso da herança para fornecer a implementação específica ao método genérico da classe pai. Em suas subclasses. Isso usa o conceito de polimorfismo de tempo de execução para disparar a definição correta do método. O envio de método dinâmico é feito apenas no tempo de execução, que verifica a referência da classe que o objeto está mantendo para chamar o método. Esse recurso é guiado por várias regras e não se aplica a métodos estáticos. Podemos implementar a substituição de método em qualquer linguagem orientada a objetos e tornar nosso programa mais rápido e robusto.
Artigos recomendados
Este é um guia para Substituir em OOPs. Aqui discutimos como a substituição funciona em OOPs, quando usá-la e 11 regras com códigos e saída. Você também pode consultar nossos outros artigos relacionados para saber mais.
- Substituindo em PHP
- Substituindo em JavaScript
- O que é OOP?
- Substituição de método em C #
- Exemplos de substituição em Java
- Método estático JavaScript | Como trabalhar com exemplos