为什么这段代码在 Java 1.6 中编译,但在 Java 1.7 中却没有?

2022-09-03 06:48:38

以下代码在 Java 1.6 中编译良好,但在 Java 1.7 中无法编译。为什么?

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

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

  • 根据JLS,此代码是不合法的,并且不应该编译(1.6编译器中存在错误,在1.7中修复)
  • 根据JLS,此代码是合法的,应该编译(1.7编译器中引入了向后兼容性错误)
  • 此代码在 JLS 中属于灰色区域

傅.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);
         ^

答案 1

演示的问题似乎与 Oracle 错误6904536中报告的行为相匹配。该错误已作为“不是问题”关闭,并具有以下说明:

javac的行为符合JLS。另请参阅65585516711619和相关 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不可见,因为不会继承对私有成员的访问权限。这一点是由一个事实驱动的,它可以在没有任何阴影的情况下拥有自己的:Childi

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

因此,这将是一个罕见的需要上倾的例子

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

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


答案 2

推荐