Question

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

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”的引用，它编译导致我相信定义是正确的，但可能引用变量的方式是问题。或者它可能是实际的实现是错误的。不确定。

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

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);
    }
}

Answer 1

symbol: variable x
location: variable temp of type T
where T is a type-variable:
T extends Object declared in method tryThis(T)
^^^^^^^^^^^^^^^^

没有进一步说明，例如<T extends InnerClass1>，该方法中T唯一已知的是它扩展了Object，而对于Object，未定义属性x。

也许你应该为这两个类定义一个公共超类，并在那个超类中声明x。

Answer 2

为了动态获取每个类的值x，您可以为interface和abstract class定义InnerClass1或InnerClass2到implement 1}}或extend。这允许继承方法和变量。看到两者都包含T类型的值，让我们创建一个名为interface的{{1}}：

ValueHolder<T>

interface ValueHolder<T> { public T getValue(); }和InnerClass1都需要实现此接口：

InnerClass2

如您所见，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; } }实现了InnerClass1，这意味着继承的ValueHolder<Integer>方法返回类型将为getValue。 Integer也是如此，它实现了InnerClass2。

按如下方式更改ValueHolder<String>：

tryThis

现在每个值都可以这样打印：

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());

Answer 3

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

只是任何类的占位符。编译器对此一无所知，因此它对符号x也一无所知。

要完成你想要做的事，你需要这样的事情：

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);
    }

会做同样的事情。

泛型非常复杂，尽管它们看起来很容易使用。

调用使用泛型

3 个答案: