16

以下代码在 Java 1.6 中编译良好，但在 Java 1.7 中编译失败。为什么？

代码的相关部分是对私有“数据”字段的引用。该引用来自定义该字段的同一类中，因此看起来是合法的。但它是通过一个通用类型的变量发生的。这段代码——一个基于内部库中的类的精简示例——在 Java 1.6 中有效，但现在在 Java 1.7 中无效。

我不是在问如何解决这个问题。我已经这样做了。我试图找到解释为什么这不再起作用。想到了三种可能性：

  • 根据 JLS，这段代码不合法​​，不应该编译（1.6 编译器中有一个错误，在 1.7 中修复）
  • 根据 JLS，这段代码是合法的，应该可以编译（1.7 编译器中引入了向后兼容性错误）
  • 此代码属于JLS 中的灰色区域

Foo.java：

import java.util.TreeMap;
import java.util.Map;

public abstract class Foo<V extends Foo<V>> {

    private final Map<String,Object> data = new TreeMap<String,Object>();

    protected Foo() { ; }

    // Subclasses should implement this as 'return this;'
    public abstract V getThis();

    // Subclasses should implement this as 'return new SubclassOfFoo();'
    public abstract V getEmpty();

    // ... more methods here ...

    public V copy() {
        V x = getEmpty();
        x.data.clear();      // Won't compile in Java 1.7
        x.data.putAll(data); // "
        return x;
    }

}

编译器输出：

> c:\tools\jdk1.6.0_11\bin\javac -version
javac 1.6.0_11

> c:\tools\jdk1.6.0_11\bin\javac c:\temp\Foo.java

> c:\tools\jdk1.7.0_10\bin\javac -version
javac 1.7.0_10

> c:\tools\jdk1.7.0_10\bin\javac c:\temp\Foo.java
Foo.java:18: error: data has private access in Foo
        x.data.clear();
         ^
Foo.java:19: error: data has private access in Foo
        x.data.putAll(data);
         ^
2 errors

附录。如果引用的是私有方法而不是私有成员变量，则会出现同样的问题。这适用于 Java 1.6，但不适用于 1.7。

Foo2.java：

import java.util.TreeMap;
import java.util.Map;

public abstract class Foo2<V extends Foo2<V>> {

    private final Map<String,Object> data = new TreeMap<String,Object>();

    protected Foo2() { ; }

    // Subclasses should implement this as 'return this;'
    public abstract V getThis();

    // Subclasses should implement this as 'return new SubclassOfFoo();'
    public abstract V getEmpty();

    // ... more methods here ...

    public V copy() {
        V x = getEmpty();
        x.theData().clear();      // Won't compile in Java 1.7
        x.theData().putAll(data); // "
        return x;
    }

    private Map<String,Object> theData() {
        return data;
    }

}

编译器输出：

> c:\tools\jdk1.6.0_11\bin\javac c:\temp\Foo2.java

> c:\tools\jdk1.7.0_10\bin\javac c:\temp\Foo2.java
Foo2.java:18: error: theData() has private access in Foo2
        x.theData().clear();
         ^
Foo2.java:19: error: theData() has private access in Foo2
        x.theData().putAll(data);
         ^
4

1 回答 1

18

演示的问题似乎与Oracle 错误 6904536中报告的行为相匹配。该错误已作为“不是问题”关闭，解释如下：

javac 的行为符合 JLS。另请参阅6558551、6711619和相关的 JLS问题6644562。

对应的 JLS 问题未解决，注释如下：

欢迎对类型变量的成员资格进行简化解释。类型变量边界的私有成员存在普遍的困难。正式地，这些成员不会成为类型变量本身的成员，尽管 javac 和 Eclipse 传统上使它们成为成员并且代码已经开始依赖它：

class Test {
  private int count = 0;
  <Z extends Test> void m(Z z) {
    count = z.count;  // Legal in javac 1.6, illegal in javac 1.7 due to fix for 6711619
  }
}

彼得提交了一个类似的测试：

class A {
  static class B { private String f; }

  abstract static class Builder<T extends B> {
    abstract T getB();

    {
      ((B)getB()).f.hashCode();
      getB().f.hashCode(); // error: f has private access in A.B
    }

  }
}

由于交集类型是通过继承构造的，而私有成员永远不会被继承，因此重新指定交集类型以具有私有成员是很棘手的。尽管如此，这将是兼容的事情。

作为参考，JLS 的相关部分是§4.4。

编辑：

实际上，我倾向于同意这里的 JLS，因为当我们从图片中删除泛型时，它会与自身匹配。考虑这个例子：

static class Parent {

    private int i;

    void m(Child child) {
        i = child.i; //compile error
    }
}

static class Child extends Parent { }

child.i不可见，因为不继承对私有成员的访问。这一点很重要，因为它可以在没有任何阴影的情况下Child拥有自己的：i

static class Child extends Parent {
    private int i; //totally fine
}

所以这将是一个罕见的需要向上转换的例子：

void m(Child child) {
    i = ((Parent)child).i;
}

因此，由于继承了可访问性，因此 JLS 在这里似乎是正确的，因为VinFoo<V extends Foo<V>>不一定是，Foo<V>但可能是扩展的某种类型Foo<V>。

于 2013-04-08T04:56:41.237 回答