Statische Bindung und dynamische Bindung

Question

Ich bin wirklich verwirrt über dynamische Bindung und statische Bindung. Ich habe gelesen, dass das Bestimmen des Typs eines Objekts zur Kompilierzeit statische Bindung genannt wird und das Bestimmen zur Laufzeit als dynamische Bindung bezeichnet wird.

Was unten im Code passiert:

statische oder dynamische Bindung Bindung?
Welche Art von Polymorphie zeigt dies?

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(); 
} 

Answer 1

Ihr Beispiel ist dynamische Bindung, weil während der Laufzeit bestimmt wird, was die Art der a ist, und die entsprechende Methode aufgerufen .

nun annehmen, dass Sie die folgenden zwei Methoden haben auch:

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

Auch wenn Sie Ihre main zu

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

diese Animal is eating druckt ändern, da der Aufruf an callEat verwendet statische Bindung, und der Compiler weiß nur, dass a vom Typ Animal ist.

Answer 2

Ihr aktueller Code ausgegeben Animal is eating

jedoch in der Hauptklasse, wenn Sie ein Objekt vom Typ Dog erstellt und es zu Animal zugewiesen, dann wird die Ausgabe Dog is eating aufgrund dynamischer Bindung sein.

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 
} 

Obwohl a deklariert wird als Animal es auf ein Objekt vom Typ zeigt Dog. Zur Laufzeit wird der Objekttyp ermittelt und die entsprechende Methode eat() aufgerufen.

Eine Möglichkeit, daran zu denken, ist method overloading ist statisch gebunden und method overriding ist dynamisch gebunden.

Answer 3

Fall 1:

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

Fall 2:

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

Hier ist sowohl dynamischer bind, weil während der Zeit der Typ des Objekts kompiliert bestimmt wird, aber während der Laufzeit basierend auf der Instanz des Objekt, zugeordnet ist, wird die entsprechende eat-Methode von der JVM dynamisch gebunden.

Im ersten Fall wird die Tierklassen-Essensmethode genannt, während in der zweiten die Hundeklasse essen aufgerufen wird, da dem Tierobjekt eine Hundeinstanz zugewiesen wird. Die Instanz von Hund ist ebenfalls eine Tierinstanz. Das heißt, Sie können es als "ist ein" Relation ein Hund ist ein Tier.So hier die Art des Objekts wird als Hund zur Laufzeit bestimmt und JVM bindet dynamisch die essen Methode der Hundeklasse.

prüfen diese Links zu

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

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

Answer 4

Das hängt wirklich von Überlastung und zwingenden, wenn Sie so etwas wie dies tun:

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"); 
    } 
} 

dann in der Hauptklasse:

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

das Ergebnis in den beiden Fällen wird : Animal is eating

aber lassen Sie es etwas drehen, lassen Sie uns th ist: dann

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

:

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

dann in der Hauptklasse:

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

jetzt sollte das Ergebnis sein:

Animal is eating 
Dog is eating 

ist dies, weil bindet Überlastung an Kompilierzeit "statische Bindung" während zwingende bindet während der Laufzeit „dynamische Bindung“

Answer 5

Für nicht-statische Funktionen verwenden Sie statische Bindung, wenn die Funktion nicht virtuell, das heißt das Schlüsselwort final auf sie ausgeübt wird und/oder die Funktion ist private. final bedeutet, dass die Funktion nicht geändert werden kann und das Schlüsselwort private impliziert, dass es nur Klassenbereich hat. Andernfalls wird dynamische Bindung verwendet.

Für statische Funktionen wird immer die statische Bindung verwendet. Wenn ein Typ A übergeben wird, wird die Methode A ausgeführt, unabhängig davon, wo A verweist.

Answer 6

Kontrolle dieser Mitarbeiter Klasse abstrakt earning() Funktion und jede Klasse hat deferent toString() Implementierung

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()); 
} 

Alle Anrufe Methode toString und earnings bei execution time aufgelöst werden, auf der Grundlage der type of the object auf die currentEmployee bezieht,

Dieser Prozess ist als dynamic binding oder late binding

01 bekannt

Referenz: Java™ How To Program (Early Objects), Tenth Edition