java - sirve - Obtener el nombre de una subclase dentro de una superclase

super en java

Question

Digamos que tengo una clase base llamada Entity . En esa clase, tengo un método estático para recuperar el nombre de clase:

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

Ahora tengo otra clase extender eso.

class User extends Entity {
}

Quiero obtener el nombre de clase de Usuario:

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

Mi objetivo es ver el resultado "com.packagename.User" en la consola, pero en su lugar voy a terminar con "com.packagename.Entity" ya que la clase Entity se referencia directamente desde el método estático.

Si esto no fuera un método estático, esto podría resolverse fácilmente usando la palabra clave this dentro de la clase Entity (es decir: return this.class.getClass() ). Sin embargo, necesito este método para permanecer estático. ¿Alguna sugerencia sobre cómo abordar esto?

Answer 1

1. Cree una variable de cadena miembro en la superclase.
2. Agregue this.getClass (). GetName () a un constructor que almacena el valor en la variable String miembro.
3. Crea un getter para devolver el nombre.

Cada vez que se crea una instancia de la clase extendida, su nombre será almacenado en la Cadena y accesible con el captador.

Answer 2

¿Por qué quieres implementar tu propio método getClass ()? Puedes simplemente usar

System.out.println(User.class);

Editar (para elaborar un poco): Desea que el método sea estático. En ese caso, debe llamar al método en la clase cuyo nombre de clase desea, ya sea la subclase o la superclase. Entonces, en lugar de llamar a MyClass.getClass() , simplemente puede llamar a MyClass.class o MyClass.class.getName() .

Además, está creando un método static con la misma firma que el método de instancia Object.getClass() , que no se compilará.

Answer 3

Esto funciona para mí

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

Pero no estoy seguro de cómo funciona.

Answer 4

Imposible. Los métodos estáticos no son polimórficos en tiempo de ejecución de ninguna manera. Es absolutamente imposible distinguir estos casos:

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

Compilan con el mismo código de bytes (suponiendo que el método esté definido en Entity ).

Además, ¿cómo llamarías a este método de una manera en la que tendría sentido que fuera polimórfico?

Answer 5

La superclase ni siquiera debería conocer la existencia de la subclase, y mucho menos realizar operaciones basadas en el nombre completo de la subclase. Si necesita operaciones en función de la clase exacta y no puede realizar la función necesaria por herencia, debe hacer algo en esta línea:

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;
}
}

(Código no probado)

Esta clase tampoco conoce sus propias subclases, sino que usa la clase Class para realizar operaciones. Lo más probable es que siga estando estrechamente relacionado con las implementaciones (generalmente algo malo, o si no está mal, no es especialmente bueno ), pero creo que una estructura como esta es mejor que una superclase que averigüe cuáles son todas sus subclases.

Answer 6

Mi contexto: superclase Entidad con subclases para objetos XML. Mi solución: crear una variable de clase en la superclase

Class<?> claz;

Luego, en la subclase, establecería la variable de la superclase en el constructor

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

Answer 7

No hagas el método estático. El problema es que cuando getClass() estás llamando al método en la getClass() : los métodos estáticos no se heredan. Además, básicamente eres Object.getClass() - Object.getClass() que Object.getClass() , lo cual es confuso.

Si necesita registrar el nombre de clase dentro de la superclase, use

return this.getClass().getName();

Esto devolverá "Entidad" cuando tenga una instancia de Entity , "Usuario" cuando tenga una instancia de User , etc.

Answer 8

Si entiendo su pregunta correctamente, creo que la única forma en que puede lograr lo que desea es volver a implementar el método estático en cada subclase, por ejemplo:

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

Esto imprimirá el paquete.Edad y paquete. Derivado como lo requiera. Desordenado pero bueno, si esas son tus limitaciones ...

Answer 9

Si lo estoy haciendo bien, quiere usar su subclase en la clase base en método estático, creo que puede hacerlo pasando un parámetro de clase al método

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 10

Su pregunta es ambigua pero, por lo que puedo decir, desea conocer la clase actual desde un método estático. El hecho de que las clases se hereden entre sí es irrelevante, pero por el bien de la discusión lo implementé de esta manera también.

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(); } }

Answer 11

Un método estático está asociado con una clase, no con un objeto específico.

Considere cómo funcionaría esto si hubiera múltiples subclases; por ejemplo, el Administrador también es una Entidad. ¿Cómo sabría su método de Entidad estática, asociado solo con la clase Entidad, qué subclase quería?

Tú podrías:

• Use el método getClass () existente.
• Pase un argumento a su método estático getClass () y llame a un método de instancia en ese objeto.
• Haga que su método no sea estático y cambie el nombre.

Answer 12

es muy simple hecho por

User.getClass (). GetSuperclass ()