# Frühe Bindung in Java ?



## Guest (13. Apr 2005)

Hallo zusammen !

Ich würde gerne wissen, ob es unter Java eine Möglichkeit, frühe Bindung zu erzwingen. 

Es ist auch erstmal egal, ob es Sinn machen würde oder nicht - mir geht es rein um die theoretische Möglichkeit  :wink: 

Lässt sich das vielleicht mit "final" realisieren ? 

Angenommen ich habe eine Basisklasse "MyBasis" mit der Methode "final print()" und eine davon abgeleitet Klasse MySub. 
Wenn jetzt MyBasisInstance.print() aufrufe, dann ist es egal, welcher Objekttyp denn nun hinter MyBasisInstance steht (ob MyBasis oder MySub) - es wird sowieso immer die gleiche Methode (da final) aufgerufen. 

Aber diese Idee ist glaube ich auch nicht so das Wahre  :bahnhof: ...

Bin für Denkanstöße / Lösungansätze / Lösungen aller Art dankbar  :lol: 

Gruß,

Holle


----------



## Beni (13. Apr 2005)

Nein, das ist meines Wissens nicht möglich. Das würde ja die ganze OOP unterwandern... :wink:


----------



## Illuvatar (13. Apr 2005)

Erzähl das doch mal den .net Erfindern^^

@topic: Das geht in Java glaub ich net


----------



## stev.glasow (13. Apr 2005)

:bahnhof: 


```
class MyBasis{
	public final void print(){
		System.out.println("Bin ich noch nicht ganz wach oder was ist hier los");
	}
}

class  MySub extends MyBasis{
	
}

....


MyBasis myBasisInstance; 
		
myBasisInstance = new MyBasis();
myBasisInstance.print();

myBasisInstance = new MySub();
myBasisInstance.print();
		

MySub myBasisInstance2= new MySub();
myBasisInstance2.print();
```


----------



## dyrathror (13. Apr 2005)

Anonymous hat gesagt.:
			
		

> Hallo zusammen !
> 
> Ich würde gerne wissen, ob es unter Java eine Möglichkeit, frühe Bindung zu erzwingen.
> 
> ...



Hi,

also zuerst einmal ist Java nicht für frühes Binding ausgelegt, da dies dem Konzept komplett entgegenläuft. Wie willst Du z.B. ein Interface früh binden?

Und dann hat das mit "final" schon mal gar nichts zu tun, da "final" nur ein überschreiben der Methode, ... verhindert.

Wenn Du was besonder früh binden willst, dann static verwenden. Aber auch static Blöcke und Variablen werden
erst initialisiert (und damit die dahinterstehenden Klassen geladen), wenn die Klasse in der sich der Block befindet das erste Mal genutzt wird.

Vielleicht mal mit C++ probieren   

Gruß
Stephan


----------



## Illuvatar (13. Apr 2005)

```
class A
{
  void print()
  {
    System.out.println("A");
  }
}
class B extends A
{
  void print()
  {
    System.out.println("B");
  }
}
public class Test
{
  public static void main (String[] args)
  {
    A aa = new A();
    aa.print(); //"A"
    B bb = new B();
    bb.print(); //"B"
    A ab = new B();
    ab.print(); //hier kein "A" möglich!
  }
}
```


----------



## stev.glasow (13. Apr 2005)

So stehts da aber nicht:


> Angenommen ich habe eine Basisklasse "MyBasis" mit der Methode "final print()" und eine davon abgeleitet Klasse MySub.


----------



## Illuvatar (13. Apr 2005)

Er hat ja nur gefragt ob sowas mit final möglich ist. Ist es aber auch nicht, da mit final gar nicht mehr überschrieben werden kann.


----------



## Wildcard (13. Apr 2005)

Illuvatar hat gesagt.:
			
		

> Er hat ja nur gefragt ob sowas mit final möglich ist. Ist es aber auch nicht, da mit final gar nicht mehr überschrieben werden kann.


Es geht ja auch nicht darum die Methode zu überschreiben, sondern um early binding!


----------



## Illuvatar (13. Apr 2005)

Bin ich jetzt der der noch net wach is ???:L Ohne Überschreiben is Late/Early Binding doch eh wurscht...

gn8 edenfalls


----------



## stev.glasow (13. Apr 2005)

