Subklasse mit Superklasse initialisieren

-AbeAdapti-

Mitglied
folgende Problemstellung:
ich hab eine Superklasse und möchte sie in eine von ihm abgeleitete SubKlasse injezieren und zwar so das ich keine getter/setter oder Konstruktoren mehr ändern muss sobald die Oberklasse ein neues Attribute erhält bzw. verliert.
Bisherige Lsg: in der Oberklasse Konstruktor händisch nachbessern, das ist bei über 30 Attributen sehr pflegeaufwendig. Gibts dafür eine andere Lsg? Hab auch schon an Reflection gedacht

Java:
//Main.java
SubKlasse s = new SubKlasse(new Oberklasse());

//SubKlassenKonstruktor:
public SubKlasse(Oberklasse o) {
      super(o);
}

//OberklassenKonstruktor:
public OberKlasse(Oberklasse o) {
      this.attribute1 = o.getAttribute1();
      .....
       this.attribute2 = o.getAttribute2();
}
 

Ritchie_Fomm

Erfahrenes Mitglied
Hallo,

eine kleine schnelle Lösung dazu wäre. Die Attribute in einer Hashtable zu halten. Damit hättest du nur eine getter und setter mit Keyübergabe. Eine Arraylist oder ähnliches von vorhandenen bzw. erlaubten Attributen sollte allerdings vorhanden sein!

Grüße
R.
 

zeja

Erfahrenes Mitglied
Hmm warum sollte man das wollen?

Eine Möglichkeit ist es das ganze über Aspekte z.B. mit AspectJ oder Spring zu machen.

Direkt selber würde es so gehen:
Java:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public final class Factory implements InvocationHandler {

    private final Superclass superclass;
    private final SubClassImpl subclass;

    private Factory(Superclass superclass, SubClassImpl subclass) {
        this.superclass = superclass;
        this.subclass = subclass;
    }

    public static Subclass createInstance(Superclass impl) {
        return (Subclass) Proxy.newProxyInstance(
                Factory.class.getClassLoader( ), new Class[] {
                        Superclass.class, Subclass.class }, new Factory(impl,
                        new SubClassImpl( )));
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        try {
            return method.invoke(superclass, args);
        }
        catch (Exception e) {
        }
        try {
            return method.invoke(subclass, args);
        }
        catch (Exception e) {
        }
        return null;
    }

    public static void main(String[] args) {
        final Subclass instance = Factory.createInstance(new SuperClassImpl( ));
        ((Superclass) instance).superclassMethod( );
        instance.subclassMethod( );
    }

    public interface Superclass {
        public void superclassMethod();
    }

    public interface Subclass {
        public void subclassMethod();
    }

    public static class SuperClassImpl implements Superclass {

        public void superclassMethod() {
            System.out.println("superclassMethod");
        }
    }

    public static class SubClassImpl implements Subclass {

        public void subclassMethod() {
            System.out.println("subclassMethod");
        }
    }
}

Ist aber nicht ganz so schön.