Introduzione al binding statico e al binding dinamico
Questi sono due tipi di rilegatura. Binding si riferisce all'associazione della chiamata del metodo al corpo del metodo. Nell'associazione statica, tutti i compiti e le dichiarazioni avvengono al momento della compilazione. Hanno più pro e contro l'uno sull'altro. In termini di prestazioni, il binding statico è migliore del binding dinamico di metodi e variabili. Il legame statico è anche noto come legame anticipato. Come tutti sappiamo, i metodi di associazione come statico, privato e finale si verificano nel tempo di compilazione mentre nel compilatore di associazione dinamica non decide quale metodo verrà chiamato.
Di seguito un esempio dato è un esempio migliore da capire
Esempio 1
public class StaticBindingExample (
public static void main(String args()) (
Vehicle veh = new MotorBike();
veh.start();
)
)
class Vehicle (
static void start() (
System.out.println("vehicle will start now..");
)
)
class MotorBike extends Vehicle (
static void start() (
System.out.println("Bike will start now..");
)
)
Nell'esempio sopra riportato, possiamo vedere come l'associazione statica ha lo scopo di prevenire il sovraccarico della classe.
Di seguito viene mostrato un esempio di come funziona il Dynamic Binding, qui il metodo della classe figlio ha la precedenza sulla classe genitore
Esempio n. 2
public class StaticBindingExample (
public static void main(String args()) (
Vehicle veh = new MotorBike();
veh.start();
)
)
class Vehicle (
void start() (
System.out.println("vehicle will start now..");
)
)
class MotorBike extends Vehicle (
void start() (
System.out.println("Bike will start now..");
)
)
In questo esempio, static non è presente nel metodo start nel metodo della classe parent & child, quindi il metodo con lo stesso nome sostituirà il metodo della classe parent. Succede per questo.
Nella schermata sopra fornita, viene fornito l'output del programma.
Perché rilegatura statica e rilegatura dinamica?
- È necessario che la programmazione gestisca situazioni diverse mediante l'uso di rilegatura statica e dinamica.
- Compile-time Binding è noto come Early Binding ovvero significa quando è necessario dichiarare le cose al momento della compilazione (all'inizio) dell'esecuzione del programma. In Dynamic Binding, il Binding viene eseguito in fase di esecuzione, noto anche come Late Binding.
- Metodo e variabili, definiti come statici, finali e privati si riferiscono al legame statico mentre i metodi virtuali che il legame ha luogo in fase di esecuzione sono noti come legame dinamico.
- Metodo Sovraccarico / Sovraccarico dell'operatore utilizza il Binding statico, quindi è uno dei migliori esempi di esso mentre Overriding utilizza Dynamic, quindi è noto come il miglior esempio di Binding dinamico.
- In questo, un oggetto reale non viene mai utilizzato mentre l'oggetto reale viene utilizzato nel binding dinamico.
Esempi
Nell'esempio riportato di seguito, possiamo vedere come avviene l'associazione statica
Esempio 1
// Implementazione della classe genitore
class Colony(
//Static method to start the electricity of the Colony
public static void start electricity()(
//printing the message here
System.out.println("Colony Electricity is On.");
)
)
//Child class implementation
class Building extends Colony(
//Static method to start the electricity of Building
public static void startElectricity()(
//printing the message here
System.out.println("Building Electricity is On.");
)
)
public class StaticBindingExample (
public static void main(String args()) (
//Creating object of the parent class type
Colony col = new Colony();
col.startElectricity();
//Creating object of the child class type
Colony col2 = new Building();
col2.startElectricity();
)
)
Nel programma sopra indicato, col è la variabile di riferimento del tipo classe Colony che punta all'oggetto della classe Colony. col2 è anche la variabile di riferimento del tipo class Colony ma punta all'oggetto della classe Building. Quando ha luogo la compilazione, mentre il compilatore di bind non controlla mai il tipo di oggetto, controlla solo il tipo di variabile di riferimento.
Nel programma sopra, come col .startElectricity (), il compilatore controlla se esiste la definizione del metodo di inizio elettricità () nella classe Colonia o meno perché col è di tipo Colonia. Analogamente per la chiamata al metodo col2.startElectricity (), controlla se il metodo start elettrica () è presente nella classe Colonia o meno perché anche col2 è di tipo Colonia. Non controlla a quale oggetto col, col2 punta. questo tipo di rilegatura è noto come rilegatura statica.
Produzione:
L'output del programma sopra indicato mostra come vengono utilizzati i membri statici per impedire l'override.
Esempio n. 2
Nell'esempio riportato di seguito, possiamo vedere come si verifica il Binding dinamico durante il runtime
// Implementazione della classe genitore
class Colony(
//method to start the electricity of the Colony
void startElectricity()(
//printing the message here
System.out.println("Colony Electricity is On.");
)
)
//Child class implementation
class Building extends Colony(
//method to start the electricity of Building
void startElectricity()(
//printing the message here
System.out.println("Building Electricity is On.");
)
)
public class StaticBindingExample (
public static void main(String args()) (
//Creating object of the parent class type
Colony col = new Colony();
col.startElectricity();
//Creating object of the child class type
Colony col2 = new Building();
col2.startElectricity();
)
)
Nel programma sopra indicato, tutto è uguale a quello di un programma di esempio statico ma in questo esempio viene rimosso il membro del metodo "statico". Durante questo, verrà chiamato il metodo dell'oggetto principale a cui punta col.startElectricity (). Mentre per la chiamata col2.startElectricity (), verrà chiamato il metodo dell'oggetto principale a cui punta col2. Questo tipo di associazione è noto come Dynamic Binding.
Produzione:
Vantaggio
- L'esecuzione di binding statico è più efficiente e più veloce di Dynamic. Questo compilatore di Binding sa che questi tipi di metodi non possono essere sovrascritti.
- Nel binding statico, il tipo viene utilizzato mentre il binding dinamico utilizza oggetti per i binding.
- Uno dei principali vantaggi di Dynamic Binding è la flessibilità, grazie alla flessibilità che una singola funzione può gestire diversi tipi di un oggetto in fase di esecuzione.
- In Binding statico, tutte le informazioni necessarie prima del tempo di compilazione mentre in Binding dinamico non sono disponibili informazioni prima del runtime.
- Il binding statico può avvenire utilizzando le normali funzioni mentre il binding dinamico può essere ottenuto utilizzando le funzioni virtuali.
Conclusione
Questi sono alcuni dei concetti importanti della programmazione orientata agli oggetti. Il bind si riferisce all'esecuzione del codice. Accade al momento della compilazione mentre il Dynamic Binding avviene in fase di esecuzione. Definizione, dichiarazione e ambito di validità della dichiarazione, questi sono tre pilastri importanti del vincolo statico mentre nel vincolo dinamico, il nome del legame e la durata delle questioni vincolanti.
Articoli consigliati
Questa è una guida alla rilegatura statica e alla rilegatura dinamica. Qui discutiamo l'introduzione, gli usi e i vantaggi. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più–
- Tipi di Web Hosting
- Sovraccarico e override in Java
- Direttive AngularJS
- Polimorfismo in Java
- Metodo statico JavaScript | Funzionando | Esempi