copying field by field in a constructor - I need a more succint form

Question

I am trying to write a constructor that creates an instance of a class from an already existing instance of a super class; I am aware of aggregation - I could have created a field of type MyClass - but I do not want to use it. So what I do is take each field in turn and initialize it, like below:

public MyClassExtension extends MyClass
{
    Object new_field;

    public MyClassExtension(MyClass instance) 
    {
        this.field_1 = instance.field_1;
        this.field_2 = instance.field_2;

            ......
        this.field_20= instance.field_20;

        this.new_field= some_value;
    }
}

The problem is that this approach is pretty verbose. Is there a shorter form of achieving the same result?

Attempts:

• calling super(instance) gives 'the constructor is undefined' error; indeed, there is no such constructor; even if I created it, the same question applies to that constructor

• calling this(instance) gives 'recursive constructor invocation' error, which is normal, since I am calling a method from within itself with no stop condition

Context information: MyClass is a javax.persistence.Entity, thus the large number of fields. MyClassExtension adds some booleans that store the visibility of UI elements, depending on the data.

Note: I am constrained to use this approach by the technology stack. Prior to EL 2.2 I cannot call a backend method from JSF, to determine the visibility of a UI element. see: How to call a method with a parameter in JSF

EDIT: I have read Copy constructor using reflection, but none of the answers is applicable to me:

• first answer: I cannot introduce an external library in an existing project without the approval of my manager; I need a core Java functionality

• second answer: I have already tried super() - see above - I won't duplicate my explanation

Answer 1

What you can do is this:

public MyClassExtension(MyClass instance) {
    super(...);
    new_field = some_value;
}

When creating a child class, it is good practice to call the super constructor (otherwise the default super constructor will be called by default).

Why so? Because it limits the number of times you need to redefine the same initialization. Eg when you want to create an object with default values. You only do it once, in the mother class and call by default the default super constructor when creating sub-classes. You may also override default values in sub-classes, depending on how you defined your class.

Here is an example: assuming you have MyClass defined like this:

class MyClass {
    protected Object field1;
    protected Object field2;
    protected Object field3;

    public MyClass(MyClass c) {
        field1 = c.field1; // Remark: this is only the setup of
        field2 = c.field2; // the reference. If you want to create a
        field3 = c.field3; // copy, please do so with a constructor.
    }

    public MyClass(Object field1, Object field2, object field3) {
        this.field1 = field1; // Same remark here
        this.field2 = field2; // (about references).
        this.field3 = field3;
    }
}

You see here that MyClass has 2 constructors defined: a so-called copy constructor that takes a MyClass object as a parameter and a constructor with all the needed fields.

Then, when you want to create a sub-class with a MyClass object as a parameter, you can do this:

class MyClassExtension extends MyClass {
    private Object newField;

    public MyClassExtension(MyClass c, Object newField) {
        super(c);
        this.newField = newField;
    }
}

But you can also do this:

class MyClassExtension {
    private Object newField;

    public MyClassExtension(MyClass c, Object newField) {
        super(c.field1, c.field2, c.field3);
        this.newField = newField;
    }
}

Hence, you limit the number of accesses to the MyClass object parameter and the sub-class MyClassExtension constructor is concise.

Note that you do have to provide this code at some place or the other in your program. You have to define to your compiler how to build a MyClassExtension given a MyClass object. Either the code is in MyClass or both in MyClass and MyClassExtension. I'm only providing a way to reduce the codebase and limit the number of changes needed if you want to change anything in your code. With this solution, if you change the MyClass constructor, MyClassExtension will be affected too (unless you enforce something else).

Also note that you need to define your copy constructors yourself because otherwise the compiler just won't know whether you want to deep copy or simply reference copy. More information here http://blog.amitinside.com/Copy-Constructor-in-Java/