Java &引用；错误：找不到符号"；调用使用泛型定义的方法时

在阅读泛型信息之后，我尝试了一个简单的示例，遇到了以下错误

MyClass.java:32: error: cannot find symbol
System.out.println("X = " + temp.x);
^
symbol: variable x
location: variable temp of type T
where T is a type-variable:
T extends Object declared in method tryThis(T)
1 error

在没有引用“temp.x”的情况下，它进行编译，这让我相信定义是正确的，但变量引用的方式可能是问题所在。或者可能是实际的实现是错误的。不确定

主类有一个方法，可以由两个内部类中的任何一个调用。调用时，该方法尝试访问特定于调用它的内部类的变量

public class MyClass {
    public class InnerClass1 {
        int x = 100;
        public void runThis() {
            tryThis(this);
            return;
        }
    }

    public class InnerClass2 {
        int x = 200;
        public void runThis() {
            tryThis(this);
            return;
        }
    }

    public static void main(String[] args) {
        MyClass x = new MyClass();
    }

    private <T> void tryThis(T temp) {
        System.out.println("X = " + temp.x);
    }
}

公共类MyClass{
公共类1{
int x=100；
public void runThis（）{
tryThis（这个）；
返回；
}
}
公共类InnerClass2{
int x=200；
public void runThis（）{
tryThis（这个）；
返回；
}
}
公共静态void main（字符串[]args）{
MyClass x=新的MyClass（）；
}
私人真空试验（温度）{
系统输出打印项次（“X=”+温度X）；
}
}

如果没有进一步的规范，例如

，那么该方法中关于

T

的唯一已知的事情就是它扩展了

对象

，对于

对象

，属性

x

没有定义

---

也许您应该为这两个类定义一个通用的超类，并在该超类中声明

x

。

以便动态地从每个类中获取值

x

，您可以为

InnerClass1

和

InnerClass2

定义通用

接口

或

抽象类

，以

实现

或

扩展

。这允许继承方法和变量。鉴于两者都持有类型为

T

的值，让我们创建一个名为

ValueHolder

的

接口

：

如您所见，

InnerClass1

实现了

ValueHolder

，这意味着继承的

getValue

方法返回类型将是

Integer

。

InnerClass2

也是如此，它实现了

ValueHolder

将您的

尝试更改此
，如下所示：

private <T> void tryThis(ValueHolder<T> temp) {
    System.out.println("Value = " + temp.getValue());
}

输出：

X = 100
X = 200

不在

我们也将实现同样的目标

泛型非常复杂，尽管它们看起来很容易使用。
泛型
T
默认为
Object
，而
Object
没有
x
。好的，知道它是一个对象，我可以修改代码以检查“instanceof”，然后适当地转换变量以使其工作。“泛型非常复杂，尽管它们看起来很容易使用。”很高兴你这么说。这让我感觉好多了。；-）很高兴让你高兴！；）谢谢，我喜欢这个实现。
public class InnerClass1 implements ValueHolder<Integer> {
    private int x = 100;

    @Override
    public Integer getValue() {
        return this.x;
    }
}

public class InnerClass2 implements ValueHolder<String> {
    public String x = "200";

    @Override
    public String getValue() {
        return this.x;
    }
}

private <T> void tryThis(ValueHolder<T> temp) {
    System.out.println("Value = " + temp.getValue());
}

Generics g = new Generics();
g.tryThis(new InnerClass1());
g.tryThis(new InnerClass2());

X = 100
X = 200

private <T> void tryThis(T temp)</code>

public class Generics {

    abstract class MyClass {
        int x;
    }

    public class InnerClass1 extends MyClass {
        InnerClass1() {
            super.x = 100;
        }

        public void runThis() {
            tryThis(this);
            return;
        }
    }

    public class InnerClass2 extends MyClass {
        InnerClass2() {
            super.x = 200;
        }

        public void runThis() {
            tryThis(this);
            return;
        }
    }

    public static void main(String[] args) {
        Generics x = new Generics();

        x.new InnerClass1().runThis();
        x.new InnerClass2().runThis();
    }

    private <T extends MyClass> void tryThis(T temp) {
        System.out.println("X = " + temp.x);
    }

}

    private void tryThis2(MyClass temp) {
        System.out.println("X = " + temp.x);
    }