Thomas Thiele
2007-07-20 12:27:58 UTC
Hallo,
ich wollte mal Nachfragen, welche Nachteile oder besser Fehler ihr in
Java in Vergleich zu anderen Programmiersprachen seht. Ich meine nicht
Sachen die in Java und der Philosophie begründent liegen,
sondern Eigenschaften, die es unmöglich machen etwas bestimmtes zu
programmieren.
C++ Programmierer mögen Operatorüberladung und Mehrfachvererbeung
vermissen. Das meine ich z.B.
nicht. Denn beide Dinge kann man mehr oder weniger hübsch mit anderen
Konstrukten lösen.
Auch das Java als Programmierparadigma Objektorientierung (scheinbar)
erzwingt ist keine Einschränkung in dem Sinne.
Was ich meine sind harte Einschränkungen die es unmöglich machen etwas
bestimmtes zu programmieren oder wirklich zu schlimmeren Fehlern
führen.
Meine Beispiele:
1. Zerstörung von Objekten nicht "just in time".
--------------------------------------------------------------------
Garbagecollection und die Nichtnotwenigkeit sich um Aufräumarbeiten zu
kümmern mag ein Vorteil sein. Aber die Java-Garbagecollection
garantiert eben nicht - wie bei Python beispielsweise - die sofortige
Zerstörung (bzw. wenigstens den sofotigen Aufruf eines Destruktors)
wenn das Objekt den Sichtbarkeitsbereich verlässt.
D.h. durch verspätete destruierung bzw. der Unmöglichkeit einer
automatischen Destruierung entstehen Ressourcenleaks! Entgegen dem
Java-Versprechen...
2. Kein impliziter Copycontructor.
------------------------------------------------
Aus Bibliothek gibt es eine Klasse: (aufs wesentliche gekürzt)
class A{
private int a;
int getA(){return a;}
}
Also unspannend. Ein simpler Datencontainer.
Jetzt benöge ich dazu eine Erweiterung, weil ich zusätzlich Daten
brauche:
class B extends A{
private int b;
int getB(){return b;}
void setB(int b){ this.b = b;}
}
Sieht auch unspektakulär aus.
Die Probleme beginnen wenn ich nur ein A Object bekomme aber ein B
Objekt für eigene Zwecke brauche:
Z.B.
// get A from the library function, that can only return an A
A a = libClass.createA();
// now I need the B...
B b = new B(a); //geht nicht!!!!!!!*
myClass.machwasmitB(b);
*ja, ja, syntaktisch geht das schon, ich kann einen solchen
Konstruktor schreiben.
B(A a){}
Aber was habe ich gekonnt? Mein B Objekt was per Vererbung ein A
Object _ist_ wird niemals
die private Variable a übernehmen.
3. Aufruf einer Funktion einer höheren Basisklasse nicht möglich
---------------------------------------------------------------------------------------------
Kein super.super.function(); möglich. Das ist Mist.
class A(){
void function1(){ /* ....*/};
void function2(){ /* ....*/};
}
class B extends A(){
void function2(){
/* ...was B-spezifisches... */
super.function2(); //die benötigte A funktionalität
};
void function3(){/*....*/}
}
class C extends B(){
void function2(){
/* ...was C-spezifisches... */
//super.function2(); //nein!!!!, ich will nix B-spezifisches!!!!
super.super.function2(); //aber das geht nicht
}
};
Fällt euch noch mehr ein?
ich wollte mal Nachfragen, welche Nachteile oder besser Fehler ihr in
Java in Vergleich zu anderen Programmiersprachen seht. Ich meine nicht
Sachen die in Java und der Philosophie begründent liegen,
sondern Eigenschaften, die es unmöglich machen etwas bestimmtes zu
programmieren.
C++ Programmierer mögen Operatorüberladung und Mehrfachvererbeung
vermissen. Das meine ich z.B.
nicht. Denn beide Dinge kann man mehr oder weniger hübsch mit anderen
Konstrukten lösen.
Auch das Java als Programmierparadigma Objektorientierung (scheinbar)
erzwingt ist keine Einschränkung in dem Sinne.
Was ich meine sind harte Einschränkungen die es unmöglich machen etwas
bestimmtes zu programmieren oder wirklich zu schlimmeren Fehlern
führen.
Meine Beispiele:
1. Zerstörung von Objekten nicht "just in time".
--------------------------------------------------------------------
Garbagecollection und die Nichtnotwenigkeit sich um Aufräumarbeiten zu
kümmern mag ein Vorteil sein. Aber die Java-Garbagecollection
garantiert eben nicht - wie bei Python beispielsweise - die sofortige
Zerstörung (bzw. wenigstens den sofotigen Aufruf eines Destruktors)
wenn das Objekt den Sichtbarkeitsbereich verlässt.
D.h. durch verspätete destruierung bzw. der Unmöglichkeit einer
automatischen Destruierung entstehen Ressourcenleaks! Entgegen dem
Java-Versprechen...
2. Kein impliziter Copycontructor.
------------------------------------------------
Aus Bibliothek gibt es eine Klasse: (aufs wesentliche gekürzt)
class A{
private int a;
int getA(){return a;}
}
Also unspannend. Ein simpler Datencontainer.
Jetzt benöge ich dazu eine Erweiterung, weil ich zusätzlich Daten
brauche:
class B extends A{
private int b;
int getB(){return b;}
void setB(int b){ this.b = b;}
}
Sieht auch unspektakulär aus.
Die Probleme beginnen wenn ich nur ein A Object bekomme aber ein B
Objekt für eigene Zwecke brauche:
Z.B.
// get A from the library function, that can only return an A
A a = libClass.createA();
// now I need the B...
B b = new B(a); //geht nicht!!!!!!!*
myClass.machwasmitB(b);
*ja, ja, syntaktisch geht das schon, ich kann einen solchen
Konstruktor schreiben.
B(A a){}
Aber was habe ich gekonnt? Mein B Objekt was per Vererbung ein A
Object _ist_ wird niemals
die private Variable a übernehmen.
3. Aufruf einer Funktion einer höheren Basisklasse nicht möglich
---------------------------------------------------------------------------------------------
Kein super.super.function(); möglich. Das ist Mist.
class A(){
void function1(){ /* ....*/};
void function2(){ /* ....*/};
}
class B extends A(){
void function2(){
/* ...was B-spezifisches... */
super.function2(); //die benötigte A funktionalität
};
void function3(){/*....*/}
}
class C extends B(){
void function2(){
/* ...was C-spezifisches... */
//super.function2(); //nein!!!!, ich will nix B-spezifisches!!!!
super.super.function2(); //aber das geht nicht
}
};
Fällt euch noch mehr ein?
