Best Practice Konstruktor mit bestehender Intanz der gleichen Klasse aufrufen

[eclipseworker]

Ich habe das Problem, dass ich einen Kontruktor gerne eine bestehende Instanz der Klasse übergeben möchte (um das Casting von einer Subklasse zu einer Subsubklasse einfacher zu machen).
So sieht das aus:

public class A{
          // Parameter von A
           public A(A oldA){
                  this.parameter1=oldA.parameter1;
                  //usw
           }
            // andere Konstruktoren und Funktionen von A
}

public class B extends A{
        public B(A oldA){
                super(oldA);
        }

        public C convertToC(Type2 cSpeficParameter){
              return new C(this, cSpeficParameter);
         }
     //Rest von B
}

public class C extends B{
       private Type cSpeficParameter;
       
      public C(A oldA, Type cSpeficParameter){
             super(oldA);
             this.cSpeficParameter=cSpeficParameter;
         }

         //Rest von C
}

Nun meine Frage A hat sehr viele Parameter, gibt es eine bessere Methode alle Werte in die neue Instanz zu kopieren als mehrere Zeilen this.parameter1=oldA.parameter1? Gibt es einen besseren Weg B zu konvertieren? Hinweis: B ist nicht überflüssig.

 

[mihe7]

gibt es eine bessere Methode alle Werte in die neue Instanz zu kopieren als mehrere Zeilen

Es gibt andere Möglichkeiten, ob diese unbedingt besser sind, musst Du entscheiden: Cloneable, Reflection, Serialisierung/Deserialisierung.

Die Methode convertToC kannst Du einfach löschen. Erstens hast Du dadurch eine zyklische Abhängigkeit, zweitens "kann" die Superklasse nicht wissen, welche Subklassen existieren. Drittens macht es keinen Unterschied, ob ich C myC = myB.convertToC(param); oder gleich C myC = new C(myB, param); schreibe: in beiden Fällen musst Du die B-Instanz und die C-Parameter kennen und wissen, dass Du eine C-Instanz haben willst.

 

[eclipseworker]

Es gibt andere Möglichkeiten, ob diese unbedingt besser sind, musst Du entscheiden: Cloneable, Reflection, Serialisierung/Deserialisierung.

Wie täte das mit Cloneable ausschauen? Reflection könnte eine ziemlich komplexe for-Schleife in der Form

public A(A oldA){
  Method sm;
 Method gm;
 Class classThis=this.getClass();
 for(String p:getClassParameter()){
    sm=class.getMethod("set"+p, getType(P));
    gm=class.getMethod("get"+p, null);
    sm.invoake(this, gm.invoke(oldA));
  }
}

Oder so ähnlich werden oder wie? Vor allem wie Mache ich getType p wenn es primitiv sein kann? Serialisierung/Deserialisierung dafür braucht man doch Speicherzugriff oder?

 

[mihe7]

Mal alle drei Varianten quick & dirty zusammengeschustert:

import java.lang.reflect.Field;
import java.io.*;

public class Test implements Cloneable, Serializable {
    private String name;
    private int value;

    public Test(String name, int value) {
        this.name = name;
        this.value = value;
    }

    public Test(Test t) {
        for (Field f : getClass().getDeclaredFields()) {
            try {
                f.setAccessible(true);
                f.set(this, f.get(t));
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    public static Test copy(Test s) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try(ObjectOutputStream dos = new ObjectOutputStream(bos)) {
            dos.writeObject(s);
            byte[] data = bos.toByteArray();
            ByteArrayInputStream bis = new ByteArrayInputStream(data);
            try(ObjectInputStream ois = new ObjectInputStream(bis)) {
                return (Test) ois.readObject();
            }
        } catch (IOException | ClassNotFoundException ex) {
            ex.printStackTrace();
            return null;
        }
    }

    @Override
    public Test clone() {
        try {
            return (Test) super.clone();
        } catch (CloneNotSupportedException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) throws Exception {
        Test test = new Test("X", 15);
        Test x = new Test(test);
        Test y = test.clone();
        Test z = Test.copy(test);

        System.out.println(x.name + ": " + x.value);
        System.out.println(y.name + ": " + y.value);
        System.out.println(z.name + ": " + z.value);
    }
}

 

[mrBrown]

Ich würde in so einem Fall nahezu immer bei einem einfachen this.y = that.x bleiben.

Wenn einem das deutlich zu viele Attribute sind, sollte man dies eher als Grund sehen, das Design noch mal zu überdenken.