Original von PD
public Object dosomething(Object o, Class c)
{
Object ret = c.newInstance();
ret=((c.getName) o).machwas();
return ret;
}
Also o gehört zur Klasse c?! Warum benutzt du nicht einfach ein Interface
public interface A {
B machwas();
}
Und schreibst dann:
public B dosomething(A o)
{
A ret = (A) o.getClass().newInstance();
ret=((A) o).machwas();
return ret;
}
Der Compiler muss ja schliesslich wissen, um was für einen Typ es sich hier handelt, damit die Funktion machwas() aufgerufen werden kann. Zur Laufzeit kann das AFAIK nur mit wirklich hässlichen Reflectionkonstrukten, die sehr inperformant sind erledigt werden.
Aber warum in Gottes Namen erzeugst du erst ein Objekt um es gleich wieder zu überschreiben ??? :-)
Original von PD
Ein zusätzliches Problem stellt der Aufruf c.newInstance() dar, wenn die Klasse keinen Standardkonstruktor besitzt.
Man kann auch Parameter an Konstruktoren übergeben. Aber auch dies quält den Code mit Reflection und sollte eher vermieden werden.
Sinnvoller ist es, die Klasse mit parameterlosen Konstruktoren auszustatten, die sinnvolle Defaultwerte bereitstellen und dann mit settern die Eigenschaften konkret zu setzen.
Greift man mit Reflection auf Parameterbehaftete Konstruktoren zu, so bekommt man keinen Compilerfehler, wenn man die Signatur ändert. Das kann äusserst ärgerlich sein, wenn dann in dem Codefragment, dass einmal alle 1000 Jahre aufgerufen wird, ein Laufzeitfehler durch soetwas auftritt.