从 static 获取子 class 父 class 在 Java 中的方法

Question

Suppose I have these classes:

public class ChildClass extends ParentClass
{
    // some class definition here
}


public abstract class ParentClass
{
    public static void printClass()
    {
        // get the class that extends this one (and for example, print it)
    }

    // some class definition here
}

Lets say when calling ParentClass.printClass() I want to print the name of the class (like doing System.out.println(ParentClass.class) ). When then extending ParentClass (for example like in ChildClass ) and calling ChildClass.printClass() , I want it to print the name of the extending class (like doing System.out.println(ChildClass.class) ). Is this somehow possible?

I've found a way to get the class from inside a static method by using MethodHandles.lookup().lookupClass() , but when using it inside of ParentClass.printClass and extending ParentClass, then calling printClass on the extending Class, I always get the class of ParentClass .

Answer 1

Quoting @RealSkeptic :

Static methods are not inherited. The fact that you can call ChildClass.printClass() is just syntactic sugar. It actually always calls ParentClass.printClass(). So you can't do something like that with a static method, only an inheritable non-static one.

Answer 2

static methods are best thought of as living entirely outside of the class itself. The reason they do show up in classes is because of the design of java (the language) itself: Types aren't just types with a hierarchy, they also serve as the primary vehicle for java's namespacing system.

Types live in packages, packages are the top level namespace concept for types. So how do you refer to a method? There's only one way: Via the type system. Hence, static methods do have to be placed inside a type. But that's about where it ends.

They do not inherit, at all. When you write:

ChildClass.lookupClass()

The compiler just figures out: Right, well, you are clearly referring to the lookupClass() method in ParentClass so that is what I will compile. You can see this in action yourself by running javap -c -p MyExample . The same principle applies to non-static methods, even.

For instance methods, the runtime undoes this maneuvre: Whenever you invoke a method on any object, the runtime system will always perform dynamic dispatch; you can't opt out of this. You may write:

AbstractList<String> list = new ArrayList<String>();
list.sort(someComparator);

and you can use javap to verify that this will end up writing into the class file that the method AbstractList::sort is invoked. But, at runtime the JVM will always check what list is actually pointing at - it's an instance of ArrayList, not AbstractList (that's obvious: AbstractList is abstract; no object can ever be directly instantiated as `new AbstractList). If ArrayList has its own take on the sort method, then that will be called.

The key takeaway of all that is: Static methods do not inherit, therefore, this dynamic dispatch system is not available to them, therefore, what you want cannot be done in that fashion.

So what to do?

It feels like what you're doing is attempting to associate a hierarchy to properties that apply to the class itself. In other words, that you want there to be a hierarchical relationship between the notion of 'ParentClass's lookupClass method and ChildClass's lookupClass method - lookupClass is not a thing you ask an instance of ChildClass or ParentClass - you ask it at the notion of the these types themselves.

If you think about it for a moment, constructors are the same way. You don't 'ask' an instance of ArrayList for a new arraylist. You ask ArrayList, the concept. Both 'do not really do' inheritance and cannot be abstracted into a type hierarchy.

This is where factory classes come in .

Factory classes as a concept are just 'hierarchicalizing' staticness, by removing static from it: Create a sibling type to your class hierarchy ( ParentClassFactory for example):

abstract class ParentClassFactory {
  abstract ParentClass create();
  abstract void printClass();
}

and then, in tandem with writing ChildClass , you also write ChildClassFactory . Generally factories have just one instance - you may want to employ the singleton pattern for this. Now you can do it just fine:

class ChildClassFactory extends ParentClassFactory {
  private static final ChildClassFactory INSTANCE = new ChildClassFactory();
  public static ChildClassFactory instance() { return INSTANCE; }
  public ParentClass create() { return new ChildClass(); }
  public void printClass() { System.out.println(ChildClass.class); }
}

// elsewhere:

// actually gets the ChildClassFactory singleton:
ParentClassFactory factory = ....;
factory.printClass(); // will print ChildClass!