2009-03-13 7 views
23

I tempi di binding possono essere classificati tra due tipi: statico e dinamico. Qual è la differenza tra l'associazione statica e quella dinamica?Qual è la differenza tra rilegatura statica e dinamica?

Potrebbe fornire un rapido esempio di ciascuno per illustrarlo ulteriormente?

+1

Se si tratta di compiti a casa, sarà meglio chiedere per una critica della vostra risposta pianificata; non per la risposta a titolo definitivo. –

+2

@Daniel L, l'ho contrassegnato come compito. Questa non è direttamente la domanda nei miei compiti. Devo classificare un gruppo di cose come statiche o dinamiche e sto cercando di chiarirmi la testa che è attraverso questa domanda. Se le persone vogliono rispondere lo faranno. – KingNestor

+0

@KingNestor: Sì, ho visto che erano compiti a casa;] Vedo cosa intendi ora. –

risposta

26

Nei termini più generali, associazione statica significa che i riferimenti sono risolti in fase di compilazione.

Animal a = new Animal(); 
a.Roar(); // The compiler can resolve this method call statically. 

legame dinamico significa che i riferimenti sono risolti in fase di esecuzione.

public void MakeSomeNoise(object a) { 
    // Things happen... 
    ((Animal) a).Roar(); // You won't know if this works until runtime! 
} 
+1

Non vero, se oggetto a = nuovo Animale(); –

+0

È vero, anche se penso che fosse ovvio che stavo cercando di essere generale. L'ho regolato un po '. –

+3

Il tuo ultimo esempio è ancora un binding statico. Il typecast potrebbe avere o meno successo, ma se il typecast riesce, anche se 'Roar' è un metodo virtuale, il codice sarà associato allo slot vtable staticamente associato a' Animal.Roar() '. L'associazione dinamica si verifica solo in C# quando si utilizza il nuovo tipo 'dynamic', oppure usando Reflection (ad esempio' a.GetType(). GetMethod ("Roar"). Invoke (a, null) '). Quest'ultimo funzionerebbe con qualsiasi tipo che implementa un metodo senza parametri chiamato 'Roar' e restituisce l'implementazione più derivata (anche se un'implementazione di base non è virtuale). – supercat

6

Dipende quando avviene il legame: al momento della compilazione (statico) o in fase di esecuzione (dinamica). Il collegamento statico viene utilizzato quando si chiama un metodo di classe semplice. Quando inizi a gestire gerarchie di classi e metodi virtuali, il compilatore inizierà a utilizzare i cosiddetti numeri VTABLE s. A quel tempo il compilatore non sa esattamente quale metodo chiamare e deve attendere il runtime per capire il metodo giusto da invocare (ciò avviene tramite VTABLE). Questo è chiamato legame dinamico.

Vedere l'articolo di Wikipedia su Virtual tables per ulteriori dettagli e riferimenti.

-4

Il binding eseguito in fase di compilazione è un collegamento statico e il binding eseguito in fase di esecuzione è il collegamento dinamico. Nel tipo di dati di binding statico del puntatore viene risolto il metodo richiamato.Ma il tipo di dati di binding dinamico dell'oggetto risolve il metodo richiamato .

-4

* Tempo di esecuzione: - * binding delle variabili ai suoi valori, nonché il legame della variabile particolare posizione di memorizzazione al momento dell'esecuzione è chiamato tempo di esecuzione vincolanti.

IT possono essere di due TIPI

  1. in entrata a un sottoprogramma.
  2. In punti arbitrari durante il tempo di esecuzione.

tempo di compilazione rilegatura: - (traduzione in tempo) E 'composta da quanto segue.

  1. Collegamento scelto dal programmatore.
  2. Associazione scelta dal traduttore.
  3. Rilegatura scelta dal caricatore.
1

Mi sono imbattuto in questa risposta perfetta di un utente quora "Monis Yousuf". Lui lo spiega perfettamente. Lo sto mettendo qui per gli altri.

Il binding è principalmente un concetto di programmazione orientata agli oggetti correlato al polimorfismo.

In primo luogo, capire che cos'è il polimorfismo . I libri dicono che significa "un nome e più forme". Vero, ma troppo astratto. Facciamo un esempio di vita reale.Andate da un "dottore", un medico può essere un oculista, specialista ORL, neurochirurgo, omeopata ecc.

Qui, un "dottore" è un nome e può avere più tipi; ognuno svolge la propria funzione. Questo è il polimorfismo nella vita reale.

Sovraccarico funzione: Questo concetto rappresenta il collegamento statico. L'overloading delle funzioni può essere approssimativamente definito come, due o più metodi (funzioni) che hanno lo stesso nome ma diverse firme (incluso numero di parametri, tipi di parametri, tipi di ritorno diffuso) sono chiamati metodi (o funzioni) sovraccaricati.

Supponiamo di dover calcolare l'area di un rettangolo e un cerchio. Vedi sotto il codice: -

class CalculateArea { 

    private static final double PI = 3.14; 

    /* 
     Method to return area of a rectangle 
     Area of rectangle = length X width 
    */ 
    double Area(double length, double width) { 
     return (length * width); 
    } 

    /* 
     Method to return area of circle 
     Area of circle = π * r * r 
    */ 
    double Area(double radius) { 
     return PI * radius * radius; 
    } 
} 

Nel codice di cui sopra, ci sono due metodi "area" con parametri diversi. Questo scenario si qualifica come sovraccarico della funzione.

Ora, venendo alla vera domanda: come si lega questo statico?

Quando si chiama una delle funzioni sopra indicate nel codice, è necessario specificare i parametri che si stanno passando. In questo scenario, si passa uno:

  • due parametri di tipo double [che chiamerà il primo metodo, a calcolare sono di un rettangolo]
  • parametro singolo di tipo double [che chiamerà il secondo metodo, per calcolare l'area di un cerchio]

Poiché, in fase di compilazione, il compilatore java può capire, quale funzione chiamare, è il binding in fase di compilazione (o STATIC).

Funzione Overriding: la funzione di override è un concetto che viene mostrato in ereditarietà. Può essere approssimativamente definito come: quando c'è un metodo presente in una classe genitore e la sua sottoclasse ha anche lo stesso metodo con la firma SAME, si chiama override della funzione. [C'è dell'altro, ma per semplicità, ho scritto questa definizione] Sarà più facile capire con il codice sottostante.

class ParentClass { 
    int show() { 
     System.out.println("I am from parent class"); 
    } 
} 

class ChildClass extends ParentClass{ 
    int show() { 
     System.out.println("I am from child class"); 
    } 
} 

class SomeOtherClass { 
    public static void main (String[] s) { 
     ParentClass obj = new ChildClass(); 
     obj.show(); 
    } 
} 

Nel codice precedente, il metodo show() si sta sovrascritti come la stessa firma (e il nome) è presente in entrambe le classi padre e figlio.

Nella terza classe, SomeOtherClass, una variabile di riferimento (obj) di tipo ParentClass contiene l'oggetto di ChildClass. Successivamente, il metodo show( viene chiamato dalla stessa variabile di riferimento (obj).

Ancora una volta, la stessa domanda: come è questo legame dinamico?

In fase di compilazione, il compilatore verifica che la variabile di riferimento sia di tipo ParentClass e verifica se il metodo show() è presente in questa classe. Una volta verificato, la compilazione ha esito positivo.

Ora, quando i programmi CORRISPONDONO, vede che l'oggetto è di ChildClass e quindi esegue il metodo ChildClass . Poiché questa decisione viene eseguita in RUNTIME, è denominata Associazione dinamica (o Polymorphism in fase di esecuzione).

Link per risposta originale