Way to make Java parent class method return object of child class

Is there any elegant way to make Java method located within parent class return object of child class, when this method is called from child class object?

I want to implement this without using additional interfaces and extra methods, and to use this without class casts, auxiliary arguments and so on.

Update:

Sorry that I was not so clear.

I want to implement method chaining, bu开发者_Python百科t I have problems with methods of parent class: I lose access to child class methods, when i call parent class methods... I suppose that I'v presented the core of my idea.

So the methods should return this object of this.getClass() class.

If you're just looking for method chaining against a defined subclass, then the following should work:

public class Parent<T> {

  public T example() {
    System.out.println(this.getClass().getCanonicalName());
    return (T)this;
  }
}

which could be abstract if you like, then some child objects that specify the generic return type (this means that you can't access childBMethod from ChildA):

public class ChildA extends Parent<ChildA> {

  public ChildA childAMethod() {
    System.out.println(this.getClass().getCanonicalName());
    return this;
  }
}

public class ChildB extends Parent<ChildB> {

  public ChildB childBMethod() {
    return this;
  }
}

and then you use it like this

public class Main {

  public static void main(String[] args) {
    ChildA childA = new ChildA();
    ChildB childB = new ChildB();

    childA.example().childAMethod().example();
    childB.example().childBMethod().example();
  }
}

the output will be

org.example.inheritance.ChildA 
org.example.inheritance.ChildA 
org.example.inheritance.ChildA 
org.example.inheritance.ChildB 
org.example.inheritance.ChildB

What are you trying to achieve ? It sounds like a bad idea. A parent class should not know anything about its children. It seems awfully close to breaking the Liskov Substitution Principle. My feeling is that your use case would be better serve by changing the general design, but hard to say without more informations.

Sorry to sound a bit pedantic, but I get a bit scared when I read such question.

Simply to demonstrate:

public Animal myMethod(){
  if(this isinstanceof Animal){
     return new Animal();
  }
  else{

     return this.getClass().newInstance();
  }
}

You can call this.getClass() to get the runtime class.

However, this is not necessarily the class that called the method (it could be even further down the hierarchy).

And you would need to use reflection to create new instances, which is tricky, because you do not know what kind of constructors the child class has.

return this.getClass().newInstance(); // sometimes works

I know exactly what you mean, in Perl there is the $class variable which means if you call some factory method on a subclass, even if it is not overridden in the subclass, if it instanciates any instances of $class an instance of the subclass will be created.

Smalltalk, Objective-C, many other languages have a similar facility.

Alas, there is no such equivalent facility in Java.

If you are using Kotlin, you can create an extension function

abstract class SuperClass
class SubClass: SuperClass()

fun <T : SuperClass> T.doSomething(): T {
    // do something
    return this
}

val subClass = SubClass().doSomething()

public class Parent {
    public Parent myMethod(){
        return this;
    }
}
public class Child extends Parent {}

And invoke it like

       Parent c = (new Child()).myMethod();
       System.out.println(c.getClass());

Is this solution is correct? If it is, then, how is it different from the #1 solution?