Constructing subclasses from superclass instance

[Michael Diamond]

I would like to be able to create a subclass instance from an existing base class in a generic way. The generic part is where I'm having trouble.

package app.business.logic;
import app.common.JavaUtil;
public class BaseClass
{
    protected foo;
    public BaseClass(baseClass base)
    {
        JavaUtil.setObjectFields(base, this);
    }
    ...
}
 
package app.business.logic;
public class SubClass extends BaseClass
{
    public SubClass(BaseClass base)
    {
        super(base);
    }
    ...
}
 

package app.common;
public class JavaUtil
{
    public static void setObjectFields(Object origObj, Object newObj)
        throws IllegalAccessException
    {
        Field  fields[];
        Class  curClass = origObj.getClass();
        
        if (!curClass.isAssignableFrom(newObj.getClass()))
        {
            throw new IllegalArgumentException("New object must be the same class or a subclass of original");
        }
        
        // Spin through all fields of the class & all its superclasses
        do
        {
            fields = curClass.getDeclaredFields();
    
            for (int i = 0; i < fields.length; i++)
            {
                fields[i].set(newObj, fields[i].get(origObj));
            }
            curClass = curClass.getSuperclass();
        }
        while (curClass != null);
    }
}

The problem is that JavaUtil.setObjectFields() is not part of the same package as the objects so it will not have access to any non-public fields. Of course I'm not going to declare all my instance fields public, but I don't want to have to copy/paste the setObjectFields() code into each one of my objects either.

Suggestions?

[Maulin Vasavada]

Hi Michael,

I'm not sure why you would need such a functionality but if you put the setObjectFields() method in the Base Class as,

public void setObjectFields(Object origObj)
        throws IllegalAccessException
    {
        Field  fields[];
        Class  curClass = origObj.getClass();
        
        if (!curClass.isAssignableFrom(this.getClass()))
        {
            throw new IllegalArgumentException("New object must be the same class or a subclass of original");
        }
        
        // Spin through all fields of the class & all its superclasses
        do
        {
            fields = curClass.getDeclaredFields();
    
            for (int i = 0; i < fields.length; i++)
            {
                fields[i].set(this, fields[i].get(origObj));
            }
            curClass = curClass.getSuperclass();
        }
        while (curClass != null);
    }

Shouldn't it work? This is because the second argument "always" is THIS object as you define it in the BaseClass's constructor so if you put the method inthe BaseClass it would be automatically inherited to child classes and you can call it by giving any arguments of valid BaseClass Child from any other valid BaseClass's child.

e.g.
if you had two children of BaseClass, Child1 and Child2
you can call,
Child1.setObjectFields(Child2); which will copy all BaseClass defined fields from Child2 to Child1 object.

Hope I understood your question.

Regards,
Maulin

[Ilja Preuss]

fields[i].setAccessible(true);

[Maulin Vasavada]

Hi Ilja,

Can you see what I am suggesting would work or not? Its interesting question.

And I would love to know if I got the picture correctly and if we can avoid even creating JavaUtil's method setObjectFields() when we can really use inheritance power.

Regards,
Maulin

[Maulin Vasavada]

Okay...finally I had to write the code,

// Base.java
package test;
 
import java.lang.reflect.Field;
 
/**
 * @author maulin
 */
public class Base {
    protected int i;
    int j;
    
    protected Base() {
        i=10;
        j=20;
    }
    public Base(Base origObj) {
        try {
            setObjectFieldsFrom(origObj);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    
    public String toString() {
        return "i="+i+",j="+j;
    }
    
    protected void setObjectFieldsFrom(Base origObj)
    throws IllegalAccessException {
        Field  fields[];
        Class  curClass = origObj.getClass();
        
        if (!curClass.isAssignableFrom(this.getClass()))
        {
            throw new IllegalArgumentException
            ("New object must be the same class or a subclass of original");
        }
        
        // Spin through all fields of the class & all its superclasses
        do
        {
            fields = curClass.getDeclaredFields();
            
            for (int i = 0; i < fields.length; i++)
            {
                fields[i].set(this, fields[i].get(origObj));
            }
            curClass = curClass.getSuperclass();
        } while (curClass != null);
    }
}
 

// Child1.java
package test;
 
/**
 * @author maulin
 */
public class Child1 extends Base {
    public Child1() {
        i=100;
        j=200;
    }
    public Child1(Base origObj) {        
        super(origObj);        
    }
}
 
// Child2.java
package test;
 
/**
 * @author maulin
 */
public class Child2 extends Child1 {
    public Child2() {
        i=1000;
        j=2000;
    }
    public Child2(Base origObj) {
        super(origObj);
    }
}
 

// TestCopy.java in different package
/**
 * @author maulin
 */
import test.*;
 
public class TestCopy {
 
    public static void main(String[] args) {
        Child1 ch1 = new Child1();
        Child2 ch21 = new Child2(ch1);
        Child2 ch22 = new Child2();
        
        System.out.println("ch1="+ch1);
        System.out.println("ch21="+ch21);
        System.out.println("ch22="+ch22);
    }
}

And the output is,
ch1=i=100,j=200
ch21=i=100,j=200
ch22=i=1000,j=2000


Is this correct behavior as expectations?


Regards,
Maulin

[Maulin Vasavada]

okay..okay...don't scream at me. I get the problem

I guess what Ilja suggested would be the only way out given that we have Security Permissions to call setAccessible() on the Field object..

Regards,
Maulin

[Michael Diamond]

Originally posted by Ilja Preuss:
fields[i].setAccessible(true);

Isn't this equivalent to setting the fields public?


Maulin: I like the idea of putting the function in the base class, but I have several object heirarchies I would like to use this with and I don't like having duplicate code. The project I inherited suffers greatly from this already so I was trying to avoid putting this function into each base class.

[Michael Diamond]

I am surprised that this doesn't seem to be a common pattern. Let me describe the problem I am trying to solve.

I have two objects, PurchaseRequest and PurchaseOrder. These objects share the same base class, OrderObject. When a request is approved, it is turned into a PurchaseOrder. I would like to create a new PurchaseOrder based upon the PurchaseRequest.

PurchaseOrder purchaseOrder = new PurchaseOrder((OrderObject) purchaseRequest);

The other option I thought about was cloning, but that does not allow me to create a new subclass from the cloned object. So this is essentially a deep copy of the superclass in the constructor of the subclass.

[Maulin Vasavada]

but I have several object heirarchies I would like to use this with and I don't like having duplicate code.

Thats why I said in my latest post that "I get the problem" I understand what you want but as you think, its difficult to do it in clean way w/o using setAccessible() thing

Regards,
Maulin

[Stan James]

Hmmm, maybe they shouldn't have a common superclass. Your constructor idea looks fine:

PurchaseOrder purchaseOrder = new PurchaseOrder(purchaseRequest); 

Maybe PurchaseOrder class keeps the existing PurchaseRequest object as a variable.

If you need to work at an abstract level where you can look at either type, you might make the common methods in an interface:

public interface OrderObject
{ 
   // define the methods 
}
 
public object PurchaseRequest implements OrderObject
{ 
   // implement all the methods with real code 
}
 
public object PurchaseOrder implements OrderObject
{ 
   // implement the methods, with pass-through calls to the
   // same method in the PurchaseRequest we got in the constructor 
   public int getQuantity()
   {
      return myRequest.getQuantity();
   }
}

Now you could have methods work on the abstract type:

public void workOn(OrderObject order)
{
   total = order.getQuantity() * order.getUnitPrice();
}

Any of that sound tempting?
[ October 14, 2004: Message edited by: Stan James ]