Este blog demonstra o uso e a implementação da vinculação dinâmica em Java.
Como usar o Dynamic Binding em Java?
A ligação dinâmica permite um acoplamento solto entre objetos. Ele ajuda na fácil extensão da funcionalidade adicionando novas subclasses que substituem os métodos sem modificar o código existente. A vinculação dinâmica é amplamente utilizada para despacho de tempo de execução, manipulação de eventos ou sistemas de plug-in.
Vamos percorrer alguns exemplos para uma explicação detalhada:
Exemplo 1: implementação de vinculação dinâmica
Ao usar a ligação dinâmica, os programadores podem permitir que os usuários personalizem e substituam os comportamentos padrão para criar aplicativos personalizáveis. Para uma implementação prática, vamos ver um exemplo:
importar java.util.Arrays;
importar java.util.HashSet;
importar java.util.List;
importar java.util.Set;
classe pública DynBind {
public static void principal ( Corda [ ] argumentos ) {
Gaming gameType1 = novo Cricket ( ) ;
Gaming gameType2 = novo CallofDuty ( ) ;
gameType1.gameType ( ) ;
gameType2.gameType ( ) ;
}
}
jogo de classe {
public void tipo de jogo ( ) {
System.out.println ( 'Jogos físicos ou virtuais' ) ;
}
}
classe Cricket estende Gaming {
@ Sobrepor
public void tipo de jogo ( ) {
System.out.println ( 'Críquete é um jogo físico' ) ;
}
}
classe CallofDuty estende o jogo {
@ Sobrepor
public void tipo de jogo ( ) {
System.out.println ( 'CallofDuty é um jogo virtual' ) ;
}
}
Explicação do código acima:
- Primeiro, a classe “ DynBindName ” é criado e dois objetos do tipo “ Jogos ” são declarados.
- Em seguida, esses objetos são inicializados com new “ Grilo ' e ' Chamada à ação ” objetos, esta inicialização demonstra a ligação dinâmica. O tipo de referência é “ Jogos ” mas os tipos de objeto reais são “ Grilo ' e ' Chamada à ação ”, respectivamente.
- Agora, esses objetos são utilizados para invocar o “ tipo de jogo() ” substituindo a função em classes filhas.
- Então, o pai “ Jogos ” classe é declarada que cria e inicializa o “ tipo de jogo() ”, que imprime uma mensagem de texto fictícia.
- Em seguida, duas classes filhas são criadas com o nome “ Grilo ' e ' Chamada à ação ”. Essas classes são herdadas do pai “ Jogos ' aula.
- Depois disso, o “ @Sobrepor ” a anotação é utilizada para substituir o pai “ Jogos ” métodos de classe chamados “ tipo de jogo() ”.
- No final, uma mensagem fictícia diferente é exibida em ambos os métodos substituídos da classe filha.
Após o término da fase de execução:
A saída mostra que as mensagens fictícias das classes filhas são exibidas no console usando ligação dinâmica.
Exemplo 2: implementação de herança multinível
A vinculação dinâmica também pode ser implementada para a criação de herança multinível. Dois blocos de código do mesmo programa, conforme mostrado abaixo:
jogo de classe {public void tipo de jogo ( ) {
System.out.println ( 'Jogos físicos ou virtuais' ) ;
}
}
classe Cricket estende Gaming {
@ Sobrepor
public void tipo de jogo ( ) {
System.out.println ( 'Críquete é um jogo físico' ) ;
}
public void playFormat ( ) {
System.out.println ( 'O críquete tem diferentes formatos de jogo' ) ;
}
}
classe CallofDuty estende o jogo {
@ Sobrepor
public void tipo de jogo ( ) {
System.out.println ( 'CallofDuty é um jogo virtual' ) ;
}
public void gameMode ( ) {
System.out.println ( 'CallofDuty tem vários modos de jogo' ) ;
}
}
classe CricketGame estende Cricket {
public void gameMode ( ) {
System.out.println ( 'Cricket tem modo de jogo único' ) ;
}
}
classe CallofDutyGame estende CallofDuty {
}
Explicação do código acima:
- Primeiro, o pai “ Jogos ” é criada e inclui a classe “ tipo de jogo() ” que contém uma mensagem fictícia.
- Em seguida, duas classes filhas chamadas “ Grilo ' e ' Chamada à ação ” são criados, ambos substituindo a função de classe pai chamada “ tipo de jogo() ”.
- Essas classes contêm uma função extra chamada “ jogandoFormato() ' e ' modo de jogo() ”funções, respectivamente.
- Em seguida, crie um filho de vários níveis chamado “ CricketGame ” que é estendido pela criança “ Grilo ' aula. Ele contém o “ modo de jogo() ” função que é substituída por seu pai “ Grilo ' aula.
- Depois disso, o “ Jogo CallofDuty ” é criada como filha para a classe “ Chamada à ação ' aula. Ele cria uma herança multinível e habilita a funcionalidade de ligação dinâmica.
Agora, insira o “ principal() ” método:
classe pública DynBind {public static void principal ( Corda [ ] argumentos ) {
Jogo CallofDuty código = novo CallofDutyGame ( ) ;
codg.gameType ( ) ;
codg.gameMode ( ) ;
CricketGame cricg = novo jogo de críquete ( ) ;
cricg.gameType ( ) ;
cricg.playingFormat ( ) ;
cricg.gameMode ( ) ;
}
}
Explicação do código acima:
- Primeiro, um objeto do “ Jogo CallofDuty ” é criada a classe que chama as funções de suas classes pai.
- Da mesma forma, o “ CricketGame ” é declarado o objeto que chama sua função de classe pai que está disponível em vários níveis na hierarquia.
Após o término da fase de execução:
A saída mostra que a herança multinível é criada usando ligação dinâmica em Java.
Conclusão
Em Java, o “ ligação dinâmica ” oferece benefícios como polimorfismo, reutilização de código, flexibilidade e extensibilidade. Ele é implementado seguindo as regras de herança, substituição de método e upcasting. A ligação dinâmica também permite funções de tempo de execução e aprimora o comportamento flexível e polimórfico no conceito de OOPs. Isso é tudo sobre o uso e implementação de ligação dinâmica em Java.