Klar hat das was mit Überschreiben zu tun:
Hier mal n C++ Beispiel (Quelle: http://home.zhwin.ch/~frp/SwE/Slides/Klassen.PDF ) :


```
//Early binding
class Monster {
  protected:
    void Augen() {cout << ":";}
    void Nase () {cout << '-';}
    void Mund () {cout << ')';}
  public:
    void Zeigen() {
   Augen();
   Nase();
   Mund();
   cout << "\n";
  }
};

class Beisser : public Monster {
    void Mund() {cout << 'X';}
};

int main(int argc, char *argv[])
{
  Monster M;
  M.Zeigen();
  Beisser B;
  B.Zeigen(); 
  system("PAUSE");	
  return 0;
}
//  Ausgabe: 
:-)
:-)
```


```
//Late binding (wie in Java)
class Monster {
  protected:
    virtual void Augen() {cout << ":";}
    virtual void Nase () {cout << '-';}
    virtual void Mund () {cout << ')';}
  public:
    void Zeigen() {
   Augen();
   Nase();
   Mund();
   cout << "\n";
  }
};

class Beisser : public Monster {
    void Mund() {cout << 'X';}
};

int main(int argc, char *argv[])
{
  Monster M;
  M.Zeigen();
  Beisser B;
  B.Zeigen(); 
  system("PAUSE");	
  return 0;
}
//  Ausgabe: 
:-)
:-X // hier wird es mit x ausgegeben
```

Mir ist nur unklar was gast für ein Problem hat.


----------



## helium (14. Apr 2005)

> Und dann hat das mit "final" schon mal gar nichts zu tun, da "final" nur ein überschreiben der Methode, ... verhindert.





> Ohne Überschreiben is Late/Early Binding doch eh wurscht...



Und deshalb gehe ich davon aus, das finale Methoden früh gebunden werden. Es würde keinen Sinn machen sie spät zu binden.


----------



## Spacerat (14. Apr 2005)

Ich würde mal gern Erfahren was Early- bzw. Late-Binding genau bedeutet. Wenn es das ist, was ich denke, gibt es das unter Java wohl kaum, da ja nur "prä-Kompiliert" wird. Member-Variablen und Klassen werden ja in Java erst zur Laufzeit gebunden (JIT-Kompiling). Late-Binding dürfte demnach völlig ausfallen oder sehe ich das Falsch? Early-Binding erledigt dann eben nur "final".

Ich glaube das kann man auch mit 'nem kleinen Experiment belegen. Man erstelle zwei Klassen mit einegen Methoden. Eine Klasse ruft eine Methode der jeweils anderen auf.
kompilieren... ausführen. Nun speichert man eine vorkompilierten Klassen an einem anderen Ort, Löscht aus einer Klasse eine Methode und aus der jeweils anderen den Aufruf auf diese (Damit erfolgreich Kompiliert wird). Anschliessend kopiert man die zuletzt gesicherte Klasse welche den Methodenaufruf ausführt zurück. Das Programm wirft beim starten nun einen hübschen Error.

cu Spacerat


----------



## stev.glasow (14. Apr 2005)

> Member-Variablen und Klassen werden ja in Java erst zur Laufzeit gebunden.


Genau das bedeutet Late-Binding. Denke ich   

Early-Binding  wäre das Binden zur 'Compilierzeit'.


----------



## Bleiglanz (15. Apr 2005)

stevg hat gesagt.:
			
		

> > Early-Binding  wäre das Binden zur 'Compilierzeit'.



und genau das ist in Java ziemlich sinnlos, weil zur Compilierzeit z.B. Interfaces ausreichen in die erst zur Laufzeit "konkrete" Implementierungen eingesetzt werden...


```
Object o = getStuffFromDeInternetViaRMIoderSonstwas();
(Down o).methodeAusDownInterface();
```

in Java ist alles automatisch "Late-Binding", die paar Fälle in denen Early-Binding möglich wäre hat man beim Sprachentwurf (sinnvollerweise) ignoriert...


----------



## helium (16. Apr 2005)

Wenn zur Compilezeit feststeht, welche Methode aufgerufen werden muss (wie es bei finalen Methoden der Fall ist) kann der Compiler sie auch früh binden.
Theoretisch könnte auch früh gebunden werden, wenn sicher ist, das keine weitere Klasse von der betroffenen Klasse abgeleitet ist.


----------



## Beni (16. Apr 2005)

Nein helium: du kannst auch nach der Kompilierung die *.class Dateien ersetzen. Und damit kann ein final wieder verschwinden...


----------



## helium (17. Apr 2005)

Der JIT hat immernoch die Möglichkeit.


----------



## Bleiglanz (18. Apr 2005)

helium hat gesagt.:
			
		

> Der JIT hat immernoch die Möglichkeit.



der JIT ist aber ziemlich spät dran und "late", davon reden wir doch!


----------



## helium (22. Apr 2005)

Frühe Bindung bedeutet, dass Direkt die "Adresse" der Methode verwendet wird, späte Bindung, dass ine weitere Indirektion dazwischen liegt, über eine Methodentabelle.


----------

