# statische,dynamische Bindung



## Han (16. Jan 2006)

Hallo....was genau ist statische,dynamische Bindung?

Wann wird sie angewandt....in unserem Skript steht dazu zwar was, aber ich kann mir nicht wirklich darunter was vorstellen......benutzt die der Compiler wenn ich z.b. eine Testklasse zum Laufen bringen will.....und der Compiler greift dann wenn ich Verebung in meinem Programm angewandt hab auf die Art auf die Methoden zu? 

im Skript:

statische Bindung (frühe Bindung)
Bindung der Methode erfolgt während der Übersetzung durch den Compiler

dynamische Bindung (späte Bindung)
haben unterschiedliche Objekte verschiedene Methoden gleichen Namens so wird beim Aufruf des Objekts zur Laufzeit  anhand der Typsignatur die passende Methode gewählt.

Was ist das genau? Kann mir wer eine bessere Erklärung geben?

mfg,
Hannes


----------



## SlaterB (16. Jan 2006)

wann immer du an einem Objekt eine Operation aufrufst,
kann der Compiler zum Kompilierzeitpunkt nicht wissen, was das später zur Laufzeit für Folgen haben wird,

denn jede Klasse kann vererbt werden, eine Variable von der Klasse X also auch ein Objekt von der Klasse Y enthalten die von X erbt, 
falls in Y die Operation überschrieben ist, dann wird eben deren Code ausgeführt,

eine Ausnahme sind vielleicht als final deklarierte Klassen/ Operationen

-----------

anders sieht es bei statischen Operationen einer Klasse aus, vielleicht auch bei privaten Objektoperationen oder noch anderen Spezialfällen an denen Polymorphie nicht auftreten kann,
dann weiß der Compiler schon beim Übersetzten welche Code folgt und kann den direkt verlinken statt die Entscheidung auf den Laufzeitzeitpunkt zu verschieben


----------



## Guest (17. Jan 2006)

Han hat gesagt.:
			
		

> Hallo....was genau ist statische,dynamische Bindung?
> 
> ...
> im Skript:
> ...



Die Erklärung im Script für dynamische Bindung ist zumindest verwirrend wenn nicht sogar falsch!

Ich würde es mal anders formulieren:

1. Hat eine KLASSE verschiedene Methoden gleichen Namens (overloading), so wird bei
    Aufruf der METHODE anhand der Typsignatur die passende Methode z.Z.
    der Übersetzung ausgewählt (frühe Bindung)

2. Ist ein Objekt Instanz einer Subklasse einer anderen Klasse und überschreibt die Subklasse
    die GLEICHE Methode der Superklasse (gleiche Typsignatur) so wird bei Aufruf dieser Methode
    diejenige aufgerufen, die in der Klasse der REALEN Instanz definiert wurde; unabhängig davon
    nach welcher Klasse das Objekt deklariert wurde (dynamische Bindung).

Da die letzte Beschreibung ist auch nicht gerade verständlich ist :-( gebe ich mal 2 Beispiele.

(B1)


```
public void methode(int i)  // Methode 1
public void methode(long i)  // Methode 2
```

xxx.methode(42) // ruft Methode 1 auf
xxx.methode(42L) // ruft Methode 2 auf

(B2)


```
abstract class Figur {
  abstract public double fläche();
}

class Kreis extends Figur {
  double radius;
  public Kreis(double radius) {this.radius = radius;}
  public double fläche() {return Math.PI * radius * radius;}
}

class Quadrat extends Figur {
  double seite;
  public Quadrat(double seite) {this.seite = seite;}
  public double fläche() {return seite*seite;}
}

public class Main {
  public static void main(String[] args) {
    Figur[] figuren = new Figur[2];
    figuren[0] = new Kreis(5);
    figuren[1] = new Quadrat(5);
    System.out.println(figuren[0].fläche());   // gibt 78.53981633974483 aus
    System.out.println(figuren[1].fläche());   // gibt 25.0 aus
  }
}
```
CU
Leroy42
	
	
	
	





```

```


----------



## Bleiglanz (17. Jan 2006)

> dynamische Bindung (späte Bindung)
> haben unterschiedliche Objekte verschiedene Methoden gleichen Namens so wird beim Aufruf des Objekts zur Laufzeit anhand der Typsignatur die passende Methode gewählt.


ist doch irgendwie TOTAL irreführend

-> es geht nicht um den "gleichen Namen"
-> und es geht nicht primär um "anhand der Typsignatur"

sondern es geht um Objekte, deren Identität für den Compiler zur Übersetzungszeit nicht bekannt ist

```
public void leicht(Object o){
         System.out.println(o.toString());
}
```
der Compiler kann überhaupt nichts "binden", weil er nicht weiss, welches toString verwendet werden soll

wenn man das mit einer Instanz einer Klasse aufruft (die aber leider erst übermorgen programmiert wird), dann hängt eben alles davon ab, ob diese "toString" überschreibt oder nicht

deshalb kann die JVM (und nicht der Compiler) erst zur Laufzeit entscheiden (anhand der "übergebenen Objektinstanz") welche Methode aufgerufen werden soll

deshalb "dynamisch", und es trifft alle nicht als final deklarierten Methoden (hat gar nix mit "Namen" oder "Signatur" zu tun), und ich bin mir nichtmal sicher, ob final Methoden statisch gebunden werden?


----------



## Han (18. Jan 2006)

Aha...bei der dynamischen Bindung geht es also um Methoden die in den Subklassen bzw. Superklasse die gleiche Typsignatur aufweisen aber eine unterschiedlichen Wert,zugeschnitten auf die Subklasse, ausgeben. 

 figuren[0] = new Kreis(5);

Bei dieser Zuweisung kann ich ja mit  figuren[0].methode() nur die Methoden und Variablen welche ich in der Superklasse figur definiert habe aufrufen, aber die die ich aufrufen kann sind dann trotzdem die von der Subklasse....und dass das die JAVA Virtual Machine kapieren kann braucht man dynamische Bindung oder?

mfg,
Hannes


----------

