Discover my child class

Question

Gurus,
One which may violate OOP, but is useful nonetheless.
Is there currently any way to discover the class of the child through which a parent static method has been called? Here is an example.
I decide to implement many beans that are persistent. I prefer to move the common code, i.e. the persistence, into a single class, have it be the abstract parent, and have all the beans be children of it.
Thus, I may have the following:
public abstract class Parent {
  //lots of common code
public class ChildBean1 extends Parent {
  // Child1 specific code
}For the parent to implement the persistence, I would have the Parent do this.getClass() in its non-static methods (e.g. store() or persist()), introspect the bean, get the fields, and save the data. Easy.
The problem is what to do for finder and other static methods. I would want the Parent to implement them:
  public static Parent findOneBean(args) {
  }Thus, the user of the class would call:
ChildBean1 cb1 = ChildBean1.findOneBean(args1);
ChildBean2 cb2 = ChildBean2.findOneBean(args2);
..The problem is that unlike in the instance case, in the static case, the parent has no way of knowing which Class to Introspect and thus cannot tell anything about the Bean. I tried looking at the stack trace - no go. There is no "this" to speak of.
Is there any way to find out from the Parent? Should I submit an RFE?
Thanks.

Answer 1

Which makes sense to me. The only problem is back to
the original: there does not appear to be a way for
the method to find its own class. Even if there was, this could only determine the class in which the method is defined, not the calling class (which in your example just happens to be a subclass, but in general doesn't have to be).
Determining the class of the object/class which calls a method is already part of the StackTraceElement API.
Truth is, this is a general problem: a static method
really has no way of saying "give me my Class" the way
a non-static method can say this.getClass(), does it?True. But the equivalent of 'getClass()' would not return the class of the caller, which is what your example requires.
this.getClass() does the right thing, wherever it is called.It returns the class of the callee not the caller. This would not be the right thing in your class, as the class of the method would always be the superclass.
So what you're asking for is static methods to get the caller's class (in you case the specialized bean), but non-static methods to get the callee's class, such that:class A {
  static void foo {
    System.out.println(Thread.getCallerClass());
  static bar {
    System.out.println(this.getClass());
class B {
  static void main (String[] args) {
    A.foo();
    new A().bar();
    System.out.println(Thread.getCallerClass());
class C extends A {
  static void main (String[] args) {
    A.foo();
    new A().bar();
    System.out.println(Thread.getCallerClass());
}So, running B would print outB.class
A.class
some JVM loader classAnd running C would print outC.class
A.class
some JVM loader classI'm not sure that it's in any way useful. It certainly doen't correspond the getClass method.
Why do you need it anyway? If you cannot deduce what needs to be serialized from the type of the arguments to your static serialize method, then there is something wrong in the parameters. If it is, for example, the same data, but a subclass specific header, then have the subclass declare an abstract method that returns the header content.
Pete