Créer une instance à partir d'une instance de superclasse

Il est un (relativement) solution triviale!

Mettre en œuvre un constructeur en class B qui prend une instance de class A et copie les champs.

L'une des raisons qu'il ne générique solution dans la langue elle-même est la cause du problème de la profondeur de la copie.

Par exemple, si l'objet source contient d'autres Objectspar opposition à la plaine de types, ce qui serait la copie générique de l'opérateur? Il suffit de copier la référence (en donnant une copie), ou de faire des copies réelles?

Quoi alors si l'un de ces objets est un Collection? Faut-il également copie de chaque élément de la collection, trop?

La seule conclusion logique serait d'effectuer une peu profonde copie, mais alors vous n'avez pas vraiment obtenu une copie.

Si vous n'avez pas besoin de toutes les fonctionnalités d'Un, il ya aussi une option pour créer de la classe B, le stockage interne de la copie d'Une instance et de la mise en œuvre de certains sous-ensemble minimal de méthodes via l'interface C par l'utilisation de proxy à l'instance.

class A implements IC {
  int x;
  int y;

  public C() {
  ...
  }
}

class B implements IC {
  private A _a;

  public B(A a) {
    _a = a;
  }

  public C() {
  _a.C();
  }
}

...non pas parce que c'est ce que les gens devraient faire, mais plus parce que je me sentais comme un défi, voici un peu de code de test qui n'est qu'une simple copie de l'objet (à l'aide de setter et getter méthodes):

import java.lang.reflect.Method;
import org.junit.Test;
public class ObjectUtils {
@Test
public void test() {
A a = new A();
B b = new B();
a.setX(1);
a.setY(2);
this.copyProperties(a, b);
}
private void copyProperties(Object obja, Object objb) {
Method m[] = obja.getClass().getDeclaredMethods();
for(int i=0;i<m.length;i++) {
try {
String name = m[i].getName();
if(name.startsWith("get") || name.startsWith("is")) {
Class rtype = m[i].getReturnType();
String setter = name.replaceFirst("^(get|is)","set");
Class s = objb.getClass();
Method method = s.getMethod(setter,rtype);
Object[] args = new Object[1];
args[0] = m[i].invoke(obja);
method.invoke(objb,args[0]);
}
} catch(Exception e) {
e.printStackTrace();
}
}
}
class A {
int x;
int y;
/**
* @return the x
*/
public int getX() {
return x;
}
/**
* @param x the x to set
*/
public void setX(int x) {
this.x = x;
}
/**
* @return the y
*/
public int getY() {
return y;
}
/**
* @param y the y to set
*/
public void setY(int y) {
this.y = y;
}       
}
class B extends A {
int z;
/**
* @return the z
*/
public int getZ() {
return z;
}
/**
* @param z the z to set
*/
public void setZ(int z) {
this.z = z;
}
}
}

Si vous changez votre méthode pour créer B objets, vous pouvez faire ce que vous voulez l'aide d':

objB = (B) objA;
objB.z = someZ;

Cela peut même être inline, mais vous avez besoin de parenthèses:

((B) objA).z = someZ;

Si non, vous devez aller un long chemin à l'aide de constructeurs:

objB = new B(objA);
objB.z = someZ;

Dans ce cas, je vous recommande de copier les domaines de la super-classe dans la superclasse. Autre chose, si vous ajoutez un champ à qui, plus tard, vous pouvez oublier de modifier la copie plus facilement.

class A {
int x;
int y;
public A(A objA) {
x = objA.x;
y = objA.y;
}
}
class B extends A {
int z;
public B(A objA) {
super(objA);
}
}

Je préfère fusionner les membres supplémentaires de B dans A.

Vous peut le faire si vos classes A et B partagent le même package ou si les variables dans votre A classe est déclarée protected. Ensuite, vous pouvez simplement accéder aux champs de la super-classe.

class A {
protected int x;
protected int y;
}
class B extends A {
int z;
void merge(A a){
super.x = a.x; 
y = a.y;        //you do not *need* to use the super keyword, but it is a good hint to
//yourself if you read your program later and might wonder ‘where is
//that y declared?’
}
}

Useage, bien sûr, est:

objB = new B();
objB.merge(objA);
objB.z = someZ;

Je pense que le meilleur moyen est d'utiliser une méthode de fabrique de créer des B des objets à partir d'Un des objets.

class BFactory
{
public static B createB(A a)
{
B b = new B();
copy(a,b);
return b;
}
private static <X,Y> void copy(X src,Y dest) throws Exception
{
List<Field> aFields = getAllFields(src.getClass());
List<Field> bFields = getAllFields(dest.getClass());
for (Field aField : aFields) {
aField.setAccessible(true);
for (Field bField : bFields) {
bField.setAccessible(true);
if (aField.getName().equals(bField.getName()))
{
bField.set(dest, aField.get(src));
}
}
}
}
private static List<Field> getAllFields(Class type)
{
ArrayList<Field> allFields = new ArrayList<Field>();
while (type != Object.class)
{
Collections.addAll(allFields, type.getDeclaredFields());
type = type.getSuperclass();
}
return allFields;
}
}