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将遵循它的类。但是我不想为每个子类添加相同的方法，只是想在ParentClasss中添加一些代码（如果可行），所以在子类中，我只需直接调用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

如果你的对象没有-arg构造函数（或者所有这些构造函数都有一致的构造函数形式），你可以使用反射来完成它。一些伪代码将是

public class MyClass {

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

}

这是使用类的运行时类型，因此子类将返回其类型。这只适用于no-arg构造函数。

java子类有返回其类的方法

4 个答案: