根据Java中的子类类型定义父类方法的泛型类型

是否可以根据子类类型动态地将T标识为返回类型？ 我想要像下面这样的东西：

public class Parent {
        public <T extends Parent> T foo() {
                return (T)this;
        }
}

public class Child extends Parent {
        public void childMethod() {
                System.out.println("childMethod called");
        }
}

如果不这样定义类型：

Child child = new Child();
child.foo().<Child>childMethod(); // compiles fine

Child-Child=new-Child（）；
child.foo（）.childMethod（）；//编撰精良

提前谢谢

您想要这个：

public class Parent<T extends Parent<T>> {
    public T foo() {
        return (T)this;
    }
}

public class Child extends Parent<Child> {
    public void childMethod() {
        System.out.println("childMethod called");
    }
}

Child child = new Child();
child.foo().childMethod(); // compiles

公共类父类{
公共图书馆{
返回（T）这个；
}
}
公共类子级扩展父级{
公共方法（）{
System.out.println（“调用的childMethod”）；
}
}
子项=新子项（）；
child.foo（）.childMethod（）；//汇编

在Java类型系统中，

Parent

不可能引用该

的确切类。但是，它可以有一个类型参数（比如
T
），子类可以将其指定为自己或其他类型（无论它们想要什么），并使用抽象方法将获取该类型
T
的实例的任务委托给子类

public abstract class Parent<T> {
    // the implementer is responsible for how to get an instance of T
    public abstract T getT();
    // in this case, foo() is kind of redundant
    public T foo() {
        return getT();
    }
}

public class Child extends Parent<Child> {
    public Child getT() {
        return this;
    }
    public void childMethod() {
        System.out.println("childMethod called");
    }
}

Child child = new Child();
child.foo().childMethod(); // compiles

公共抽象类父类{
//实现者负责如何获取T的实例
公共摘要T getT（）；
//在本例中，foo（）有点多余
公共图书馆{
返回getT（）；
}
}
公共类子级扩展父级{
公共子getT（）{
归还这个；
}
公共方法（）{
System.out.println（“调用的childMethod”）；
}
}
子项=新子项（）；
child.foo（）.childMethod（）；//汇编
子级扩展父级
，对吗？应该
子级
扩展
父级
？对，我已经编辑了代码。谢谢！：）@chaplian这样做的目的是什么：child.foo（）.childMethod（）？相同的结果将是child.childMethod（）。只是为了能够编写内联语句。更简单的是：公共类Parent{}，类child扩展Parent{}，main:Parent instance=newparent（）@溶剂化剂否。您的代码会在绑定中产生原始类型
父类
，这是非常不受欢迎的啊，是的，没有注意到..如果没有inheritance@Bohemian你为什么要使用而不是？@solvator我在上面的评论中已经回答了这个问题，但这里再次说明。。。如果给父级一个泛型参数，则它的每次使用都应该有该参数，否则将得到原始类型（未指定参数的类。虽然它看起来像无限递归，
Parent
是您在避免使用原始类型的同时指定子类的泛型绑定的方式。当使用原始类型时，所有泛型信息都会从类中剥离（几乎，但不完全，像它的
Parent
）
public abstract class Parent<T> {
    // the implementer is responsible for how to get an instance of T
    public abstract T getT();
    // in this case, foo() is kind of redundant
    public T foo() {
        return getT();
    }
}

public class Child extends Parent<Child> {
    public Child getT() {
        return this;
    }
    public void childMethod() {
        System.out.println("childMethod called");
    }
}

Child child = new Child();
child.foo().childMethod(); // compiles