为什么在Java中将私有内部类成员公开？

Question

如果在 Java 中将私有内部类的成员声明为 public，但仍然无法在包含类之外访问该成员，那么原因是什么？或者可以吗？

public class DataStructure {
    // ...

    private class InnerEvenIterator {
        // ...

        public boolean hasNext() { // Why public?
            // ...
        }
    }
}

Answer 1

有许多没有用的访问修饰符组合。私有内部类中的公共方法仅在公共类/接口中实现公共方法时才有用。

public class DataStructure {
    // ...

    private class InnerEvenIterator implements Iterator {
        // ...

        public boolean hasNext() { // Why public?
            // ...
        }
    }

    public Iterator iterator() {
        return new InnerEvenIterator();
    }
}

顺便说一句：抽象类通常具有 public 构造函数，而实际上它们是 protected

Answer 2

如果内部类是私有的，则不能通过外部类外部的名称来访问它。内部类和外部类可以访问彼此的私有方法和私有实例变量。只要在内部类或外部类中，修饰符 public 和 private 就具有相同的效果。在您的代码示例中：

public class DataStructure {
    // ...

    private class InnerEvenIterator {
        // ...

        public boolean hasNext() { // Why public?
            // ...
        }
    }
}

就 DataStructure 类而言，这完全等同于：

public class DataStructure {
    // ...

    private class InnerEvenIterator {
        // ...

        private boolean hasNext() {
            // ...
        }
    }
}

这是因为只有 DataStructure 可以访问它，因此将其设置为 public 还是 private 并不重要。不管怎样，DataStructure 仍然是唯一可以访问它的类。使用您喜欢的任何修饰符，功能上没有区别。唯一不能随机选择的时间是在实施或扩展时，在这种情况下您不能减少访问权限，但可以增加访问权限。因此，如果抽象方法具有受保护的访问权限，您可以将其更改为公共。当然，两者实际上都没有任何区别。

如果您计划在其他类中使用内部类，并因此将其公开，那么您可能不应该首先将其设为内部类。

此外，我没有看到内部类扩展或实现其他类的任何要求。他们这样做可能很常见，但这肯定不是必需的。

Answer 3

这里必须考虑多个方面。下面将使用术语“嵌套类”，因为它涵盖非静态（也称为“内部类”）和静态类（源）。

与 private 嵌套类无关，但 JLS §8.2 有一个有趣的 示例 显示了包私有或 protected 类中的 public 成员可能有用的地方。

源代码

重写方法

当嵌套类实现接口或扩展类并重写其方法之一时，则按照 JLS §8.4.8.3：

重写或隐藏方法的访问修饰符必须至少提供与重写或隐藏方法一样多的访问权限

例如：

public class Outer {
  private static class Nested implements Iterator<String> {
    @Override
    public boolean hasNext() {
      ...
    }
    
    @Override
    public String next() {
      ...
    }
  }
}

重写的方法 hasNext() 和 next() Iterator 方法必须是 public，因为 Iterator 方法是公共的。

作为旁注： JLS §13.4.7 描述了类可以提高其方法之一的访问级别，即使子类覆盖它，也不会导致链接错误。

传达意图

访问限制在 JLS §6.6.1：

只有当类型可访问并且成员或构造函数被声明为允许访问时，引用类型的成员[...]才是可访问的

[...]

否则，成员或构造函数被声明为私有，并且当且仅当它出现在顶级类型的主体中时才允许访问（§7.6) 包含成员或构造函数的声明。

因此，私有嵌套类的成员（从源代码的角度来看；另请参见“反射”部分）只能从封闭的顶级类型的主体中访问。有趣的是，“主体”还涵盖了其他嵌套类：

public class TopLevel {
  private static class Nested1 {
    private int i;
  }

  void doSomething(Nested1 n) {
    // Can access private member of nested class
    n.i++;
  }

  private static class Nested2 {
    void doSomething(Nested1 n) {
      // Can access private member of other nested class
      n.i++;
    }
  }
}

因此，从编译器提供的访问限制的角度来看，在 private 嵌套类中使用 public 成员确实没有意义。

然而，使用不同的访问级别对于传达意图非常有用，特别是（正如其他人指出的那样）当嵌套类将来可能被重构为单独的顶级类时。考虑这个例子：

public class Cache {
  private static class CacheEntry<T> {
    private final T value;
    private long lastAccessed;

    // Signify that enclosing class may use this constructor
    public CacheEntry(T value) {
      this.value = value;
      updateLastAccessed();
    }

    // Signify that enclosing class must NOT use this method
    private void updateLastAccessed() {
      lastAccessed = System.nanoTime();
    }

    // Signify that enclosing class may use this method
    public T getValue() {
      updateLastAccessed();
      return value;
    }
  }

  ...
}

编译的类文件

