Legame statico e rilegatura dynamic

Sono davvero confuso riguardo al binding dinamico e al binding statico. Ho letto che determinare il tipo di un object in fase di compilazione è chiamato associazione statica e determinarlo in fase di esecuzione è chiamato associazione dynamic.

Cosa succede nel codice qui sotto:

Associazione statica o associazione dynamic?
Che tipo di polimorfismo fa questo spettacolo?

class Animal { void eat() { System.out.println("Animal is eating"); } } class Dog extends Animal { void eat() { System.out.println("Dog is eating"); } } public static void main(String args[]) { Animal a=new Animal(); a.eat(); } 

Il tuo esempio è l’ associazione dynamic , poiché in fase di esecuzione viene determinato quale sia il tipo di a , e viene chiamato il metodo appropriato.

Supponiamo ora di avere i seguenti due metodi:

 public static void callEat(Animal animal) { System.out.println("Animal is eating"); } public static void callEat(Dog dog) { System.out.println("Dog is eating"); } 

Anche se cambi la tua main a

 public static void main(String args[]) { Animal a = new Dog(); callEat(a); } 

questo stamperà Animal is eating , perché la chiamata a callEat usa il binding statico , e il compilatore sa solo che è di tipo Animal .

Questo dipende molto da sovraccaricare e sovrascrivere se hai fatto qualcosa del genere:

 public class Animal{} public class Dog extends Animal{} public class AnimalActivity{ public void eat(Animal a){ System.out.println("Animal is eating"); } public void eat(Dog d){ System.out.println("Dog is eating"); } } 

quindi nella class principale:

 public static void main(String args[]) { Animal a=new Animal(); Animal d=new Dog(); AnimalActivity aa=new AnimalActivity(); aa.eat(a); aa.eat(d); } 

il risultato nei due casi sarà: l’ Animal is eating

ma lasciatelo girare, lascia che questo:

 public class Animal{ public void eat(){ System.out.println("Animal is eating"); } } 

poi:

 public class Dog extends Animal{ public void eat(){ System.out.println("Dog is eating"); } } 

quindi nella class principale:

 public static void main(String args[]){ Animal d=new Dog(); Animal a=new Animal(); a.eat(); d.eat(); } 

ora il risultato dovrebbe essere:

 Animal is eating Dog is eating 

questo perché l’overloading si lega in fase di compilazione “binding statico” mentre overriding si lega in fase di esecuzione “dynamic binding”

Il tuo codice attuale produrrà Animal is eating

Tuttavia, nella tua class principale, se hai creato un object di tipo Dog e lo hai assegnato ad Animal , il tuo risultato sarà Dog is eating causa del legame dinamico.

 public static void main(String args[]) { Animal a = new Dog(); // An object of Dog is assigned to Animal a.eat(); // Dynamically determines which eat() method to call } 

Anche se a viene dichiarato come Animal , indica un object di tipo Dog . Quindi, in fase di esecuzione, il tipo di object viene determinato e viene chiamato il metodo eat() appropriato.

Un modo per pensarci è method overloading è staticamente vincolato e l’ method overriding è vincolato dynamicmente.

Per le funzioni non statiche, si utilizza il collegamento statico ogni volta che la funzione non è virtuale, vale a dire che la parola chiave final viene applicata e / o la funzione è private . final implica che la funzione non può essere modificata e la parola chiave private implica che ha solo un ambito di class. In caso contrario, viene utilizzato il collegamento dinamico.

Per le funzioni statiche, viene sempre utilizzato il collegamento statico. Se viene passato un tipo A , verrà eseguito il metodo di A, indipendentemente da dove i riferimenti A

Caso 1:

 Animal a =new Animal(); a.eat(); 

Caso 2:

 Animal a=new Dog(); a.eat(); 

Qui entrambi sono bind dinamici perché durante il tempo di compilazione viene determinato il tipo dell’object, ma in fase di esecuzione in base all’istanza l’object a cui è assegnato il metodo di alimentazione corrispondente viene associato dynamicmente dalla JVM.

Nel primo caso viene chiamato il metodo mangia class animale, mentre nel secondo la class del cane mangia viene chiamata mentre all’object Animale viene assegnata un’istanza Dog. L’istanza di Cane è anche un’istanza di animale. Cioè puoi prenderlo come ” è una ” relazione un cane è un animale. Qui il tipo di object è determinato come cane in fase di esecuzione e JVM lega dynamicmente il metodo di mangiare della class del cane.

Controlla anche questo link

http://www.javatpoint.com/static-binding-and-dynamic-binding

http://www.coderanch.com/t/386124/java/java/Static-Binding-Dynamic-Binding

verificare che questa class di dipendenti abbia la funzione earning() astratta e che ogni class abbia un’implementazione toString() deferente

 Employee[] employees = new Employee[4]; // initialize array with Employees employees[0] = new SalariedEmployee(); employees[1] = new HourlyEmployee(); employees[2] = new CommissionEmployee(); employees[3] = new BasePlusCommissionEmployee(); for (Employee currentEmployee : employees){ System.out.println(currentEmployee); // invokes toString System.out.printf("earned $%,.2f%n", currentEmployee.earnings()); } 

Tutte le chiamate al metodo toString e alle earnings vengono risolte al execution time , in base al type of the object a cui fa riferimento il dipendente corrente,

Questo processo è noto come dynamic binding o late binding

riferimento: Java ™ How To Program (Early Objects), Decima edizione