Java - Can the children of an abstract class (the "extends"-ers) instantiate themselves via their parents abstract method?" i.e. m = new this();"?

First things first, please be aware I am trying to express my question as best I can with my current knowledge and vocabulary, so please excuse this...

I have an abstract class in which I want to make a method where it instantiates itself.... Of course this is impossible in an abstract class, however, what I really want is for the concrete children (those classes that开发者_运维技巧 "extends") to inherit this instantiation so that they then can instantiate themselves....

Basically what I want to do is this:

MyAbstract a = new this();

However this isn't allowed... Is there any way I can do what I want?

Here is some non-compiling dream-code (i.e. code I wish worked). Basically I am wanting the ConcreteChild to call a method in which it create an object of itself. The method is inherited from it's parent.

public class Abstract {

    public void instantiateMyConcreteChild()
    {
        Abstract a = new this();
    }

}

public class ConcreteChild extends Abstract{

    public static void main(String[] args) {
        ConcreteChild c = new ConcreteChild();

        c.instantiateMyConcreteChild();
    }

}

* Additional info **

Thanks for the replies but I think I missed something vital....

Basically I wanted to pass an object's self ( "this" ) into some methods of some other classes. However, creating instantiating another object within an object is a bit backwards, I can just pass "this", right...

You can do this using reflection, something like :

Abstract a = getClass().newInstance();

This is because getClass() always returns the concrete class, so this.getClass() will return the real subclass and not the current class.

However, beware that if the subclass defines a custom constructor, having more or less parameters than your abstract class, it could fail. Unless you specify in the documentation that subclasses must have a constructor with such given parameters ... but it's fragile anyway.

You can inspect it, using getClass().getConstructors() and see which constructors are there, and if there is the one you are expecting, or even search for a viable one, otherwise you can catch the exception thrown by newInstance(..), and wrap it in a more descriptive exception for the users, so that they understand better what they missed ... but it would still be a kind of a hack, cause there is no explicit language support for such a situation.

Another approach could be to implement Cloneable in your abstract class, and then use the clone method, but it could be overkill or even wrong if what you want is a new, clean instance.

You can't do this using an instance method. Because as the name implies an instance methods requires that the instance has already instantiated.

What you actually need to do here is to separate the non-changing internal functionality from the abstract class itself. So what I could do is to ,for e.g., have an inner class that really encapsulates the non-changing functionality like so:

public class Abstract {

   public void instantiateMyConcreteChild()
   {
       Abstract a = new NonChangingOperations();
   }

   class NonChangingOperations
   {
       public void operationA() {}
   }

}

Infact you really dont need to keep the class NonChangingOperations as an inner class, you could make it as an external utility class with its own class hierarchy.

Are you trying to define a constructor that the subclasses of Abstract can use? If so you could simply do it the same way you define any other constructor.

public class Abstract {

Abstract() {
    //set fields, etc. whatever you need to do
}

}

public class ConcreteChild extends Abstract{

    ConcreteChild() {
        //call superclass's constructor
        super();
    }
}

Could you just have this ?

public abstract class AbstractClassWithConstructor {


    public AbstractClassWithConstructor() {
        init();
    }

    protected abstract void init();
}

FYI

In the objective-c you need to set this by calling method init. The the method init() would look like this:

protected AbstractClassWithConstructor init() {
        return this;
    }