从超类中获取子类的名称

Question

假设我有一个名为Entity 的基类。在那个类中，我有一个静态方法来检索类名：

class Entity {
    public static String getClass() {
        return Entity.class.getClass();
    }
}

现在我有另一个类扩展它。

class User extends Entity {
}

我想获取用户的类名：

System.out.println(User.getClass());

我的目标是看到“com.packagename.User”输出到控制台，但我最终会得到“com.packagename.Entity”，因为实体类是直接从静态方法引用的。

如果这不是静态方法，则可以通过在 Entity 类中使用 this 关键字轻松解决此问题（即：return this.class.getClass()）。但是，我需要这种方法保持静态。关于如何解决这个问题的任何建议？

Answer 1

不要将方法设为静态。问题是，当您调用 getClass() 时，您正在调用超类中的方法 - 静态方法不会被继承。另外，你基本上是在给Object.getClass()命名，这令人困惑。

如果您需要在超类中记录类名，请使用

return this.getClass().getName();

当你有一个 Entity 实例时，这将返回“实体”，当你有一个 User 实例时返回“用户”，等等。

Answer 2

不可能。静态方法无论如何都不是运行时多态的。绝对不可能区分这些情况：

System.out.println(Entity.getClass());
System.out.println(User.getClass());

它们编译成相同的字节码（假设方法在Entity中定义）。

此外，您将如何以一种对多态有意义的方式调用此方法？

Answer 3

这对我有用

this.getClass().asSubclass(this.getClass())

但我不确定它是如何工作的。

Answer 4

您的问题含糊不清，但据我所知，您想通过静态方法了解当前类。类相互继承这一事实无关紧要，但为了便于讨论，我也以这种方式实现了它。

类父{ 公共静态无效打印类（）{ System.out.println(Thread.currentThread().getStackTrace()[2].getClassName()); } } 公共类测试扩展父{ 公共静态无效主要（字符串[]参数）{ 打印类（）； } }

Answer 5

超类甚至不应该知道子类的存在，更不用说基于子类的完全限定名执行操作了。如果您确实需要基于确切类的操作，并且无法通过继承执行必要的功能，您应该按照以下方式进行操作：

public class MyClassUtil
{
    public static String doWorkBasedOnClass(Class<?> clazz)
    {
        if(clazz == MyNormalClass.class)
        {
            // Stuff with MyNormalClass
            // Will not work for subclasses of MyNormalClass
        }

        if(isSubclassOf(clazz, MyNormalSuperclass.class))
        {
            // Stuff with MyNormalSuperclass or any subclasses
        }

        // Similar code for interface implementations
    }

    private static boolean isSubclassOf(Class<?> subclass, Class<?> superclass)
    {
        if(subclass == superclass || superclass == Object.class) return true;

        while(subclass != superclass && subclass != Object.class)
        {
            subclass = subclass.getSuperclass();
        }
        return false;
    }
}

（未经测试的代码）

这个类也不知道它自己的子类，而是使用Class 类来执行操作。最有可能的是，它仍然会与实现紧密联系在一起（通常是一件坏事，或者如果还不错，它也不是特别好），但我认为这样的结构比超类弄清楚什么要好它的所有子类都是。

Answer 6

为什么要实现自己的 getClass() 方法？你可以使用

System.out.println(User.class);

编辑（稍微详细一点）：您希望方法是静态的。在这种情况下，您必须在您想要其类名的类上调用该方法，无论是子类还是超类。然后，您可以直接调用MyClass.class 或MyClass.class.getName()，而不是调用MyClass.getClass()。

另外，您正在创建一个与 Object.getClass() 实例方法具有相同签名的 static 方法，该方法无法编译。

Answer 7

1. 在超类中创建成员 String 变量。
2. 将 this.getClass().getName() 添加到将值存储在成员 String 变量中的构造函数中。
3. 创建一个 getter 以返回名称。

每次实例化扩展类时，其名称都会存储在 String 中，并且可以通过 getter 访问。

Answer 8

静态方法与类相关联，而不是与特定对象相关联。

考虑如果有多个子类，这将如何工作——例如，Administrator 也是一个实体。您的静态 Entity 方法（仅与 Entity 类关联）如何知道您想要哪个子类？

你可以：

• 使用现有的 getClass() 方法。
• 将参数传递给您的静态 getClass() 方法，然后调用该对象的实例方法。
• 使您的方法成为非静态方法，然后重命名。

Answer 9

如果我正确理解你的问题，我认为你可以实现你想要的唯一方法是在每个子类中重新实现静态方法，例如：

class Entity {
    public static String getMyClass() {
        return Entity.class.getName();
    }
}

class Derived extends Entity {
    public static String getMyClass() {
        return Derived.class.getName();
    }
}

这将根据您的需要打印 package.Entity 和 package.Derived。凌乱但嘿，如果这些是你的限制......

Answer 10

如果我说得对，你想在静态方法的基类中使用你的子类 我认为您可以通过将类参数传递给方法来做到这一点

class Entity {
    public static void useClass(Class c) {
        System.out.println(c);
        // to do code here
    }
}

class User extends Entity {
}

class main{
    public static void main(String[] args){
        Entity.useClass(Entity.class);
    }
}

Answer 11

我的上下文：具有 XML 对象子类的超类实体。 我的解决方案： 在超类中创建类变量

Class<?> claz;

然后在子类中我会在构造函数中设置超类的变量

public class SubClass {
   public SubClass() {
     claz = this.getClass();
   }
}

Answer 12

这很简单

User.getClass().getSuperclass()