Java 扩展的Queision on“；如何引用子类变量而不在父类中声明该变量； 公共类测试{ 公共静态void main（最终字符串[]args）{ B=新的B（）； 系统输出打印ln（b）； } } 接口MyInterface{ int getX（）； } 抽象类A实现MyInterface{ @凌驾 公共字符串toString（）{ 返回字符串.valueOf（getX（））； } } 类B扩展了A，实现了MyInterface{ 专用静态最终整数X=10； @凌驾 公共int getX（）{ 返回X； } } C类{ //这是一节具体的课 }

我无法使用泛型增强此接口。 它在抽象类或实现类中抛出错误。

---

我怎样才能做到这一点

你的意思是这样的吗

public class Test {
    public static void main(final String[] args) {
    B b = new B();
    System.out.println(b);
    }
}

interface MyInterface<T> {
    int getX();
}

abstract class A implements MyInterface {
    @Override
    public String toString() {
    return String.valueOf(getX());
    }
}

class B extends A, implements MyInterface<C> {
    private static final int X = 10;

    @Override
    public int getX() {
    return X;
    }
}

class C  {
    // This is concrete class some 
}

公共类测试{
公共静态void main（最终字符串[]args）{
MyInterface b=新的b（）；
系统输出打印ln（b）；
}
}
接口MyInterface{
T getX（）；
}
抽象类A实现MyInterface{
@凌驾
公共字符串toString（）{
返回字符串.valueOf（getX（））；
}
}
B类扩展了A类{
//专用静态最终整数X=10；
专用静态最终双X=10；
//@凌驾
公共双getX（）{
返回X；
}
}

公共类MyTest2{
公共静态void main（最终字符串[]args）{
B=新的B（）；
系统输出打印ln（b）；
}
}
接口MyInterface{
int getX（）；
}
抽象类A实现MyInterface{
@凌驾
公共字符串toString（）{
返回字符串.valueOf（getX（））；
}
}
B类扩展了A类{
专用静态最终整数X=10；
@凌驾
公共int getX（）{
返回X；
}
}
C类{
//这是一节具体的课
}

上面的代码甚至可以编译吗？问题到底出在哪里还不清楚？如果你不打算使用它，为什么你的界面会有一个类型参数

T

？重点是什么？我说不出你想完成什么。“用泛型增强这个接口”并没有告诉我什么。我将使用这个T。我并没有显示细节来简化我的问题，我得到了错误。接口MyInterface不能使用不同的参数实现多次：MyInterface和MyInterface。我的想法是我需要在A中使用/调用getX（）的实现。这就是为什么我需要在AIt中实现MyInterface并没有简化这个问题，它使答案变得不可能。你的问题是，“我如何使之成为可能？”——我不知道你想让什么成为可能，因为你已经简化了你问题中的所有重要信息。

public class Test {
    public static void main(final String[] args) {
        MyInterface b = new B();
        System.out.println(b);
    }
}

interface MyInterface<T> {
    T getX();
}

abstract class A<T> implements MyInterface {
    @Override
    public String toString() {
        return String.valueOf(getX());
    }
}

class B extends A {
    //private static final int X = 10;
    private static final double X = 10;

    //@Override
    public Double getX() {
        return X;
    }
}

public class MyTest2 {
    public static void main(final String[] args) {
    B b = new B();
    System.out.println(b);
    }
}

interface MyInterface<T> {
    int getX();
}

abstract class A<T> implements MyInterface {
    @Override
    public String toString() {
    return String.valueOf(getX());
    }
}

class B extends A<C>  {
    private static final int X = 10;

    @Override
    public int getX() {
    return X;
    }
}

class C  {
    // This is concrete class some
}