注意 Java 编译器如何处理对嵌套类成员的访问也很有趣。在 JEP 181：基于 Nest 的访问控制（在 Java 11 中添加）之前，编译器必须创建合成访问器方法，因为类文件无法表达与嵌套类相关的访问控制逻辑。考虑这个例子：

class TopLevel {
  private static class Nested {
    private int i;
  }
    
  void doSomething(Nested n) {
    n.i++;
  }
}

-p ./TopLevel$Nested.class 检查时，您将看到添加了一个合成 access$008 方法：

class TopLevel$Nested {
  private int i;
  private TopLevel$Nested();
  static int access$008(TopLevel$Nested);
}

当使用 Java 8 编译并使用 javap 稍微增加了类文件的大小，并且可能会降低性能。这就是为什么经常为嵌套类的成员选择包私有（即无访问修饰符）访问以防止创建合成访问方法的原因之一。
对于 JEP 181，这不再是必要的（使用 JDK 11 编译时的 javap -v 输出）：

class TopLevel$Nested
...
{
  private int i;
  ...

  private TopLevel$Nested();
  ...
}
...
NestHost: class TopLevel
...

反射

另一个有趣的方面是反射。遗憾的是，JLS 在这方面没有具体验证，但 §15.12.4.3 包含一个有趣的提示：

如果 T 与 D 位于不同的包中，并且它们的包位于同一模块中，并且 T 是 public 或 protected，则 T 是可访问的。 p>

[...]

如果 T 是受保护的，那么它必然是嵌套类型，因此在编译时，它的可访问性会受到包含其声明的类型的可访问性的影响。但是，在链接期间，其可访问性不受包含其声明的类型的可访问性影响。此外，在链接期间，protected T 与 public T 一样可访问。

类似地，AccessibleObject.setAccessible(...)< /a> 没有提到完全封闭的类型。事实上，可以访问非 public 封闭类型中的 public 或 protected 嵌套类型的成员：
test1/TopLevel1.java

package test1;

// package-private
class TopLevel1 {
  private static class Nested1_1 {
    protected static class Nested1_2 {
      public static int i;
    }
  }
}

test2/TopLevel2.java

package test2;

import java.lang.reflect.Field;

public class TopLevel2 {
  public static void main(String... args) throws Exception {
    Class<?> nested1_2 = Class.forName("test1.TopLevel1$Nested1_1$Nested1_2");
    Field f = nested1_2.getDeclaredField("i");
    f.set(null, 1);
  }
}

这里反射能够修改字段 test1.TopLevel1.Nested1_1.Nested1_2.i 而无需使其可访问，尽管它位于包私有类内的 private 嵌套类中。

当您为运行不受信任的代码的环境编写代码时，您应该记住这一点，以防止恶意代码干扰内部类。
因此，当涉及嵌套类型的访问级别时，您应该始终选择最不宽松的类型，最好是私有或包私有。

Answer 4

如果 InnerEvenIterator 类没有扩展任何类或实现任何接口，我认为这是无稽之谈，因为没有其他类可以访问它的任何实例。

但是，如果它扩展或实现任何其他非私有类或接口，那就有意义了。一个例子：

interface EvenIterator {
    public boolean hasNext();
}


public class DataStructure {
    // ...

    private class InnerEvenIterator implements EvenIterator{
        // ...

        public boolean hasNext() { // Why public?
            // ...
        }
    }

    InnerEvenIterator iterator;

    public EvenIterator getIterator(){
         return iterator;
    }     

}

Answer 5

该方法可以设为public，以表明它在语义上是公开的，尽管编译器在这种特殊情况下并不强制执行可见性规则。

想象一下，在一些重构过程中，您需要使这个内部类成为顶级。如果此方法是私有，您如何决定是否应将其设为公共，或者应使用一些更具限制性的修饰符？将方法声明为 public 告诉读者原作者的意图 - 该方法不应被视为实现细节。

Answer 6

当您实现任何接口时它非常有用。

class DataStructure implements Iterable<DataStructure> {

    @Override
    public Iterator<DataStructure> iterator() {
        return new InnerEvenIterator();
    }
    // ...        

    private class InnerEvenIterator implements Iterator<DataStructure> {
        // ...    
        public boolean hasNext() { // Why public?
            // ...
            return false;
        }

        @Override
        public DataStructure next() {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }

    public static void main(String[] ex) {
        DataStructure ds = new DataStructure();
        Iterator<DataStructure> ids = ds.iterator();
        ids.hasNext(); // accessable            
    }
}

Answer 7

我认为您缺少示例代码中实现 Iterator 接口部分。在这种情况下，您不能使 hasNext() 方法具有除 public 之外的任何其他可见性标识符，因为这最终会降低其可见性（接口方法具有公共可见性） ）并且它不会编译。