Questo blog illustra l'utilizzo e l'implementazione dell'associazione dinamica in Java.
Come utilizzare l'associazione dinamica in Java?
L'associazione dinamica consente l'accoppiamento libero tra gli oggetti. Aiuta nella facile estensione della funzionalità aggiungendo nuove sottoclassi che sovrascrivono i metodi senza modificare il codice esistente. L'associazione dinamica è ampiamente utilizzata per l'invio in fase di esecuzione, la gestione degli eventi o i sistemi di plug-in.
Facciamo un paio di esempi per una spiegazione dettagliata:
Esempio 1: implementazione dell'associazione dinamica
Utilizzando l'associazione dinamica, i programmatori possono consentire agli utenti di personalizzare e sovrascrivere i comportamenti predefiniti per creare applicazioni personalizzabili. Per l'implementazione pratica, esaminiamo un esempio:
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
importare java.util.Set;
classe pubblica DynBind {
public static void principale ( Corda [ ] arg ) {
Gaming gameType1 = nuovo Cricket ( ) ;
Gaming gameType2 = nuovo CallofDuty ( ) ;
gameType1.gameType ( ) ;
gameType2.gameType ( ) ;
}
}
gioco di classe {
public void gameType ( ) {
System.out.println ( 'Giochi fisici o virtuali' ) ;
}
}
la classe Cricket estende il gioco {
@ Oltrepassare
public void gameType ( ) {
System.out.println ( 'Il cricket è un gioco fisico' ) ;
}
}
classe CallofDuty estende il gioco {
@ Oltrepassare
public void gameType ( ) {
System.out.println ( 'CallofDuty è un gioco virtuale' ) ;
}
}
Spiegazione del codice precedente:
- Innanzitutto la classe” DynBind ” viene creato e due oggetti di tipo “ Gioco ” sono dichiarati.
- Successivamente, questi oggetti vengono inizializzati con new ' Cricket ' E ' Call of Duty ” oggetti, questa inizializzazione dimostra l'associazione dinamica. Il tipo di riferimento è ' Gioco ” ma i tipi di oggetti effettivi sono “ Cricket ' E ' Call of Duty ”, rispettivamente.
- Ora, questi oggetti sono utilizzati per invocare il ' tipo di gioco() ” funziona sovrascrivendo la funzione nelle classi figlie.
- Poi, il genitore” Gioco viene dichiarata la classe ” che crea e inizializza il “ tipo di gioco() ” funzione, che stampa un messaggio di testo fittizio.
- Successivamente, vengono create due classi figlie con il nome ' Cricket ' E ' Call of Duty ”. Queste classi sono ereditate dal genitore ' Gioco ' classe.
- Dopodiché il “ @Oltrepassare ” l'annotazione è utilizzata per sovrascrivere il genitore “ Gioco 'metodi di classe denominati' tipo di gioco() ”.
- Alla fine, viene visualizzato un messaggio fittizio diverso in entrambi i metodi sottoposti a override della classe figlia.
Al termine della fase esecutiva:
L'output indica che i messaggi fittizi delle classi figlio vengono visualizzati nella console utilizzando l'associazione dinamica.
Esempio 2: implementazione dell'ereditarietà multilivello
L'associazione dinamica può anche essere implementata per la creazione di ereditarietà multilivello. Due blocchi di codice dello stesso programma come mostrato di seguito:
gioco di classe {public void gameType ( ) {
System.out.println ( 'Giochi fisici o virtuali' ) ;
}
}
la classe Cricket estende il gioco {
@ Oltrepassare
public void gameType ( ) {
System.out.println ( 'Il cricket è un gioco fisico' ) ;
}
public void playingFormat ( ) {
System.out.println ( 'Il cricket ha diversi formati di gioco' ) ;
}
}
classe CallofDuty estende il gioco {
@ Oltrepassare
public void gameType ( ) {
System.out.println ( 'CallofDuty è un gioco virtuale' ) ;
}
Modalità gioco public void ( ) {
System.out.println ( 'CallofDuty ha più modalità di gioco' ) ;
}
}
class CricketGame estende Cricket {
Modalità gioco public void ( ) {
System.out.println ( 'Cricket ha una modalità di gioco singolo' ) ;
}
}
class CallofDutyGame estende CallofDuty {
}
Spiegazione del codice precedente:
- Primo, il genitore” Gioco ” classe viene creata e include il “ tipo di gioco() ” funzione che contiene un messaggio fittizio.
- Successivamente, due classi figlie denominate ' Cricket ' E ' Call of Duty ” vengono creati, entrambi sovrascrivendo la funzione della classe genitore denominata “ tipo di gioco() ”.
- Queste classi contengono una funzione aggiuntiva denominata ' giocandoFormat() ' E ' modalità di gioco() ” funzioni, rispettivamente.
- Quindi, crea un figlio multilivello chiamato ' Gioco di cricket ” che viene esteso dal bambino “ Cricket ' classe. Contiene il “ modalità di gioco() ” funzione che è sovrascritta dal suo genitore “ Cricket ' classe.
- Dopodiché il “ Gioco CallofDuty ” la classe viene creata come child per il “ Call of Duty ' classe. Crea un'ereditarietà multilivello e abilita la funzionalità dell'associazione dinamica.
Ora, inserisci il ' principale() ' metodo:
classe pubblica DynBind {public static void main ( Corda [ ] arg ) {
Gioco CallofDuty cod = nuovo CallofDutyGame ( ) ;
codg.gameType ( ) ;
codg.gameMode ( ) ;
Gioco di cricket cricg = nuovo gioco di cricket ( ) ;
cricg.gameType ( ) ;
cricg.playingFormat ( ) ;
cricg.gameMode ( ) ;
}
}
Spiegazione del codice precedente:
- In primo luogo, un oggetto del “ Gioco CallofDuty Viene creata una classe che chiama le funzioni delle sue classi genitore.
- Allo stesso modo il “ Gioco di cricket Viene dichiarato un oggetto che chiama la sua funzione di classe genitore che è disponibile a più livelli nella gerarchia.
Al termine della fase esecutiva:
L'output mostra che l'ereditarietà multilivello viene creata utilizzando l'associazione dinamica in Java.
Conclusione
In Java, il ' legame dinamico ” offre vantaggi come polimorfismo, riusabilità del codice, flessibilità ed estensibilità. Viene implementato seguendo le regole di ereditarietà, override del metodo e upcasting. L'associazione dinamica abilita anche le funzioni di runtime e migliora il comportamento flessibile e polimorfico nel concetto OOP. Questo è tutto sull'uso e l'implementazione dell'associazione dinamica in Java.