Why isn't there a simpler way to initialize a subclass with its super class

Question

Let me explain my doubt with an example...
public class Parent {
�    public String parent;
public class Child extends Parent{
�    public String child;
I've an instance of Parent p. I want to construct Child c, with the data in p.
The only way that is provided by Java language seems to be, having a constructor in Child like
public class Child extends Parent{
�    public String child;
�    public Child(Parent p){
�    �    parent = p.parent;
�    }
The problem with this is there is lot of redundant assignment code.
What I don't understand is why there is not a simpler way of doing this when a subclass is after all super class data + some other data(excuse me for not looking at the bahavior part of it)
I'm looking for something as simple as Child c = p, which I know is wrong and know the reasons too.
Yes, we can wrap Child over Parent to do this, but it necessitates repeating all the methods in Parent.
Why is the language writers didn't provide a simple way of doing this? I should be missing something here...I'm just searching for an explanation. May be I'm asking a dumb question, but this bugs me a lot...
Regards,
Kothapalli.

Answer 1

To answer DrClap, I'm demanding it now :-). Let me
not suggest something that Mr.Gosling didn't think of;
he should be having some reasons in not providing it.Because it's essentially impossible in the general case. One of the reasons you may be extending a class is to add new invariants to the superclass.
eg- extend java.awt.Rectangle by BoundedRectangle - extra invariant that none of its corner points may be less than 0 or more than 100 in any dimension. (The rectangle must be entirely contained in the area (0,0)-(100,100))
What would happen if you try to create a BoundedRectangle from a rectangle representing (50,50)-(150,150)? Complete invariant breakdown, with no generic way to handle it, or even recognise it.
Actually, BIJ and sgabie are asking for it. Provide an
automatic copy constructor. Every object should have
an implicit copy constructor defined. From any
subclass, I should be able to invoke
super(parentClass). From the subclass, we can invoke
super(parentClass) first and then go on to initialize the
subclass data.
I really don't know the implementation issues of this,
but what I'm looking for is something like this. I'm just
curious to know the implementation issues.Implementation issue #1: Classes that should not, under any circumstane, be copied.
* eg 1- Singleton objects. If there's an automatic copy constructor, then multiple singletons can be created, making them essentially useless. This by extension kills the Typesafe Enum pattern also.
* eg 2- Objects with extra information, such as java.sql.Connection - if you copied this, would the copy be using the same socket connection, or would another connection be required? What happens if opening another connection, and the JDBC driver requires the password to be entered for every new connection? If the wrong password is entered, what happens to the newly creating connection?
Implementation issue #2: Copying implementation?
* Already mentioned by RPWithey. The only guaranteed way to perform the copy would be with a shallow copy, which may end up breaking things.
Why can't you write the copy constructor yourself? If it's a special case, it only has to be done once. If it's a recurring case, you could write a code generation tool to write them for you, along with most of the rest of the class.