Получение названия подкласса из суперкласса

Ваш вопрос неоднозначен, но насколько я могу судить, вы хотите узнать текущий класс из статического метода. Тот факт, что классы наследуют друг от друга, не имеет значения, но для обсуждения я также реализовал это таким образом.

class Parent {
    public static void printClass() {
      System.out.println(Thread.currentThread().getStackTrace()[2].getClassName());
    }
}

public class Test extends Parent {
    public static void main(String[] args) {
      printClass();
    }
}

Статический метод связан с классом, а не с конкретным объектом.

Подумайте, как это работало бы, если бы было несколько подклассов - например, администратор также является сущностью. Каким образом ваш статический метод Entity, связанный только с классом Entity, узнает, какой подкласс вам нужен?

Вы могли:

• Использовать существующий метод getClass ().
• Передайте аргумент вашему статическому методу getClass () и вызовите метод экземпляра для этого объекта.
• Сделайте ваш метод нестатическим и переименуйте его.

Не делайте метод статическим. Проблема в том, что когда вы вызываете getClass () , вы вызываете метод в суперклассе - статические методы не наследуются. Вдобавок вы, по сути, затеняет имя Object.getClass () , что сбивает с толку.

Если вам нужно зарегистрировать имя класса в суперклассе, используйте

return this.getClass().getName();

Это вернет «Entity», если у вас есть экземпляр Entity , «User», если у вас есть User ] экземпляр и т. д.

Почему вы хотите реализовать свой собственный метод getClass ()? Вы можете просто использовать

System.out.println(User.class);

Edit (чтобы уточнить): вы хотите, чтобы метод был статическим. В этом случае вы должны вызвать метод для класса, имя класса которого вы хотите, будь то подкласс или суперкласс. Затем вместо вызова MyClass.getClass () вы можете просто вызвать MyClass.class или MyClass.class.getName () .

Кроме того, вы создаете метод static с той же сигнатурой, что и метод экземпляра Object.getClass () , который не будет компилироваться.

Если я правильно понял ваш вопрос, я думаю, что единственный способ добиться желаемого - это повторно реализовать статический метод в каждом подклассе, например:

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 как вам нужно. Беспорядочно, но послушайте, если это ваши ограничения ...

Суперкласс не должен даже знать о существовании подкласса, не говоря уже о выполнении операций на основе полного имени подкласса. Если вам действительно нужны операции, основанные на конкретном классе, и вы не можете выполнить необходимую функцию путем наследования, вы должны сделать что-то в этом роде:

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 для выполнения операций. Скорее всего, он по-прежнему будет тесно связан с реализациями (как правило, это плохо, а если не плохо, то не особенно хорошо ), но я думаю, что такая структура лучше, чем суперкласс, выясняющий, что все из его подклассов.