java 子类有返回其类的方法

Question

好吧，也许这是一个愚蠢的问题。但我只是想知道这是否可以在java中完成。

abstract public class ParentClass<T> { 
  abstract public T getTest();
}

在子类中

public class SubClass extends ParentClass<MyObject> {
  public MyObject getTest() {
    // I can return the object with class MyObject
    return null;
  }
}

我的问题是我可以在子方法中返回类类型吗？我的意思是，是否可以通过在 ParentClass 中添加一些代码来完成，这样我就可以在下面执行此操作？

例如

public class Sub1Class extends parentClass<Object1> {
  public Object1 getTest() { }
  // I want to have a method that return it's class in the superclass
  public Sub1Class getItClassObject() { }
}

另一个例子

public class Sub2Class extends parentClass<Object2> {
  public Object2 getTest() { }
  // I want to have a method that return it's class in the superclass
  public Sub2Class getItClassObject() { }
}

，

public class Sub3Class extends parentClass<Object3> {
  public Object3 getTest() { }
  // I want to have a method that return it's class in the superclass
  public Sub3Class getItClassObject() { }
}

如果你看到，Sub1Class、Sub2Class 和 Sub3Class 中的 getItClassObject 方法将遵循它的类。但我不想为每个子类添加相同的方法，只想在 ParentClass 中添加一些代码（如果可行），因此在子类中，我只需直接调用 getItClassObject 即可，而无需在每个子类中编写所有代码。

通常我会像这样在 ParentClass 中添加方法。

abstract public class ParentClass<T> {
  abstract public T getTest();
  public Object getItClassObject() { }
}

所以在子类中我只是实例化该类，但我必须再次转换:(

Sub1Class sub1Class = new Sub1Class();
Sub1Class after1Cast = (Sub1Class) sub1Class.getItClassObject();

Sub2Class sub2Class = new Sub2Class();
Sub2Class after2Cast = (Sub2Class) sub2Class.getItClassObject();

我认为它不能在java中完成。但我不知道是否有解决这个问题的线索。谢谢

Answer 1

我想这就是你想要的。编译结果如下：

abstract class A {
    public abstract A getA();
}

class B extends A {
    // Declared to return a B, but it still properly overrides A's method
    @Override
    public B getA() {
        return new B();
    }
}

class C extends A {
    // Declared to return a B, but it still properly overrides A's method
    @Override
    public C getA() {
        return new C();
    }
}

如您所见，A 声明 getA() 方法返回一个 A。但是，您可以限制子类中的返回类型，如图所示。

Answer 2

我不确定我是否正确理解你的意图，但我认为内置的 Object.getClass() 方法会做你想要的。给定的类定义为：

public abstract class ParentClass<T> {
  public abstract T getTest();
}

class SubClassString extends ParentClass<String> {
   public String getTest() {
      return "";
   }
}

class SubClassInteger extends ParentClass<Integer> {
   public Integer getTest() {
      return Integer.valueOf(0);
   }
}

getClass() 将返回正确的运行时类

  public static void main(String[] args) {
      SubClassString subString = new SubClassString();
      // displays "class SubClassString"
      System.out.println(subString.getClass()); 

      SubClassInteger subInteger = new SubClassInteger();
      // displays "class SubClassInteger"
      System.out.println(subInteger.getClass());

      ParentClass<?> parentInstance = new SubClassInteger();
      // displays "class SubClassInteger"
      System.out.println(parentInstance.getClass());  
  }

Answer 3

我能想到的唯一方法是在扩展子类时告诉父类子类是什么（就像您对“T”所做的那样）。例如：

public abstract class ParentClass<T,U> { 
    abstract public T getTest();
    abstract public U getItClassObject();
}

他们像这样定义你的子类：

public class Sub1Class extends ParentClass<Object1,Sub1Class> {
    public Object1 getTest() { }
    public Sub1Class getItClassObject() { }
}

然后你可以做你想做的事情而无需类型转换：

Sub1Class sub1Class = new Sub1Class();
Sub1Class after1Cast = sub1Class.getItClassObject();

Answer 4

如果您的对象具有无参数构造函数（或所有对象具有某种一致形式的构造函数），则可以使用反射来执行此操作。一些伪代码是

public class MyClass {

    public MyClass instantiateType() {
       Class<?> actualClass = getClass();
       return actualClass.newInstance();
    }

}

“这是使用类的运行时类型，因此子类将返回它们的类型”。但这仅适用于无参数构造函数。